Representative and generated

So long of GSoC and No blog yet? Why Soumya?

Yeah, yeah, I know. It’s been a while, and no blog posts yet. But hey, between wrestling with CFFI + C + Python and libcups with its 150+ APIs, blogging kind of took the back seat. But enough excuses - let’s dig into what’s been cooking.

A little history (with C in it)

Back in the day (almost 15 years ago!), Tim Waugh wrote the first version of pycups as a C extension module for Python. That worked well, but like all old code, it aged… let’s just say, not like fine wine. After Tim, Zdenek took over as maintainer, but with multiple projects of OpenPrinting and other projects in the mix, there wasn’t much room to modernize PyCups2 for him.

Welcome to the July 2025 development and community update.

Development Report

Text Tool Rework Progress

Another important piece of the Text Tool update has made it into the unstable nightly builds: Style Presets.

For making text bold, or a certain font at a certain size, or a huge list of settings tweaked just right, you can easily apply your favorite properties without having to remember them all. (MR!2403)

The QML Text Properties docker now uses the same custom slider-spinbox widgets as the rest of Krita, thanks to Wolthera and Deif Lou. (MR!2428)

Community Report

July 2025 Monthly Art Challenge Results

16 forum members took on the challenge of the "Cool Rides" theme. And the winner is… Cool Rides by @edgarej

The August Art Challenge is Open Now

In the spirit of August's monthly challenge being unofficially dedicated to Krita's cybersquirrel mascot, winner @edgarej has chosen "Kiki's Summer Activities" as the theme. The optional challenge as chosen by runners-up @npc and @Mythmaker is to give Kiki a pet companion. What does Kiki like to do to beat the heat? You decide!

Featured Artwork

Best of Krita-Artists - June/July 2025

This month's Best of Krita-Artists Nominations thread received 13 nominations of forum members' artwork. When the poll closed, the moderators broke a five-way tie for second place, and these five wonderful works made their way onto the Krita-Artists featured artwork banner:

On the Road Again by @Yaroslavus_Artem

Lucy CyberPunk Edgerunner Fanart - P.2025058 by @ynr_nohara

Medieval Table by @Ape

Summer Retreat by @Gurkirat_Singh

Mountain Sunset - Master Study Bohdan Saliy with Memileo Impasto Brushes by @TaleOfACat

Ways to Help Krita

Krita is Free and Open Source Software developed by an international team of sponsored developers and volunteer contributors. That means anyone can help make Krita better!

Support Krita financially by making a one-time or monthly monetary donation. Or donate your time and Get Involved with testing, development, translation, documentation, and more. Last but not least, you can spread the word! Share your Krita artworks, resources, and tips with others, and show the world what Krita can do.

Other Notable Changes

Other notable changes in Krita's development builds from July 16, 2025 - August 18, 2025.

Stable branch (5.2.12-prealpha):

• Palette Docker: Fix crash with add swatch dialog. (bug report) (Change, by Wolthera van Hövell)

Unstable branch (5.3.0-prealpha):

• Fill Tools: Add option to Include Current Layer in color labels reference mode. (Change, by runch r.)
• Symbol Libraries Docker: Fix symbol thumbnails being pixelated, and add a thumbnail-only view mode. (Change, by Agata Cacko)
• Freehand Path Tool: Remember Tool Options. (Change, by Agata Cacko)
• Animation: Switch to active keyframe when inserting/removing hold frames. (CCbug report) (Change, by Emmet O'Neill)
• Animation: Fix rendering GIFs that don't have the .gif file suffix. (bug report) (Change, by Emmet O'Neill)

Nightly Builds

Pre-release versions of Krita are built every day for testing new changes.

Get the latest bugfixes in Stable "Krita Plus" (5.2.12-prealpha): Linux - Windows - macOS (unsigned) - Android arm64-v8a - Android arm32-v7a - Android x86_64

Or test out the latest Experimental features in "Krita Next" (5.3.0-prealpha). Feedback and bug reports are appreciated!: Linux - Windows - macOS (unsigned) - Android arm64-v8a - Android arm32-v7a - Android x86_64

Intro

After getting the Selection Action Bar into a working state over the past few weeks, this week I focused on creating documentation and refactoring code to improve clarity, maintainability and make sure other contributors can build off of this work without confusion.

Progress

Documentation

One of the most important parts of contributing to open source is writing about what you have built. Krita's documentation is maintained in a dedicated repository. This week I began drafting a merge request to add a page with instructions and UI images under the reference manual tools section.

My aim is to ensure that any Krita user can easily understand the feature through both the documentation and the code.

Refactoring

Another important part of contributing to open source is writing code that is easy to read and maintain for future contributors. My aim was to improve the structure of the code without changing its behavior. I did this by reducing duplication, using descriptive variable names, and replacing magic numbers with named constants.

Instead of manually creating and connecting each button, I introduced a helper function that takes configuration data (icon, tooltip, slot) and handles the setup in one place.
Create Button Helper

I also applied an extract method refactor, grouping the buttons and toolbar UI logic into their own functions.
setupButtons and drawActionBarBackground

Conclusion

This week reinforced the importance of writing both documentation and clean code. I learned that documentation ensures users understand your work, while refactoring ensures the code is clear and easy for contributors to improve.

Heading into the final week of GSoC, I am ready to share my contributions and overall learnings. My focus will be on gathering feedback and finalizing the feature!

Contact

To anyone reading this, please feel free to reach out to me. I’m always open to suggestions and thoughts on how to improve as a developer and as a person.
Email: ross.erosales@gmail.com
Matrix: @rossr:matrix.org

There has been quite a surge in interest towards desktop Linux lately. The userbase, atleast according to some metrics, seems to be climbing.

I realised today that it's been 4 years for me since I did the switch. I have gathered some know-how that maybe a complete newbie could find useful. I also try to untangle some jargon I've learned: It may not be exactly technically correct, but this is meant for a more regular user anyway.

Note: Do not trust "AI" tools when looking for information. They can lie. They don't really "know" anything, they just copy what they see on the internet, and spit it out. Sometimes in wrong orders and contexts. I will list some resources I trust at the end of the post.

I have also written about this before here: Setting up Kubuntu for gaming

That post is quite out of date though, so consider this a supplemental material and sort of upgrade.

Investigate the software you need

There is often times where you can only use specific software on Windows only. Or specific games with anticheats do not work on Linux; Not all of them though! Just some, especially with kernel level anticheats!.

But for example Photoshop or similar tools do not work on Linux natively. There can be tricks to get them working.

You would not expect Mac software to work on Windows, right? This is similar kind of situation.

Now Linux can run some Windows applications through Bottles, which uses Wine. But not all.

So, make a list of the Must Have applications you have. Then search for Linux compatibility.

In some cases, you may find alternatives for the application, that work on both Windows and Linux! When that happens, you can already test it out in Windows and see if it works for your workflow, and start using that instead. Note that this can take time to learn, but I think it would be worth it.

And hardware too

I haven't had a problem with incompatible hardware with Linux for long long time, but it's still good idea to check it. For example, if you have Nvidia GPU, you may want to check if the GPU is supported by which drivers, or if you need to install drivers at all. For AMD/Intel GPU users, you're in luck, because the drivers are in the Kernel: This means that you don't need to install anything.

If I have had trouble with hardware, it's often been audio devices, like headsets that have two separate dials for sound (mono and stereo), weird bluetooth speakers, etc..

There is a site called Linux Hardware you can use to search for compatible parts.

Backup all your stuff

Before doing anything to your PC: Backup your data. Backup the photos, the videos, the game save files, documents, anything you may need. Back them up to a cloud service or external drive.

Make sure those backups work, too.

Distribution choice paralysis

Linux distributions are all their own operating systems, they just share the most central part, that is the Linux kernel.

Distributions take that kernel, add their own things to it and make it what they want it to be for their users.

There's a lot of distributions. Like, A LOT. So of course it'll feel daunting to choose one.

But there's no "wrong" choice. It will probably take time to figure out which one you like, but honestly, most people will be fine with one that does it's job, stays out of the way and updates without effort.

Everyone has tons of opinions about this. Then there's the weird curmudgeons that tell others their opinion is "wrong." Those people are something you can ignore. If it works for you, that's all that matters.

After choosing a distribution, you install it to an USB stick (that has nothing important in it, so NOT the one with your backups!!) with tool like Rufus, boot from it at PC startup (varies between motherboards) and get installing.

My recommended newbie distributions

To help one get started with choosing, here's my recommendations from all the distributions I've tried on my ~4 year journey.

Do note that gaming is big factor in my computer use, so if the distribution can't game well, it's not on this list.

Bazzite

Homepage: https://bazzite.gg/

Bazzite is perfect distribution for anyone starting with Linux.

It's made so that user can't really break it, due to it's nature: You can't really open system files and start modifying them and deleting them. Then, updates are done in a way that if something goes wrong, you can go to previous version of the distribution.

On top of that, it makes setting it up very easy with its guides. And in download section, you select what hardware you have, and what desktop enviroment you have, so you know from the get-go that it's very likely going to work with your system.

If you don't really know what to choose, go with Bazzite.

Fedora KDE

Homepage: https://fedoraproject.org/kde/

Fedora KDE is solid. It works, it updates regularly, it plays games I play really well, and works with development. And then it stays out of the way. Fedora is also what Bazzite is built on top of.

Fedora however allows you to tinker with the system files and such, as long as you have access to it. You should not do that if you don't know what you're doing! But it's possible.

Installation on systems with AMD/Intel GPU is really easy and you don't need to install any separate drivers.

With Nvidia GPU, you will likely have to use RPM Fusion repositories, and follow their guide: https://rpmfusion.org/Howto/NVIDIA.

So yes, for Nvidia users it can be bit more tinkery.

Fedora KDE is my daily driver because it works really well with any development work I do due to it's up-to-date system libraries. And since it's regularly updated, if there is a bug, it often gets fixed just as fast.

Kubuntu

Homepage: https://kubuntu.org/

Last but not the least, Kubuntu is a solid distribution as well. It does not update as frequently as Fedora KDE does, but not everyone needs such frequent updates, especially for basic daily use.

Kubuntu utilizes same tools and systems as Ubuntu, which you may have heard of. So it has a solid community behind it.

When I used Kubuntu, it worked with games really well and I had zero issues with it. I moved to Fedora due to development stuff, so that's why I don't use it anymore.

When downloading Kubuntu, make sure to choose "Latest."

Opinions and notes about LTS distros

LTS stands for "Long Term Support" or "Long Term Stable."

This wording has caused a lot of confusion: People tend to think "stable" means it doesn't crash. What it actually means is that it won't change and that means the bugs are stable too. The only updates it gets are security updates. Bug fixes, especially for software, are really rare.

LTS/Stable distributions are perfect for enterprise environments or your grandmas PC which you know she won't remember to update.

For regular use, especially gaming use, I would recommend against them: They use LTS kernel that has support only for specific devices, so if you buy a new shiny GPU and plop it in to system running on LTS kernel, it very likely does not have support for that new shiny GPU.

Also, when you encounter an annoying bug, be prepared for that bug to stay around until the next LTS release: Which can mean years!

So unless you really know you need/want LTS distribution, choose anything that is "Latest" or frequently updated. You will have less headaches that way: I learned this the hard way.

Note: Bunch of people have told me that I should have more nuance here. I understand it too, for some people LTS distribution can be quite perfect. I'm not saying that one should completely avoid them, either. But newcomer should, in my honest opinion, try more up-to-date distribution. I think they provide better experiences, especially for regular desktop use. Bazzite has been really good for this usecase.

Desktop environments

You may notice that I seem to recommend distros running on KDE software.

This is because, well, I work on that software and I like it! But people also find it very easy to learn when they're coming from Windows.

When I started Linuxing, I tried GNOME. It's a great desktop environment, but it's far from what Windows is. This was very overwhelming for me, because I was already learning completely new operating system paradigm, so having also the desktop use change from underneath was really jarring. I then tried XFCE, which is very lightweight and nice to use, but it lacked some things I wanted, like Wayland support.

I then stumbled upon on KDE Plasma and fell in love with it: I did not have to learn completely new way of using my desktop, but could gradually modify the desktop to suit my needs. My Plasma setup is far from the defaults nowadays, and Plasma allowed me to discover what I like on my own pace.

Note that I don't think any desktop enviroment is "bad." They're just different, catering for different needs.

But for most Windows users, I do recommend KDE Plasma for the above reasons: Less cognitive load to learn everything.

Unlearning Windows

When moving to desktop Linux, most people are confused by some things, like "Where's my C-drive."

Windows has taught many of us specific patterns, and when those patterns do not exist, we tend to blame the system we're using.

What you need to remember is that you're not trying to switch to "better Windows." You're switching to completely different operating system, and you need to try your best at unlearning Windows.

So where is the C and D drive

Instead of having drives like C and D, you mount the drives you have.

You can open terminal and type ls /mnt/ and it shows what drives you have mounted.

Mounting in this case means that it's plugged in and browsable.

Here's a shoddy comparison:

• C drive on Windows -> /
• D drive on Windows -> /mnt/drive-name

The / is called "root directory" and that's where everything in the PC resides.

It can get more complicated, and my suggestion is to just leave / alone.

If you want to have games on your other drive, check your /mnt/ folder for that drive. Usually during installation the drive is made for you.

If not, you may have to ask help for the distribution you're using.

In Linux, all drives and such are folders, that start from /. Instead of multiple "trees" that start from "C" or "D", there's one big tree that starts from /.

What's /home/ or ~

When you open file manager such as Dolphin, usually the first folder you see open is /home/your-username/.

This is your home folder. Think of it like "my documents" folder in Windows computers.

Keep all your documents, videos, images etc. in here.

When people say ~/Documents, the ~ is shorthand for /home/your-username/. This also works inside terminal, so you can type ls ~ to see what's inside your home folder, without having to type the /home/user.

Can I just keep my game drive from Windows?

When installing Linux, many people tend to ask that if they can just keep the drive full of games, like D: drive, without formatting it and just use the same game files.

Well, you sort of can, but Linux is not very fast with it. When Windows formats drives, it uses something called NTFS for them. Linux has many different ones, but usually it's ext4 or btrfs.

NTFS drives can be opened and such on Linux, but it can be rather slow.

So my tip is just to back up the game data to something like USB drive and then move them, or just download the games again. You will be much happier with the performance that way.

Do not be afraid of terminal

Terminal is that box full of text you can type in. It looks like something from the 80s/90s.. And it can be intimidating.

Don't be afraid of it! Terminals are great way to operate on some things because they're desktop agnostic!.

This means that if your friend uses GNOME and you use KDE Plasma, and you both have some problem you have to solve. GNOME and Plasma have different user interfaces, so you can't really advice your friend how to solve that issue on their end.

However, what you can do is solve that issue inside terminal with a command, then share that command with your friend who can then use it too.

Of course, there's a ton more nuance here.. But the above is why it's still being used.

Couple important notes:

• If you don't understand the command, study it first before running it.
• If the command requires sudo to be run, study it three times before even thinking of running it.

Commands that need sudo to be run mean that they have access to everything on your computer, as they need a root access. If you don't know what you're doing, things may break.

Again, this is not something you need to be afraid of, but you should be cautious, especially when copying commands from the internet!

Report bugs!

In Linux world, most things don't cost anything. However, if you encounter bugs, you should report those to the app/system you encountered it with.

This helps the bug to get fixed. Sometimes it can take long time, sometimes it can be fixed next day.

But without the bug report, nobody will know.

Here's a post about reporting bugs I wrote: How I report bugs

Note: If you're using LTS distribution, report all the bugs to the distribution itself, not the app/system!

Avoid installing apps from internet

On Windows, it's common to go to a website and download an exe file there to install something.

On Linux, we prefer using app "stores" where one just types what they want to download and then download it.

For example in KDE Plasma, we use tool called Discover.

Instead of going to internet, open Discover and type the name of the app. If it exists, it'll pop-up, and then you can download it there.

This is safer for the user as the files come from the distribution (or Flathub, more on that later), so they have been (likely) tested that they work. They also are installed more cleanly to the system, so you get all the launcher icons and other things.

You can download apps from web pages, and sometimes that's the only way to get some apps. But always first check your distribution app downloader.

Flathub

Flathub is the new cool thing that uses Flatpaks.

As a regular user you don't need to worry as much what Flatpaks are, but I will explain anyway: When distributing application between distros, some distros use different package management systems.

This then can get out of hand when you want to share your app with 10 distributions that all use their own thing. Or they use the same thing but have different library versions.. And this causes headaches.

What Flatpak tries to do is just Make Things Work by adding all that's needed to the package, then user just installs it. Flathub is a central place where people upload their flatpaks.

Flatpaks also have security measures, that can be helpful with some apps. For example Flatpak apps can be told to not be able to read any other folder than ~/Downloads etc. Kind of like what Android has with their permission system.

So, if your system does not have Flathub set up, select your distribution from here, and add it to your system.

However I advice to not install Steam through it: Steam works better when it has more access to your system. So follow your distributions guide for installing Steam in those cases.

Dualbooting

If you want or need to use Windows for something, it is possible to set up your PC so that when you power on your PC, it asks you if you want to use Windows or Linux.

Distributions have their own manuals for that. Be prepared that Windows updates have been known to meddle with your boot-loader (the thing that shows you the "Windows or Linux?" at startup), which may cause your PC suddenly boot only to Windows one day.

So, it's possible, but you need to do some research about it for the distro you have chosen.

Learning resources

Again, do not rely on AI tools. They can lie.

Instead, search information from various forums and wikis, such as:

• ArchWiki
  • Despite the name, it can be useful for whatever distribution you use!
• ProtonDB
  • Game compatibility with Linux
• GamingOnLinux
  • A lot of gaming related news, and they have section for tracking anti-cheat compatibility
• All Things Linux wiki
  • Up and coming new wiki for Linux things
• r/linuxhardware
  • People ask here often if specific hardware works on Linux

Then, every project and desktop has often their own forums and wiki pages. When in doubt, read those. Don't be afraid to ask in the forums either, or in chats like IRC or Matrix.

Anything else?

Uh, that's a lot of stuff. I don't remember if I had anything else in mind. I will update this post if I do remember suddenly something.

I hope this has been useful, however! I can't give in-depth guides to everything, because things can vary between distributions, hardware, desktop environments.. But I hope this can at least help you get started and helps resolve some questions you have.

If you have any questions, feel free to mail me at linux-newbies@akselmo.dev. If it's something that should deserve it's place here, I will update the post.

Anyways, thanks for reading!

Edits

• 2025-08-23: Clarified that my notes about LTS are opinions, added Dualbooting section

This post is somewhat an update for my older post: Kate and Python language server

There seems to be a lot of different Python language servers.. And I just want one that does all and stays out of the way.

So after moaning about that I was pointed towards basedpyright on Fedi.

Despite the silly name, it works really well, so I set it up for Kate editor as I do. Here's how.

Install basedpyright

You may want to use something like pipx for this, that's at least what I did.

pipx install basedpyright

pylsp_in_env.sh

Then add pylsp_in_env.sh to PATH (such as ~/.local/bin/) Kate can see:

#!/usr/bin/env bash

path="$1"
cd $path
if [ -d ./.venv ]; then
  source ./.venv/bin/activate
elif [ -d ./venv ]; then
  source ./venv/bin/activate
elif [ -f ./Pipfile ]; then
  exec pipenv run basedpyright-langserver --stdio
  exit 0
fi

exec basedpyright-langserver --stdio

As mentioned in the previous post, this is needed to get the proper virtual environment. I also updated the script to work with Pipfiles.

Kate lsp settings

Then add this to Kate LSP settings.

I have also kept the pylsp settings there. It doesn't harm anything to have them there, in case you want to change the language server back to python-lsp-server.

{
	"python": {
		"command": [
			"pylsp_in_env",
			"%{Project:NativePath}"
		],
		"root": ".",
		"url": "https://docs.basedpyright.com/latest/",
		"highlightingModeRegex": "^Python$",
		"settings": {
			"basedpyright": {
				"analysis": {
					"typeCheckingMode": "off"
				}
			},
			"pylsp": {
				"plugins": {
					"pycodestyle": {
						"enabled": false
					},
					"ruff": {
						"enabled": true
					}
				}
			}
		}
	}
}

You can change the typeCheckingMode to different values like basic and recommended if project demands it. I set it off because with recommended there's A LOT of diagnostics that I usually don't need, unless again, the project expects proper type checking.

Done!

And that's it. Restart Kate or the Language server inside Kate and as long as Kate can find the file, it should just start up basedpyright-langserver and work.

I like this language server a lot, but if there's other challengers in future, expect me to make a post about them too.

Until next time!

KStars v3.7.8 is released on 2025.08.13 for Windows & Linux. MacOS release is pending. It's a bi-monthly bug-fix release with a couple of exciting features.

Live Stacking

The moment many of you have been waiting for has arrived! John Evans has introduced the highly anticipated Live Stacking feature to Ekos, seamlessly integrated into the FITS Viewer. Once you configure your live stacking directory, any FITS images added will be automatically stacked in real-time.

This feature works independently of your existing sequences or scheduler sessions, allowing you to configure the live stacker to process captured images for an enhanced view of your final results. It's particularly valuable for public observatories and star parties, where real-time feedback can greatly enhance the viewing experience.

Since Live Stacking is still in beta, we welcome your feedback and suggestions for improvement. Check out the demonstration videos below to see the feature in action and learn about its capabilities.

Equipment Profile Editor

The Ekos Equipment Profile editor has received a complete redesign. We've eliminated the limitations of the previous editor—you can now add unlimited drivers to your equipment profiles without restrictions. Need three different mounts in a single profile? No problem!

Both driver and profile lists now include search functionality, making it quick and easy to locate specific drivers. This flexibility gives you unprecedented control over your equipment configurations.

Focus History Navigation

Wolfgang Reissenberger has added an invaluable Focus History navigation feature. When autofocus encounters issues, you can now navigate through your focus frame history to inspect images from all autofocus runs, making troubleshooting much more effective.

The Focus module now includes a dedicated navigation panel. To optimize screen real estate, we've moved the detected stars display and current HFR readings above the V-Curve rather than below it, freeing up valuable space.

FITS Viewer Stretch Presets

Hy Murveit has refined the FITS Viewer stretch sliders and added a convenient preset button that cycles through seven different stretch configurations, offering various combinations of background brightness and contrast levels.

When you display the histogram and zoom in, the sliders provide much finer resolution control—particularly useful for precise black point adjustments.

Flatpak Support

Thanks to extensive collaboration between the Ikarus Technologies team, KDE Infrastructure team, and the Flathub community, we now offer both Stable and Nightly Flatpak packages.

The KStars Flatpak includes all INDI drivers and runs securely within the flatpak sandbox environment. This allows you to install both Stable and Nightly versions simultaneously without conflicts; perfect for testing the latest features and bug fixes while maintaining access to the stable release.

For installation on a brand new system, you'll need to install INDI firmware files. We've prepared comprehensive instructions and a simple installation script for both stable and nightly versions to facilitate this process.

Polar Alignment Improvements

Migration to Qt6

This release represents a significant technical milestone with our complete migration to Qt 6 and KDE Frameworks 6. KStars is still compatible with Qt 5 until all major distributions fully switch to Qt 6. While these changes happen behind the scenes, they provide a more robust foundation for future development.

The entire KStars development team contributed to this substantial effort. Special recognition goes to Eric Dejouhanet and Robert Lancaster, who invested countless hours reworking our complex CI/CD pipelines and macOS support builds in KDE's Craft system. This release wouldn't have been possible without their exceptional dedication.

Dark mode has been available in Plasma for quite a while now but the next release explores new areas where it can be taken one step further, beginning from some behind the scenes infrastructure to more user facing features such as dynamic wallpapers and automatic day/night global theme switching.

My journey to improving dark mode capabilities started at the recent Plasma Sprint. A while ago, I developed a wallpaper plugin that’s capable of synchronizing images to the position of the Sun, which I wanted to upstream but one of the biggest issues was the sheer size of the project. It supports a bunch of modes, it requires special tooling, and the wallpaper format is too cumbersome for upstream (although it’s amazing for 5K or 8K images!). So, I decided to make a pitch for adding one of the modes available in that plugin to other Plasma developers, which should be very easy to integrate with the existing infrastructure in Plasma. The idea was well-received and it led to a discussion about other related things, like better integration of geolocation services in Plasma, etc.

Day/night wallpapers

Some wallpaper packages can contain light and dark images. Currently, the light image will be used with a light color scheme, and the dark image will be used with a dark color scheme. The main idea behind the new day/night dynamic wallpapers was to exploit this design of the wallpaper packages: switch between light and dark images depending on the elevation of the Sun rather than the color scheme.

The plasma5-wallpapers-dynamic served as the basis for the new dynamic wallpaper mode in Plasma. It works exactly like we want. If geolocation data is available, use it to compute the position of the Sun. The daylight duration varies depending on your location throughout the year; by taking the geolocation into account, the dynamic wallpapers can closely match the dark/light cycle. If the geolocation is unknown, fall back to some pre-configured morning and evening times.

From functional point of view, it doesn’t have any purpose, but it’s a lovely touch that helps you to personalize your computer.

While on this, we also looked into optimizing the wallpaper configuration dialog. Specifically, fixing GridView in QtQuick so it is possible to reuse wallpaper preview items for smoother scrolling and re-working the wallpaper preview generation process for better performance and to make it less error prone.

How to create a day/night wallpaper

A day/night wallpaper is a regular wallpaper package but with light and dark images, Plasma does the rest to figure out what images should be displayed.

For example, imagine that you want to create a wallpaper with a lake. Then the wallpaper would look something like this

Lake/
├── contents
│   ├── images
│   │   ├── 1080x1920.png
│   │   └── 5120x2880.png
│   └── images_dark
│       ├── 1080x1920.png
│       └── 5120x2880.png
└── metadata.json

The Lake folder contains two things: a contents folder with images and a metadata.json file. The metadata.json file provides extra information about the wallpaper, e.g. the author, etc.

{
   "KPlugin": {
       "Authors": [
           {
               "Email": "foobar@example.com",
               "Name": "Name of the author"
           }
       ],
       "Id": "Next",
       "License": "CC-BY-SA-4.0",
       "Name": "Lake"
   },
   "X-KDE-CrossFade": true
}

The Id specifies the unique id of the wallpaper, the Name specifies the human readable name of the wallpaper. The metadata may also contain an X-KDE-CrossFade key, this is used to enable or disable long cross-fade. For example, if the transition from day to night lasts 30 minutes, then Plasma will slowly cross-fade from the light to the dark image for 30 minutes. Such a long cross-fade transition can be undesired if the images are too distinct.

images and images_dark folders contain light and dark images, respectively. Note that image file names must match the image resolution, i.e. 5120x2880.png instead of light.png, etc.

The wallpaper should be installed in /usr/share/wallpapers or ~/.local/share/wallpapers.

knighttime(d)

In addition to day/night wallpapers, it would also be nice if more things could be more dynamic. For example, switching the global theme at night. However, this creates a bit of a problem. If you want to configure the times when wallpapers or themes need to be changed, you will need to set settings for every feature individually, which is not great.

To solve that problem, a new desktop component was introduced that orchestrates when morning and evening transitions occurs – KNightTime. It’s a super duper tiny project with a client library and a daemon (knighttimed) that provides the schedule for day/night cycle transitions.

Since all features that synchronize to the day/night cycle subscribe to KNightTime, you only need to configure it to use specific morning and evening times. Night Light, day/night wallpapers and so on will be all synchronized.

knighttimed runs in background and it is started on demand, so in most cases, you don’t even need to worry about its existence.

Day/night themes

Besides the wallpaper, one can also switch between light and dark global themes depending on time of day.

Perhaps the hardest part about this was figuring out how to retrofit our system settings to accommodate for this new mode rather than actually implementing the logic that changes the active theme. Many thanks to Felix Ernst and Nate Graham for providing mock-ups and feedback about the UI.

It is worth noting that Plasma will switch between the themes only if the computer has been idle for 5 seconds. The main reason behind this is to avoid interruptions while actively using the computer. In case you don’t like it, you can turn it off in system settings or increase the default idle interval if you think it’s too low for your needs.

With the automatic mode, the global theme switching code is going to be stress-tested quite a bit, so we’ve also started (and continue) looking into various paper cut issues regarding theme switching, e.g. some buttons not adapting to the new color scheme correctly, etc.

Future improvements

There are other things that can be synchronized to the day-night cycle, for example screen brightness. Although, there is nothing clear on the radar yet.

Conclusion

The next release is going to feature a few dark mode improvements. Some are pretty technical, some are very user facing. In either case, I hope that things like this will help to make Plasma users happier and make Plasma stand out more among other desktop environments.

Intro

Last week, I added canvas limitations to keep the Selection Action Bar within a user's view. This week, I focused on positioning the toolbar so it renders directly underneath the initial selection instead of a hard coded value on the canvas. This change improves the user experience by reducing mouse travel and making the toolbar feel more intentional and intuitive to use.

Side note: This week I also added 2 buttons: 'Fill with Color' and 'Crop to Selection'.

Obstacles to Implementation

The first step to render the Selection Action Bar under the selection was to find the selection's coordinates.

Mapping Coordinates

The difficulty and learning opportunity I found during this process was understanding the difference between the image space and the canvas space. To keep it simple, selections live in the image space and the Selection Action Bar lives in the canvas space. Due to zooming in and out, different resolutions, and resizing, coordinates in the image space are not always equal to the canvas space. So to translate/map the coordinates of the selection to match where the toolbar should render, we can use KisCoordinatesConverter to translate these coordinates from image space to canvas space.

// get current selection
KisSelectionSP selection = d->m_viewManager->selection();

// get coordinates of current selection
QRectF selectionBounds = selection->selectedRect();
int selectionBottom = selectionBounds.bottom();
QPointF selectionCenter = selectionBounds.center();
QPointF bottomCenter(selectionCenter.x(), selectionBottom);

// translate the selection coordinates to the canvas widget space
QPointF widgetBottomCenter = converter->imageToWidget(bottomCenter);

// adjust/center/space how the toolbar renders under the selection
widgetBottomCenter.setX(widgetBottomCenter.x() - (d->actionBarWidth / 2)); 
widgetBottomCenter.setY(widgetBottomCenter.y() + d->bufferSpace);

// update the relative position of the toolbar
d->dragRectPosition = widgetBottomCenter.toPoint();

Conclusion

With these improvements, the UI now feels user friendly and intentional. For the next (and final) 2 weeks of GSoC, I plan to organize my documentation to build out a technical page on Krita's official documentation website and to refactor some code for better maintainability.

Contact

To anyone reading this, please feel free to reach out to me. I'm always open to suggestions and thoughts on how to improve as a developer and as a person. Email: ross.erosales@gmail.com Matrix: @rossr:matrix.org

The Amarok Development Squad is happy to announce the immediate availability of Amarok 3.3.1, the first bugfix release for Amarok 3.3 "Far Above the Clouds"!

3.3.1 features a number of minor bugfixes and code and build system cleanups. Some occasional crashes related to the new audio backend have also been fixed, and the remaining non-theme icons in user interface have been replaced. The new release also features improvements to the scripting support. Although current scripting functionality is not yet on a par with that of 2.x series in the '10's, especially the script console improvements should help anyone willing to explore the current capabilities.

Changes since 3.3.0

FEATURES:

• Enable saving and loading script console items, autocompletion in script console, and re-enable some more scripting functionality

CHANGES:

• Convert the remaining main UI toolbuttons to use icons from theme
• Clear out remnants of the now-discontinued MusicDNS service

BUGFIXES:

• Fix example permission grant command in database settings (BR 386004)
• Fix equalizer gains not updating when selecting some presets (BR 463908)
• Fix continuing playback after timecoded tracks (cue files etc, (BR 270003)
• Fix MusicBrainz search
• Properly start CD playback if Amarok is not already running (BR 503310)
• Also transmit embedded cover art through MPRIS (BR 357620)
• Don't show transcoding dialog after canceling download (BR 275840)
• Load network information earlier to avoid crashes on startup (BR 507497)
• Try to export as-compatible-as-possible playlist files (BR 507329)
• Fix some random crashes during playback

Getting Amarok

In addition to source code, Amarok is available for installation from many distributions' package repositories, which are likely to get updated to 3.3.1 soon, as well as the flatpak available on flathub.

Packager section

You can find the tarball package on download.kde.org and it has been signed with Tuomas Nurmi's GPG key. One should also observe that Amarok 3.3.1 drops the previous optional build-time dependency to ffmpeg.

As of a couple days ago Filelight on Windows is performing its search many times faster than before. Go check it out!

https://apps.kde.org/filelight/

It’s shocking that it was slow to begin with… A few years ago I rewrote the Filelight file walking logic to use native API for Linux and Windows. I thought I did a pretty good job of it and speed wasn’t too shabby. You can imagine my surprise when a friend recently pointed out that a similar piece of software performed maybe even better. Obviously this couldn’t stand. I immediately went to profile the situation and indeed Filelight wasn’t as fast as expected.

It turns out there are multiple competing APIs for querying file information on Windows and depending on which gets used performance may not be what you would expect. There’s a good write-up at https://www.cppstories.com/2024/cpp-query-file-attribs-faster/ in case you care to read more.

Long story short: by not calling slow API, Filelight is now heaps faster than before. Scans that took multiple seconds before now finish in the blink of an eye.

In case you are wondering just how much faster it is:

New

Old

Enjoy!