I’ve been happily using Woodpecker CI to get CI for my repositories on Codeberg. Codeberg is a non-profit community-driven git repository hosting platform, so they can’t provide free CI to everyone.

Since I run lots of stuff on small arm boards (for example this website), I need my CI jobs to create arm executables. The easiest way to get that done is to just compile on arm devices, so I was happy to see that Hetzner is now offering arm nodes in their cloud offering.

To make that as cheap as possible, the CI should ideally create a VM before running its job, and remove it again afterwards. Unfortunately Woodpecker does not seem to support that out of the box at this point.

My solution to that was to build a docker proxy, that creates VMs using docker-machine, and then proxies the incoming requests to the remote VM. That works really well now, so maybe you will find it useful.

Setting that up is reasonably simple:

• Install docker-machine. I recommend using the fork by GitLab
• Install the backend for your cloud provider. For Hetzner I use this one
• Grab a binary release of docker-proxy (if you need arm executables), or compile it yourself.
• Create a systemd unit to start the service on boot in /etc/systemd/system/docker.proxy.service. This particular one just runs it on the woodpecker-agent user that you may already have if you use Woodpecker CI.

[Unit]
Description=Docker CI proxy
After=network.target

[Service]
User=woodpecker-agent
Group=nogroup
Restart=always
ExecStart=/usr/local/bin/docker-proxy

[Install]
WantedBy=multi-user.target

• Fill in /etc/docker-proxy/config.toml This example works for Hetzner, but everything that has a docker-machine provider should work. You just need to supply the arguments for the correct backend.

[docker_machine]
driver="hetzner"
args=[
    "--hetzner-api-token=<token>",
    "--hetzner-server-type=cax11",
    "--hetzner-image-id=103907373",
]

[general]
timeout=300
port=8000

• Finally, make woodpecker-agent use the new docker proxy, by setting DOCKER_HOST=http://localhost:8000 in its environment.

I hope this may be useful for you as well :)

Let’s go for my web review for the week 2023-19.

Ed Sheeran, Once Again, Demonstrates How Modern Copyright Is Destroying, Rather Than Helping Musicians

Tags: copyright, law, music

The copyright system is utterly broken at that point. This kind of lawsuits don’t make any sense.

https://www.techdirt.com/2023/05/08/ed-sheeran-once-again-demonstrates-how-modern-copyright-is-destroying-rather-than-helping-musicians/

Thunderbird Is Thriving: Our 2022 Financial Report

Tags: tech, foss, mozilla, fundraising

Clearly inspiring… this project really went from dying to skyrocketing. I’d like to see more of those.

https://blog.thunderbird.net/2023/05/thunderbird-is-thriving-our-2022-financial-report/

Bluesky is a scam – fiatjaf

Tags: tech, social-media, protocols, vendor-lockin

This clearly doesn’t look as interesting as ActivityPub…

https://fiatjaf.com/ab1127fb.html

When “free forever” means “free for the next 4 months”

Tags: tech, tools, messaging, foss, vendor-lockin

Clearly Zulip uses the opportunity for a bit of self-promotion. Can’t blame them, at least they’re the rare ones not going for open core. Also this is a good explanation on why one shouldn’t trust the “free forever” claims for cloud hosting.

https://blog.zulip.com/2023/05/04/when-free-forever-is-4-months/

Will A.I. Become the New McKinsey? | The New Yorker

Tags: tech, ai, gpt, capitalism, ethics, criticism

Excellent opinion piece. Sure, “A.I.” is a tool, but who is wielding that tool currently? Whom needs is it designed to fulfill? This is currently very much of a problem. The comparison with McKinsey although surprising is an interesting thought.

Also I appreciate the clarification on the Luddites movement… they were not anti-technology.

https://www.newyorker.com/science/annals-of-artificial-intelligence/will-ai-become-the-new-mckinsey

DeepMind’s Epistemic Neural Networks Enable Large Language Model Fine-Tuning With 50% Less Data | Synced

Tags: tech, ai, machine-learning, neural-networks, gpt

Looks like a promising way to reduce the training cost of large language models.

https://syncedreview.com/2022/11/16/deepminds-epistemic-neural-networks-enable-large-language-model-fine-tuning-with-50-less-data/

Releasing 3B and 7B RedPajama-INCITE family of models including base, instruction-tuned & chat models — TOGETHER

Tags: tech, ai, neural-networks, gpt, foss

Truly open source models are pouring in. This is showing more transparency and I hope it will lead to better uses even though some of the concerns will stay true.

https://www.together.xyz/blog/redpajama-models-v1

Introducing MPT-7B: A New Standard for Open-Source, Commercially Usable LLMs

Tags: tech, ai, neural-networks, gpt, foss

And yet another set of open source models. This is really democratizing quickly.

https://www.mosaicml.com/blog/mpt-7b

Even Amazon can’t make sense of serverless or microservices

Tags: tech, infrastructure, microservices, architecture, complexity

Even the giants are slowly moving back from microservices in some places. DHH has a very cruel way to point it out, still that’s true. Let’s hope people realize the mistake it was in term of complexity.

https://world.hey.com/dhh/even-amazon-can-t-make-sense-of-serverless-or-microservices-59625580

Classification of the principal programming paradigms

Tags: tech, programming, language

Nice poster. It’s harder to classify programming languages than it sounds. This one is interesting.

https://www.info.ucl.ac.be/~pvr/paradigms.html

Chris James -HTMX is the Future

Tags: tech, web, htmx, frontend, backend

This is indeed looking more and more like a viable and worthwhile option for web applications.

https://quii.dev/HTMX_is_the_Future

Deciphering Glyph :: Never Run ‘python’ In Your Downloads Folder

Tags: tech, python, security

It points out the security risk but it’s mainly a good explanation on how Python loads modules.

https://blog.glyph.im/2020/08/never-run-python-in-your-downloads-folder.html

Understanding ActivityPub - Sebastian Jambor’s blog

Tags: tech, fediverse, protocols, http

Interesting article. This is a good introduction to the ActivityPub protocol. It also gives nice flies and pointers on how to dive deeper.

https://seb.jambor.dev/posts/understanding-activitypub/

Is sequential IO dead in the era of the NVMe drive? — Jack Vanlightly

Tags: tech, storage, performance

Interesting exploration on the performance of SSDs regarding write patterns. Turns out sequential IO is still a thing, just for a different reason than with good old HDDs.

https://jack-vanlightly.com/blog/2023/5/9/is-sequential-io-dead-in-the-era-of-the-nvme-drive

GitHub - ellie/atuin: 🐢 Magical shell history

Tags: tech, shell, command-line, tools

Looks like an interesting tool to try. History is an important part of the shell experience.

https://github.com/ellie/atuin

vmtest: Run your tests in virtual machines

Tags: tech, tests, virtualization, linux

Looks like a really neat tool for testing low level and kernel dependent details in a reproducible way.

https://dxuuu.xyz/vmtest.html

Key practice: Test Driven Development | by Jason Yip | May, 2023 | Medium

Tags: tech, tdd, tests

Neat, short and simple post highlighting the important traits of TDD.

https://jchyip.medium.com/key-practice-test-driven-development-d77bee69427c

Why engineers need to be bored. - by John McBride

Tags: tech, management, productivity, innovation

This is another way to approach the question of having slack in your schedule. This is necessary, and probably at scale in the organization (as implied by this article).

https://onengineering.substack.com/p/why-engineers-need-to-be-bored

You don’t need Scrum. You just need to do Kanban right.

Tags: tech, project-management, agile, scrum, kanban

A good reminder that there is life outside of Scrum… I especially like the framing of Scrum as training wheels. When you learned biking you outgrew the training wheels, didn’t you?

https://lucasfcosta.com/2022/10/02/scrum-versus-kanban.html

Appreciating Your Way to XP - by Kent Beck

Tags: tech, improving, management, xp

Old article, still an interesting approach to making changes and looking for growth opportunities. There is value in trying not to frame everything as problems to solve.

https://tidyfirst.substack.com/p/appreciating-your-way-to-xp

Be a thermostat, not a thermometer

Tags: management, team, communication

Interesting ideas in there. It’s not enough to pick up that something is off in a conversation. It’s better to influence things to defuse the tension. Clearly not that easy to do, will require quite some practice.

https://larahogan.me/blog/be-a-thermostat-not-a-thermometer/

Bye for now!

IT feels like a billion years before the last plasma sprint, which was in 2019 in Valencia, before the pandemic, but finally this year we are back on track, and was great to see again many old friends as well as seeing many new faces for which it was the first sprint.

We were gracefully hosted by Tuxedo Computers in Augsburgh, makers of very nice laptops that come with Linux and KDE Plasma, as well as being KDE patrons.

First of all, everybody got up to speed with a full git build of a Plasma 6 session, so that everybody could participate in development and discussions from the same level.

There were many discussions about Plasma 6, about what we want to do in Plasma and in Kirigami, how we want to change the look and defaults for the new major release. Most of the user-facing changes have been wonderfully described by Nate.

On my part, I worked on mainly 2 things, that were fairly not “glamorous” but quite important never the less (and mildly painful to do) : a refactor of the plasmoid loading code and splitting all the Svg themes code to a new framework with far less dependencies, ideally usable by any application.

Plasma API

I spent most of my hacking time at the sprint on a refactor of the plasmoid loading code, which won’t be really “seen” by the user, but will make the infrastructure much more robust and the API cleaner.

The person which must pay attention to it is the plasmoid author, which will need to adapt the plasmoid code in a few places.

Most notable is that, just like when you are writing a QML application you have to use the ApplicationWindow root QML Item, for a plasmoid you now have to use a PlasmoidItem root object, so something like

Item {
    Plasmoid.compactRepresentation: Label {text: Plasmoid.title}
    Plasmoid.fullRepresentation: Item {...}
}

becomes:

PlasmoidItem {
    compactRepresentation: Label {text: Plasmoid.title}
    fullRepresentation: Item {...}
}

A full porting guide is in progress.

KSvg

Using the Plasma Svg code to support stylesheet recoloring, on disk image cache to speed up loading, and the 9-patches FrameSvg is something the several applications would be interested to, and some actually are already doing, but since plasma-framework has a lot of dependencies, for some applications that is a blocker. All the svg code has now been broken out into a new framework called KSvg, which is still work in progress, but in the end will support all existing plasma themes with no change, and if an application wishes to use it, the svg sets will be loaded from the app own data folder (or anywhere else the application configures it to) instead of the share/plasma/desktoptheme folder, where plasmashell looks for them (so they can also use a complete different theme structure and don’t have to provide the same elements)

Let’s go for my web review for the week 2023-18.

The web’s most important decision - The History of the Web

Tags: tech, web, history, public-domain

Indeed, without deciding to put everything in the public domain, the face of the web would have been very different.

https://thehistoryoftheweb.com/postscript/the-webs-most-important-decision/

Let’s Make Sure Github Doesn’t Become the only Option - Edward Loveall

Tags: tech, git, github, vendor-locking, tools

Nice to see there are still people out there keeping in mind the “let’s not put all our eggs in the same basket”. This is especially important for systems with such vendor lock-in as GitHub. I’m a bit less convinced about replacing Git itself for now.

https://blog.edwardloveall.com/lets-make-sure-github-doesnt-become-the-only-option

FOSS I Love - Local game streaming with Sunshine and Moonlight

Tags: tech, gaming, linux, streaming

Looks like nice projects. After all these years I’m still amazed at what people manage to achieve in their spare time when they get together to solve a problem.

https://ahelwer.ca/post/2023-04-29-sunshine-moonlight/

The Programmer’s Paradox: Waterloo Style

Tags: tech, architecture, design, programming, object-oriented

Interesting approach. I did quite some of that but without really putting it together like this. It’s a nice way to explain it.

https://theprogrammersparadox.blogspot.com/2023/04/waterloo-style.html?m=1

Tufte CSS

Tags: tech, web, css, blog

I must resist to redesign my blog I guess… In any case, this is a very nice style for content.

https://edwardtufte.github.io/tufte-css/

cohost! - “I want to talk about WebGPU”

Tags: tech, web, graphics, 3d, webgpu

Nice overview of WebGPU. Also does a decent job laying out the history of graphics APIs. With WebGPU bound to be more widespread and available outside of the browsers things will get very interesting.

https://cohost.org/mcc/post/1406157-i-want-to-talk-about-webgpu

Understanding SAL | Microsoft Learn

Tags: tech, safety, c++, c

There are really many initiatives to make C and C++ safer lately. I wonder which one will see adoption and what will make its way to the standards.

https://learn.microsoft.com/en-us/cpp/code-quality/understanding-sal?view=msvc-170

The Cargo Cult of TCP_NODELAY: When to Use It – Somewhere Within Boredom

Tags: tech, tcp, networking

Very nice explanation about TCP_NODELAY and its implications.

https://withinboredom.info/blog/2023/01/03/the-cargo-cult-of-tcp_nodelay-when-to-use-it/

Goodbye to Flake8 and PyLint: faster linting with Ruff

Tags: tech, python, linting, quality, tools

Looks like a promising linting tool for Python. Feature packed and faster than most other options out there.

https://pythonspeed.com/articles/pylint-flake8-ruff/

Cloud exit pays off in performance too

Tags: tech, infrastructure, performance

Very interesting to see that move to owned hardware… turns out that not only the invoice is smaller in their case but the performances are much better as well.

https://world.hey.com/dhh/cloud-exit-pays-off-in-performance-too-4c53b697

Uptime Guarantees — A Pragmatic Perspective

Tags: tech, reliability, infrastructure, software, business, management

Nice overview of what it takes to increase your uptime. It can get expensive quickly. This is also a good reminder that it’s not only about software, it’s a lot about people and administrative constraints as well.

https://world.hey.com/itzy/uptime-guarantees-a-pragmatic-perspective-736d7ea4

Architecture decision record (ADR) examples

Tags: tech, architecture, decision-making

Nice resource to get started with this important and efficient practice.

https://github.com/joelparkerhenderson/architecture-decision-record

Rules of Thumb for Software Development Estimations

Tags: tech, project-management, estimates

It’s a bit a “yet another article” about estimates. Still there are a few good points in there, they’re harder to apply than it sounds though.

https://vadimkravcenko.com/shorts/project-estimates/

Culture & Methods Trends Report March 2023

Tags: tech, business, management, product-management, remote-working, business

Clearly a bit US centric but interesting trends nonetheless. We might see some of that reaching Europe (for good and for bad) fairly quickly. At least regarding hybrid work, flexible offices and more asynchronous communication, I’ve seen it globally spread already.

https://www.infoq.com/articles/culture-trends-2023/

Bye for now!

Some time ago, before the world locked down, I pondered that KDE wasn’t very good at getting our apps to our users. We didn’t even have a website that listed our apps with download links. If you were an open source app developer using our tech (Qt and KDE Frameworks) would you come into KDE to build your app or just start a project on Github and do it yourself? KDE has community which means some people to help look over your work and maybe contribute and translate and some promo and branding mindshare and there’s teams of people in the distros who specialise in packaging our stuff. But successful projects like Krita and Digikam and indeed my own Plasma release scripts still have to do a lot on top of what KDE communally gives them.

So I launched apps.kde.org and made the All About the Apps goal which was selected in the hope of getting KDE to support taking our apps to the users more slickly. I didn’t manage to make much progress with the goal which I will readily take the blame for. After some fighting I managed to get our announcements linking to the app stores directly but I didn’t manage to get much else slicker.

What my dream still is would be for apps to have a button that…

• Bumps the version number in the source
• Makes the tar and uploads it to a secret place
• Tells the Linux distros to package it
• Packaging for Windows/Mac/Android/Snap/Flatpak/Appimage would be in the Git repo and our CI would now build them and upload to the relevant test sites
• OpenQA style tests would be in the git repo and our CI would now test these packages
• Another button would make the source and packages public in Microsoft Store/Appimagehub/SnapStore/Flathub/download.kde.org and somehow tells the Linux distros and send the announce to the Discuss group and start off a blog post for you

I just released KDE ISO Image Writer (another project I didn’t make much progress with for too many years) and had a chance to see how it all felt

There’s no nice buttons and while we have a tool to make the tar and I have a tool to add the release to the AppStream file, there’s nothing to bump version numbers in cmake or add releases to AppStream or make templates for pre-announcements and announcements.

How’s the packaging and app store situation?

Windows and Microsoft Store

I had to go out and buy a laptop for this, there’s virtual machines available for free which should work but I didn’t trust them with the hardware needed here and they’re time limited so I’m a bit wary of setting up Craft then having to do it again when the time runs out. Craft does a lot of the hard work building for Windows and binary-factory and elite Craft dev hvonreth is often around to give help.

Getting access to the Microsoft Store takes a sysadmin request and working out what to ask for then working out what to upload. I uploaded the wrong thing (a .appx file) when it should have been a .appxupload file and that seemed to break the MS Store from accepting it at all. After lots of twiddling and deleting and generally turning it off and on again I got it uploaded and a day later it was rejected with the claim that it crashed. While the app had installed and run fine for me locally using this .appxupload thing to install it locally did indeed cause it to crash. We diagnosed that to the elevated privileges needed and after some Googling it turns out the Microsoft Store doesn’t seem to support this at all. So my dream of having it available to install there has not worked out, but you can get the installer from download.kde.org and use that.

There’s still only 9 KDE apps on the MS Store at a quick “KDE” search which seems far too few.

AppImage

These have been around for decades and KDE has always had fans of this format (it used to be called Klik at one point e.g. test KOffice). SUSE devs were a big fan at one point. In recent years its gained auto-update, daemons to manage the system integration, build tools, support from top apps like Krita and Digikam and a centralised place to get it in AppimageHub (not to be confused with the other AppimageHub). And yet mass adoption seems as far off as ever.

There’s two ways I found to build it, with appimage-builder which was easy enough to pick up and make a packaging file which uses packages from Ubuntu and neon.

Or you can reuse Craft (used earlier for Windows) to build on Linux for the AppImage. This also allows binary-factory integration but I don’t seem to have got this working yet. It might also be worth exploring openSUSE’s OSB which might allow for other platforms.

I tried to upload it to AppimageHub but that broke the website which needed some back channel chats to fix. Once uploaded it appears shortly, no further bureaucracy needed (which is a bit scary). It doesn’t appear on the KDE Store which seems to be about themes and addons rather than apps. And I put it on download.kde.org.

It’s hard to know how popular AppImage is within KDE, neither of the AppImageHubs seem easy to search and many apps publish their own in various ways. There’s about a dozen (non-Maui) KDE apps with appimages on download.kde.org plus a dozen Maui apps which are developed within KDE and used by the Nitrux distro. I hear complains that AppImage doesn’t support Wayland which will limit them.

Flatpak and Flathub

This format has lots of good feels and mindshare because it integrates well with the existing open source communities.

The flatpak-manifest.json file can be added directly to the repo (which I’m very jealous of, when I suggested it for Snaps it was rejected and caused me to grump off the whole Goal) and that can be added to binary-factory but also to invent.kde.org CI. There’s an active team around to help out. That gets uploaded to a KDE testing repo where you can install and test.

But to get it out to the users there’s a separate process for Flathub the main host for Flatpak packages. That takes a another week or two of bureaucracy to get published (bureaucracy when publishing software for people to install is necessary and important). There’s also a stats website which suggests it has 300 installs.

Searching for KDE on Flathub gives over 130 results.

Snaps

This works the smoothest if I say so myself. Add the packaging to the snapcraft repo and it builds on the invent.kde.org CI which actually just sends it off to the launchpad builders and it builds for ARM and AMD64. Then you get one of the KDE Snapcraft team (Scarlett, me, Harald) to register it and voila it uploads to candidate channel for testing. It needs manually moved into the stable release channel which can either be done by our team or we can share admin rights. The bureaucracy comes when you need to ask for permissions such ISO Image Writer needing access to disks, that took a week to be accepted. The packages are build using KDE neon for Qt and KDE Frameworks etc and we’ve had troubles before when KDE neon moves onto new versions of Qt but the content Snap has stayed on older ones, but we’re working out when to save a spare snapshot of it. The build tool Snapcraft also has a kde-neon extension which just adds in common parts used by KDE snaps but sometimes that gets out of date too so we’ve had to work out ways around it.

The Snapcraft KDE page has about 140 apps. From the admin page I can see ISO Image Writer has 920 installs around the world (not bad for two days old). The store doesn’t seem great at picking up the AppStream meta data so screenshot and icons are often out of date which I’ve brought up with the devs a bunch of times. It’s centralised around a single Canonical owned store which open source/free software fans can find a bad smell but it is what users want.

Others

I’ve not looked at f-droid, Google Play, Chocolately, or Apple’s App Store. With the probable exception of Apple’s store we should embrace all of these.

I couldn’t find any tools to add release data (the files to download) to AppStream file which is what ends up on apps.kde.org, that feels like a low-hanging-fruit fix. Building pre-release tars which aren’t available publicly seems tricky to do, we have that for KDE neon but none of the app stores have it. Similarly tools to make templates for release announcements can’t be hard, I do that for Plasma already.

So lots of work still to do to make KDE have slick processes for getting our software out there to the users, it’s social and technical challenges and cultural shifts take a long time. Loads of people have put in lots of work to get us where we have today but still lots to do. If you’re up for a challenge and want to help I hope this blog shows the challenges and potential for fixing them rather than sounding too negative. Let’s keep KDE being All About the Apps!

It’s finally there: Kaidan with end-to-end encryption via OMEMO 2, Automatic Trust Management and support of XMPP Providers! Most of the work has been funded by NLnet via NGI Zero PET and NGI Assure with public money provided by the European Commission. We would also like to thank Radically Open Security (especially Christian Reitter) for a quick security evaluation during the NGI Zero project.

Even if Kaidan is making good progress, please keep in mind that it is not yet a stable app. Do not expect it to work well on all supported systems. Moreover, we do currently not consider Kaidan’s security as good as the security of the dominating chat apps.

There is a new overview of features Kaidan supports. Have a look at that or at the changelog for more details.

Encryption

All messages sent by Kaidan can be encrypted now. If a contact supports the same encryption, Kaidan enables it by default. Therefore, you do not have to enable it by yourself. And you will also never need to worry about enabling it for new contacts. But it is possible to disable it for each contact at any time.

Additionally, all metadata that is encryptable, such as typing notifications, is encrypted too. The new Automatic Trust Management (ATM) makes trust management easier than before. The details are explained in a previous post.

We worked hard on covering as many corner cases as possible. Encrypted sessions are initialized in the background to reduce the loading time. Kaidan even tries to repair sessions broken by other chat apps. But if you discover any strange behavior, please let us know!

We decided to focus on future technologies. Thus, Kaidan does not support OMEMO versions older than 0.8.1. Unfortunately, many other clients do not support the latest version yet. They only encrypt the body (text content) of a message, which is not compatible with newer OMEMO versions and ATM. But we hope that other client developers will follow our lead soon.

XMPP Providers

Kaidan introduced an easy registration in version 0.5. It used an own list of XMPP providers since then. The new project XMPP Providers arose from that approach. That project is intended to be used by various applications and services.

Kaidan is now one of them. It uses XMPP Providers for its registration process instead of maintaining an own list of providers. Try it out and see how easy it can be to get an XMPP account with Kaidan!

Changelog

This release adds the following features:

• End-to-end encryption with OMEMO 2 for messages, files and metadata including an easy trust management
• XMPP Providers support for an easy onboarding
• Message reactions for sending emojis upon a message
• Read markers showing which messages a contact has read
• Message drafts to send entered messages later after switching chats or restarting Kaidan
• Message search for messages that are not yet loaded
• New look of the chat background and message bubbles including grouped messages from the same author
• Chat pinning for reordering chats
• Public group chat search (without group chat support yet)
• New contact and account details including the ability to change the own profile picture
• Restored window position on start

Download

• Source code (.tar.xz) (sig signed with 4663231A91A1E27B)
• Linux (Flatpak on Flathub)

Or install Kaidan from your distribution:

We continued the port to Qt6, released the 23.04 release and attended Linux App Summit

We have been busy this past month! We released KDE Gear 23.04, which now contains most of the Plasma Mobile applications. The development of Plasma Shell based on Qt6 is progressing.

Plasma

Daniel Hofmann reduced the refresh rate of the clock to reduce the energy consumption.

Devin continued porting to Qt6 and fixing bugs. He also added a first start wizard for when the user logs for the first time.

Push notifications

Volker presented his work on Push Notifications at the Linux App Summit in Brno last weekend. You can watch his talk on youtube.

Tokodon (Mastodon client)

The visibility, post-creation time and application are now displayed when a post is selected (Shubham Arora, KDE Gear 24.08.0, Link)

We now always use relative times in posts (Shubham Arora, KDE Gear 24.08.0, Link)

We now consistently use "Post" in our UI instead of a mix between "Post" and "Toot". (Shubham Arora, KDE Gear 24.08.0, Link)

We implemented the Mastodon "Explore" tab, which shows some posts popular in your instance (Shubham Arora, KDE Gear 24.08.0, Link)

We overhauled the interaction icons (Joshua Goins, KDE Gear 23.08.0, Link)

Kalendar

The contact editor now allows adding basic personal information about the contact (Aakarsh MJ, KDE Gear 23.08.0, Link) and also their profile picture (Aakarsh MJ, KDE Gear 23.08.0, Link)

We fixed a serious crash when editing events in the calendar in the month view (Carl Schwan, KDE Gear 23.04.1, Link)

We fixed a data race causing a crash (Carl Schwan, KDE Gear 23.04.1, Link)

We fixed the custom reminder option showing as "On Event start" (Vanshpreet S Kohli, KDE Gear 23.04.1, Link)

We don't link against the libraries AkonadiXML, AkonadiAgentBase, CalendarSupport (Volker Krause, KDE Gear 23.08.0, Link 1 Link 2) and EventViews (Kevin Ottens - Carl Schwan, KDE Gear 23.08.0, Link 1, Link 2) anymore.

We re-enabled the search collection to see all the open or closed calendar invitations now that they work again in Akonadi (Carl Schwan, KDE Gear 23.08.0, Link)

We now have unit tests for the phone number model (Aakarsh MJ, KDE Gear 23.08.0, Link)

NeoChat

Tobias has reworked the Quickswitcher (Ctrl+K) to be more useful. Now it shows the room's name and last message (NeoChat 23.08, Link).

Carl ported the spell-checking settings page to the newer form components (NeoChat 23.08, Link).

James has created improved full-window image and video-viewing components, which you will soon also see in more of our apps (NeoChat 23.08, Link and Kirigami Addons 0.8, Link).

Tobias has implemented support for sending location events (NeoChat 23.08, Link)

Marc changed the message style to have a different background color for code blocks (NeoChat 23.08, Link)

Powerplant

Powerplant is a new application developed by Mathis with the help of Carl. This application helps you keep track of your plants' needs (e.g., water).

This is a new application and we welcome contributions. Check out our Gitlab Repository.

MarkNote

Another new application by Mathis is MarkNote. MarkNote is a WYSIWYG note editor.

This is a new application and we welcome contributions. Check out our GitLab Repository.

OptiImage

Yet another application is OptiImage, developed by Carl. It is an image optimizer which makes use of optipng and jpegoptim to optimize images.

This is a new application and we welcome contributions. Check out our GitLab Repository.

Audiotube

Audiotube now lets you right-click to open the context menu (Mathis, Link).

The top result is now displayed at the top of the search results (Jonah, Link).

Many broken search terms were fixed (Jonah)

Rattlesnake

The metronome app Rattlesnake was completely redesigned by Mathis and now uses the mobile form components and new sounds.

Check out the GitLab repository.

Contributing

Want to help with the development of Plasma Mobile? We are desperately looking for new contributors, beginners are always welcome!

Take Plasma Mobile for a spin! Check out the device support for each distribution and find the version which will work on your phone.

Even if you do not have a compatible phone or tablet, you can also help us out with application development, as you can easily do that from a desktop!

View our documentation, and consider joining our Matrix channel, and let us know what you would like to work on!

Our issue tracker documentation also gives information on how and where to report issues.

Donate

And finally, KDE can’t work without financial support, so consider making a donation today! This stuff ain’t cheap and KDE e.V. has ambitious hiring goals. We can’t meet them without your generous donations!

This new entry will cover ways to configure global preferences for Maui Apps and Maui Shell.

MauiMan

MauiMan stands for Maui Manager, and exists for setting, saving, and syncing the configuration preferences for the Maui Apps ecosystem. These configurations are global, and some of them can be overridden by the apps themselves, but more about that later. To store the configurations MauiMan uses the MauiMan.conf config file, located at your local config path: for example ~/.config/Maui/MauiMan.conf.

(!) The settings modifications are only written/saved when using the MauiMan API directly.

MauiMan consists of two parts, a (1) background server that syncs and broadcasts the preference properties changes to all the running Maui Apps, and a (2) public API, that allows app developers to easily hook their apps to the system preferences. The MauiMan server program is named MauiManServer and uses the DBus IPC.

The public API and the server are divided into modules: for different setting categories, such as Theme, Background, Accessibility, FormFactor, etc…

Using MauiMan to configure Maui Apps.

To configure existing preferences, there are different ways to do it, from a graphical interface to editing a text file or even hooking to the public API directly (for developers), in the following sections we’ll cover all the possible ways.

The ideal way to set the configurations, from a user perspective, is to use the Maui Settings application, which exposes all the MauiMan preferences in a graphical manner; although, some of the settings presented are “curated” to use predefined sane values, for example, not allowing to set the border-radius of elements to an unfitting value rendering the interface unusable. This means that with this approach you dont get full control over the values of the properties in all the cases, but you are less prompt to mess up.

Maui Settings also exposes other settings for other system stuff, such as Networks, Sound, Notifications, etc. If any of the needed servers to sync configurations are offline, Maui Settings warns you about it and allows you to launch the server daemon with a single click.

(!) Keep in mind that Maui Settings is still under heavy development and most modules are still not implemented.

Another way to do interact with MauiMan is by using DBus directly. For this one can use a graphical application and navigate to org.mauiman.Manager and then dive into the existing modules for modifying the properties.

(!) Using this approach will not save the changes made: it will keep the changes in memory as long as the MauiManServer daemon is running, but once the process is restarted those changes will be lost since changes to the MauiMan properties are only saved when using the MauiMan public API.

Another apporach is to manually edit the MauiMan.conf file. It has a couple downsides:

• The changes won’t be made live.
• Changes won’t be loaded until MauiManServer process has been restarted since MauiManServer saves in memory the properties and only loads preferences from the config file on startup.

Using this config file is a convenient way to set default values for distributions shipping Maui apps, so they can be styled for the distribution. This config file is located at:

~/.config/Maui/MauiMan.conf

Here’s a snapshot of the config file contents:

[Accessibility]
SingleClick=false

[Background]
DimWallpaper=false
FitWallpaper=false
ShowWallpaper=true
SolidColor=#ffff00
SourceDir=file:///usr/share/wallpapers/Cask
Wallpaper=file:///usr/share/wallpapers/Cask/Cloudy Noon - 5K (16:10).jpg

[FormFactor]
PreferredMode=0

[InputDevices]
KeyboardLayout=us

[Screen]
Orientation=1
ScaleFactor=1

[Theme]
AccentColor=#000
BorderRadius=12
CustomColorScheme=Amethyst
DefaultFont="Noto Sans,10,-1,0,50,0,0,0,0,0,Regular"
EnableCSD=true
EnableEffects=true
IconSize=16
IconTheme=Colloid
MarginSize=4
MonospacedFont="xos4 Terminus,12,-1,7,50,0,0,0,0,0,Regular"
PaddingSize=4
SpacingSize=4
StyleType=1
WindowControlsTheme=CadiumGloss

Accessing these MauiMan properties is also possible from an application side too: for developers there is the MauiMan public library which exposes all the properties trough a public API. So if you need to know about the current workspace background image source, you could hook to MauiMan::BackgroundManager::wallpaper()  and even connect to wallpaperChanged signal to know in real time when the wallpaper has been changed.

#include <MauiMan/backgroundmanager.h>

void func()
{
auto wallpaper = MauiMan::BackgroundManager().wallpaperSource();
}

Most of the properties are already quickly accessible via MauiKit Style object,  (for apps developed using MauiKit) which besides syncing to MauiMan changes can also override these properties with in-app specific values and if needed clear those using undefined to return using the MauiMan values.

For example, for setting the style type as dark for an app, despite the global preference being different:

​​​​Maui.ApplicationWindow
{
    Maui.Style.styleType: Maui.Style.Dark
}

​and to reset the value back to the global system preference:

​​​​Maui.ApplicationWindow
{
    Maui.Style.styleType: undefined
}​ ​​​

CaskServer

To configure Maui Shell preferences and expose those to any other processes, there is CaskServer, which as MauiMan, has two components: a CaskServer daemon for syncing/broadcasting the properties changes and the public library.

The public library allows apps to request Cask to draw custom shadows, title bar colors, and more privacy settings, via the Chrome and Screenshot modules. More modules include Shell, Power, Profiles, and Notifications.

The Shell module allows tweaking the Cask elements such as dock, panels, launcher, popups, etc preferences.

Some of these properties can be modified from Maui Settings, while others, such as properties from the Chrome module, are specific for a given app, so an individual app can be hooked to the Chrome module via the CaskServer library to perform changes to the available properties.

(!) CaskServer as Maui Settings and Maui Shell is still under heavy development and isn’t stable enough yet for commercial use, keep this in mind if you decide to give it a try.

The CaskServer configuration file is located at :

~/.config/Maui/CaskServer.conf

More detailed information about configuring Cask and Maui Shell will soon be shared, as development progresses.

​​​​​​

To follow the Maui Project’s development or say hi, you can join us on Telegram: https://t.me/mauiproject.

We are present on Twitter and Mastodon:

• https://twitter.com/maui_project.
• https://mastodon.technology/@mauiproject.

New release schedule

The post Configuring Maui appeared first on MauiKit — #UIFramework.

A month has passed since my last monthly post about my work as KDE Software Platform Engineer. What have I been up to since then?

As usual not everything I did ended up as committed code. A lot of my work is reviewing other people’s code, discussing ideas, and generally being useful to the community.

One area I’ve been focussing on is our infrastructure for global shortcuts. These are currently handled by the KGlobalAccel framework. This frameworks contains the runtime component that manages global shortcuts as well as an application-facing library to interact with the runtime. The runtime and interface library being in the same project has caused us some issues in the past. To address these the runtime part is now split out into a separate project and part of the Plasma group. You can read up more details on this here. This change also allowed for some further changes that made launching applications from global shortcuts both simpler code-wise and more robust. I have also worked on another set of changes that will address some of the pain points that are currently present in our global shortcuts system. While doing that I also addressed some issues I found in the underlying KDE Frameworks libraries.

Another area I worked on is notifications. One thing I did there was reducing the API surface of the KNotification class by hiding internal API that shouldn’t be exposed to application developers. I also proposed a revamped API for specifying notification actions. The new API is both easier to use for application developers and easier to extend with new features in the future.

With a small API change to KStatusNotifierItem, our class for implementing system tray icons, it is now easier for QML applications to fully make use of its capabilities. The API to set an associated window previously was only really usable for QtWidgets apps, now it can be used for QML apps too.

In some Plasma news: Plasma now uses the C++20 standard. This allows us to use some nifty new C++ features. One big one that comes to mind are coroutines, which have the potential to massively simplify parts of our code. Getting there required some tweaks to make our code and our dependencies fully C++20-compliant.

Talking about dependencies: With our move to Qt6 all of our Qt-based dependencies need to make that move too. appstream-qt, the library that powers e.g. Discover is now ready for that too. I helped integrating that into our build infrastructure. Another project with such dependencies is our online accounts system. It depends on libraries like libaccounts-qt and signond, which I’m working on porting to Qt6.

Last weekend I attended the Linux App Summit in Brno, Czech Republic. It was a lovely event that allowed me to get in touch with both people from KDE and our partner organizations like GNOME and Flathub.

To support the work I and many other people do in KDE please consider donating to KDE e.V. Your donations make my work as KDE Software Platform Engineer possible. Thank you for that!