Last week I attended this year’s FOSSGIS Konferenz in Münster, Germany, focusing on public transport and indoor navigation topics.

Indoor Navigation

We use indoor map rendering and indoor routing in KDE Itinerary for e.g. train stations. There were a number of interesting talks and discussions in that area:

• A 2.5D visualization of buildings and especially of the vertical connectivity (stairs, elevators, etc) between floors, by a team from TU Dresden, with a free implementation available. Compared to our current 2D view this makes it easier to understand how to move between floors, but it brings new challenges as well (video).
• Indoor localization and routing including an AR demo by the German Federal Agency for Cartography and Geodesy (BKG). The routing is done via Unity, which uses the same library underneath that we use as well. Localization is using a mix of sensors available in normal smart phones, which is particularly interesting for us. Unfortunately like most similar systems the implementation isn’t published (talk).
• Work on importing building geometries for 400+ buildings of TU München, using IFC BIM data. That’s the best way to get high-quality building geometries into OSM I think, but while there has been previous work on building an import toolchain for this, getting the actual BIM data has been elusive due to various concerns by building owners.
• Modelling and tagging of infrastructure in and around train stations in OSM (session notes).

And of course there was also the yearly offline FOSSGIS edition of the OSM indoor meetup for connecting everyone working on that subject (translated session notes).

Open Transport

The other big topic for me was public transport routing, which we do in Transitous, for use in Itinerary and many other apps.

There were several talks and poster sessions in that area:

• Katharina presented her work on an explorative long distance journey planning UI (English version from FOSDEM here). I’d really like to see Transitous become a platform to build such innovative UIs on top, so you can focus on that rather than redoing the entire data handling and routing.
• My own talk introducing Transitous.
• Felix spoke about the routing capabilities of MOTIS, the routing engine Transitou is built upon.
• René showed work on developing and standardizing data formats for describing public transport vehicles in great detail. That’s badly needed for considering accessibility during routing, the current modelling in GTFS (basically “wheelchair=yes|no”) is way to simplistic for that.
• A talk about DB Regio’s vehicle position processing. Especially deriving delay estimates from position data is highly relevant for Transitous, but unfortunately neither their data nor their code seems to be openly available.

There also has been a lot of hallway track discussion on this:

• Together with several MOTIS users and contributors we reviewed and updated the MOTIS feature wish list.
• There are ideas for collaborating on a public transport optimized geocoder, between Nominatim, Transitous and other people needing this. Currently this is usually based on OSM data, but additionally using schedule data would allow things like considering the number of lines or trips at a stop for ranking. “Meta-stations” were another subject, ie. if you select “Paris” as the destination any of its major railway stations and airports would be expected destination, rather than just the first stop inside the city boundary.
• GTFS data quality was a prevalent topic, including during the offline FOSSGIS edition of the Open Transport Meetup, and now also with the German Federal Agency for Cartography and Geodesy (BKG) joining everyone else in exploring the wonders of this. More eyes (and more pressure) can only help here.
• Possible datasets for elevation models usable for routing, for Transitous something particularly interesting for first/last mile bike routing.
• Plans for a Transitous sprint/hack weekend are getting a bit more concrete, with two promising options in June/July.
• Ideas for improving Transitous’ outreach activities and social media presence/PR.

Also, if you are interested or involved in FOSS or Open Data topics around mobility/transit keep October 17/18 free, there’s an exciting announcement coming up shortly.

OSM

The FOSSGIS conference is of course much larger than just those two topics, and while those kept me occupied most of the time I managed to pick up a few more things as well:

• Pirmin’s talk on showing realtime data layers with MapLibre should come in handy for getting live updates onto the map view for monitoring our emergency and weather alert aggregation server. This talk also featured a Transitous live demo, something I didn’t dare doing myself.
• Frederik’s work on PostPass could turn out to be a vastly more efficient way to extract region or timezone boundary polygons than our current approach that takes hours and needs a full local OSM planet file.

And as always when hanging out with people from different communities there’s experiences to share on things like mentorship and funding programs as well as nowadays sadly also on defense measures to protect our infrastructure from overly aggressive AI crawler bots.

Welcome to a new issue of "This Week in Plasma"! Every week we cover the highlights of what's happening in the world of KDE Plasma and its associated apps like Discover, System Monitor, and more.

This was a week of smaller improvements: lots of stability enhancements user interface upgrades. All good preparation for Plasma 6.4, which will be released in a little over two months!

Notable UI Improvements

Plasma 6.4.0

Sticky Notes widgets that live in a panel can now have their pop-up pinned open, just like most other panel pop-ups. (Christoph Wolk, link)

Notifications no longer switch to scientific notation when showing extremely large numbers; now they always show normal numbers. (Nate Graham, link)

Did a round of UI polish on the crash reporting wizard to improve its layout, appearance, and text clarity. (Thomas Duckworth, link)

If you change the cursor blink rate (currently a hidden setting, but we may expose it in the GUI), this preference will now be synced to GTK-based apps too. (Kai Uwe Broulik, link)

KWin's Zoom effect and Plasma's desktop mouse wheel actions are now much easier to trigger and end by scrolling with a touchpad or a mouse with a high resolution scroll wheel. (Xaver Hugl, link 1 and link 2)

Persistent notifications can now be sent to the notification history in case you don't want to look at them anymore, but keep them around for later, e.g. for timers. (Kai Uwe Broulik, link)

Improved the visuals of the portal-based account details request dialog. (Joshua Goins, link)

Sound themes can now be applied with a double-click, same as other items on System Settings' grid-based theme chooser pages. (Kai Uwe Broulik, link)

Frameworks 6.14

Telegram's System Tray icons are once again Breeze-themed when using the Breeze Icon theme and Telegram version 5.12.4 or later; we had to create some symlinks to react to Telegram changing the icon names they use. (Rocket Aaron and Nate Graham, link)

Notable Bug Fixes

Plasma 6.3.4

Fixed a variety of small layout bugs in notifications: now URLs and long words wrap properly; the orange line on critical notifications no longer squares off the normally-rounded bottom-left corner; and internal paddings and spacings have been restored to exactly what they were in Plasma 6.2 and earlier, undoing some small layout changes unintentionally introduced with the big code refactor in Plasma 6.3. (Nate Graham, link 1, link 2, link 3, link 4, and link 5)

The "Always open with this app" option in portal-based app chooser dialogs now actually works. (Nicolas Fella, link)

Plasma 6.3.5

Fixed a somewhat common Plasma crash related to power-cycling screens in multi-screen setups. (Marco Martin, link)

Fixed a bunch of bugs related to notifications not moving to new positions when they should under various circumstances. (Marco Martin, link)

When using multiple screens, reverting a change to one of the screen's settings no longer makes the UI inappropriately show the settings of the other screen. (Oliver Beard, link)

Plasma 6.4.0

Fixed a case where KWin could crash with misbehaving 3rd-party scripts. (David Redondo, link)

Fixed auto-update in Discover again, as part of a larger package of work to make the notifier tray widget behave more reliably and predictably. (Aleix Pol, link)

Switching pages in Plasma widgets' configuration dialogs no longer inappropriately prompts you to save or discard your changes when there were no changes! (Christoph Wolk, link)

Frameworks 6.13

Fixed a bug in Kirigami that resulted in Plasma widgets' config dialogs and "Get New [thing]" dialogs sometimes missing their header text or buttons. (Marco Martin, Link)

Other bug information of note:

• 1 very high priority Plasma bug (up from 0 last week). Current list of bugs
• 18 15-minute Plasma bugs (same as last week). Current list of bugs

Notable in Performance & Technical

Plasma 6.4.0

System Monitor and its widgets are now capable of getting statistics from Intel GPUs. (David Redondo, link)

Improved KWin's startup speed a little bit by not having it pointlessly compute font metrics for something that didn't really need to adjust with the font size anyway. (Aleix Pol Gonzalez, link)

Refactored the portal-based dialogs in a way that eliminates an entire class of crashes, both actual and potential. (David Redondo, link)

Made Plasma practically silent in its log output. This project is almost finished! (Christoph Wolk, link 1, link 2, link 3, link 4, link 5, link 6, and link 7)

How You Can Help

KDE has become important in the world, and your time and contributions have helped us get there. As we grow, we need your support to keep KDE sustainable.

You can help KDE by becoming an active community member and getting involved somehow. Each contributor makes a huge difference in KDE — you are not a number or a cog in a machine!

You don’t have to be a programmer, either. Many other opportunities exist:

• Triage and confirm bug reports, maybe even identify their root cause
• Contribute designs for wallpapers, icons, and app interfaces
• Design and maintain websites
• Translate user interface text items into your own language
• Promote KDE in your local community
• …And a ton more things!

You can also help us by making a donation! Any monetary contribution — however small — will help us cover operational costs, salaries, travel expenses for contributors, and in general just keep KDE bringing Free Software to the world.

To get a new Plasma feature or a bugfix mentioned here, feel free to push a commit to the relevant merge request on invent.kde.org.

Let’s go for my web review for the week 2025-14.

How crawlers impact the operations of the Wikimedia projects

Tags: tech, ai, machine-learning, gpt, criticism, knowledge

Unsurprisingly, Wikimedia is also badly impacted by the LLM crawlers… That puts access to curated knowledge at risk if the trend continues.

https://diff.wikimedia.org/2025/04/01/how-crawlers-impact-the-operations-of-the-wikimedia-projects/

Beyond Public Access in LLM Pre-Training Data: Non-public book content in OpenAI’s Models – Social Science Research Council (SSRC)

Tags: tech, ai, machine-learning, gpt, copyright, ethics

We just can’t leave the topic of how the big model makers are building their training corpus unaddressed. This is both an ethics and economics problem. The creators of the content used to train such large models should be compensated in a way.

Between this, the crawlers they use and the ecological footprint of the data centers, there are so many negative externalities to those systems that law makers should have cease the topic a while ago. The paradox is that if nothing is done about it, the reckless behavior of the model makers will end up hurting them as well.

https://www.ssrc.org/publications/beyond-public-access-in-llm-pre-training-data-non-public-book-content-in-openais-models/

AI ambivalence

Tags: tech, ai, machine-learning, gpt, copilot, criticism

I somehow recognise myself in this piece. Not completely though, I disagree with some of the points… but we share some baggage so I recognize another fellow.

https://nolanlawson.com/2025/04/02/ai-ambivalence/

Why I stopped using AI code editors

Tags: tech, ai, machine-learning, gpt, copilot, learning, knowledge

Even if you use LLMs, make sure you don’t depend on them in your workflows. Friction can indeed have value. Also if you’re a junior you should probably seldom use them, build your skill and knowledge first… otherwise you’ll forever be a beginner and that will bite you hard.

https://lucianonooijen.com/blog/why-i-stopped-using-ai-code-editors/

Pixelfed leaks private posts from other Fediverse instances - fiona fokus

Tags: tech, social-media, fediverse

Clearly the security practice around Pixelfed bears questioning. I’m also a bit surprise at the lack of protection of private messages in the ActivityPub protocol (even though it’s a hard admittedly a hard problem).

https://fokus.cool/2025/03/25/pixelfed-vulnerability.html

How to report a security issue in an open source project - Jacob Kaplan-Moss

Tags: tech, foss, security

This is considered standard practice at this point. The article does a good job explaining it and the reasoning behind it.

https://jacobian.org/2025/mar/27/reporting-security-issues-in-oss/

The Surprise of Multiple Dependency Graphs - ACM Queue

Tags: tech, dependencies, supply-chain

Dependency resolution is harder than people generally expect. This is a difficult problem and is very sensitive to the context.

https://queue.acm.org/detail.cfm?ref=rss&id=3723000

A Retrospective on the Source Code Control System

Tags: tech, version-control, history

This paper is a look back at SCCS. This is nice to see how much progress was made in version control systems since then, it’s also interesting to see how the design choices changed.

https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=10821013

git-revise

Tags: tech, version-control, git, tools

Looks like a nice alternative to git rebase to manage patchsets. Definitely interesting if you’re using something like Gerrit. With other forges… It’ll depend how your reviews are handled I think.

https://mystor.github.io/git-revise.html

Gerrit, GitButler, and Jujutsu projects collaborating on change-id commit footer

Tags: tech, version-control, git, codereview

Could be interesting if it gets standardized. Maybe other forges than Gerrit will start leveraging the concept, this would improve the review experience greatly on those.

https://lore.kernel.org/git/CAESOdVAspxUJKGAA58i0tvks4ZOfoGf1Aa5gPr0FXzdcywqUUw@mail.gmail.com/T/#u

Empowering WebAssembly with Thin Kernel Interfaces

Tags: tech, webassembly, virtualization, portability, research

This is interesting research. It shows nice prospects for WebAssembly future as a virtualization and portability technology. I don’t think we’ll see all of the claims in the discussion section realized though.

https://dl.acm.org/doi/pdf/10.¹¹⁴⁵⁄_3689031.3717470

A Study of Undefined Behavior Across Foreign Function Boundaries in Rust Libraries

Tags: tech, rust, safety

Rust itself might bring interesting properties in term of safety. As soon as it needs to interact with other languages though the chances of undefined behavior increase drastically. This definitely pushes towards using more dynamic analysis tools to catch those.

https://arxiv.org/abs/2404.11671

Introducing Stringleton

Tags: tech, rust, memory, safety

Nice feature, but more interesting in its explanation is the topic of static initializers in Rust. They’re clearly not a settled area in the language, that’s in part because of how low level static analyzers are.

https://simonask.github.io/introducing-stringleton/

A pattern for obtaining a single value while holding a lock

Tags: tech, multithreading, c++

This is indeed a nice pattern to obtain a value, brings neat advantages.

https://devblogs.microsoft.com/oldnewthing/20250127-00/?p=110809

Deadlock-free Mutexes and Directed Acyclic Graphs

Tags: tech, multithreading, rust

Interesting trick to check at runtime that you always acquire mutexes in the same order.

https://bertptrs.nl/2022/06/23/deadlock-free-mutexes-and-directed-acyclic-graphs.html

Anime.js | JavaScript Animation Engine

Tags: tech, web, frontend, animation

Interesting JS library for animation on the Web. It’s nice that it seems really small.

https://animejs.com/

Learn CSS Layout The Pedantic Way

Tags: tech, web, frontend, css

Looks like a nice resource to deep dive into CSS layouts and really understand their behaviours.

https://book.mixu.net/css/

CSS System colors

Tags: tech, web, frontend, css, colors

Nice way to have a web frontend which respects the system color choices of the user.

https://anto.pt/articles/css-system-colors

Minimal CSS-only blurry image placeholders

Tags: tech, web, frontend, colors

This is a very smart way to create pure CSS placeholders.

https://leanrada.com/notes/css-only-lqip/

The Fifth Kind of Optimisation

Tags: tech, multithreading, optimization, rust

A good look back at parallelisation and multithreading as a mean to optimise. This is definitely a hard problem, and indeed got a bit easier with recent languages like Rust.

https://tratt.net/laurie/blog/2025/the_fifth_kind_of_optimisation.html

Ports and fat adapters

Tags: tech, architecture, complexity

A good reminder of why you often don’t want to follow an architecture pattern to the letter. They should be considered like guidelines and depending on your technical context you should properly balance the costs. Here is an example with the Ports and Adapters pattern in the context of an ASP.NET application.

https://blog.ploeh.dk/2025/04/01/ports-and-fat-adapters/

Thoughts on ECS | Voxagon Blog

Tags: tech, architecture, simulation, game

Nice post about pros and cons of ECS architectures.

https://blog.voxagon.se/2025/03/28/thoughts-on-ecs.html

The manager I hated and the lesson he taught me

Tags: tech, programming, engineering, leadership

For sure the aforementioned manager need to fix his communication style. That being said the core advice was indeed good.

https://www.blog4ems.com/p/the-manager-i-hated

Bye for now!

Akademy 2025 will be a hybrid event held simultaneously in Berlin, Germany, and online. The Call for Participation is open! Send us your talk ideas and abstracts.

Why talk at #Akademy2025

Akademy attracts artists, designers, developers, translators, users, writers, companies, public institutions and many other KDE friends and contributors. We celebrate the achievements and help determine the direction for the next year. We all meet together to discuss and plan the future of the Community and the technology we build. You will meet people who are receptive to your ideas and can help you with their skills and experience. You will get an opportunity to present your application, share ideas and best practices, or gain new contributors. These sessions offer the opportunity to gain support and make your plans for your project become a reality.

How to get started

Do not worry about details or slides right now. Just think of an idea and submit some basic details about your talk. You can edit your abstract after the initial submission. All topics relevant to the KDE Community are welcome. Here are a few ideas to get you started on your proposal:

• How KDE can empower building robust communities in changing political climates
• Work towards KDE's goals: Streamlined Application Development Experience, We care about your Input, and KDE Needs You
• Giving people more digital freedom, sovereignty, and autonomy with KDE software
• Guides on how to participate for new users, intermediates and experts,
• New developments/plans for KDE Frameworks, Plasma, Applications and other projects
• Anything else that might interest the audience.

To get an idea of talks that were accepted, check out the program from previous years: 2024, 2023, 2022, 2021 and 2020.

For more details and information, visit our Call for Participation.

Model/View Drag and Drop in Qt - Part 3

Step 1

Step 2

Step 3

Step 4

class EmailsModel : public QAbstractTableModel
{
    ~~~
    Qt::ItemFlags flags(const QModelIndex &index) const override
    {
        if (!index.isValid())
            return {};
        return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDragEnabled;
    }

    // the default is "copy only", change it
    Qt::DropActions supportedDragActions() const override { return Qt::MoveAction | Qt::CopyAction; }

    QMimeData *mimeData(const QModelIndexList &indexes) const override;

    bool removeRows(int position, int rows, const QModelIndex &parent) override;

bool EmailsModel::removeRows(int position, int rows, const QModelIndex &parent)
{
    beginRemoveRows(parent, position, position + rows - 1);
    for (int row = 0; row < rows; ++row) {
        m_emailFolder->emails.removeAt(position);
    }
    endRemoveRows();
    return true;
}

class FoldersModel : public QAbstractTableModel
{
    ~~~    
    Qt::ItemFlags flags(const QModelIndex &index) const override
    {
        CHECK_flags(index);
        if (!index.isValid())
            return {}; // do not allow dropping between items
        if (index.column() > 0)
            return Qt::ItemIsEnabled | Qt::ItemIsSelectable; // don't drop on other columns
        return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsDropEnabled;
    }

    // the default is "copy only", change it
    Qt::DropActions supportedDropActions() const override { return Qt::MoveAction | Qt::CopyAction; }
  
    QStringList mimeTypes() const override { return {QString::fromLatin1(s_emailsMimeType)}; }
  
    bool dropMimeData(const QMimeData *mimeData, Qt::DropAction action, int row, int column, const QModelIndex &parent) override;
};

bool FoldersModel::dropMimeData(const QMimeData *mimeData, Qt::DropAction action, int row, int column, const QModelIndex &parent)
{
    ~~~  // safety checks, see full example code

    EmailFolder *destFolder = folderForIndex(parent);

    const QByteArray encodedData = mimeData->data(s_emailsMimeType);
    QDataStream stream(encodedData);
    ~~~ // code to detect and reject dropping onto the folder currently holding those emails

    while (!stream.atEnd()) {
        QString email;
        stream >> email;
        destFolder->emails.append(email);
    }
    emit dataChanged(parent, parent); // update count

    return true; // let the view handle deletion on the source side by calling removeRows there
}

The post Model/View Drag and Drop in Qt - Part 3 appeared first on KDAB.

This is for everyone upgrading to Plasma 6.3.4, which was released yesterday. I suspect that some of you will notice something slightly wrong with notifications; the top padding is off, causing text to look not vertically centered most of the time.

This is my fault. The recent bug-fixes I made to notification spacings and paddings were backported to Plasma 6.3.4, but ended up missing a part that positions the text labels nicely when there’s body text or an icon, and didn’t notice this until after 6.3.5 was released. The fix was just merged and backported for Plasma 6.3.5, so unless your distro backports the fix (I’ve already emailed the appropriate mailing list about this) you’ll have to live with slightly ugly label positioning until then. Sorry folks! My bad.

Once you have the fix — either because your distro backports it or because you’ve waited until Plasma 6.3.5 — notification text positioning should look better again:

In Konsole Layout Automation (part 1), I wrote about how to automate opening Konsole with different tabs that ran different commands. In this post, I'll talk about doing this for layouts.

Inspiration

In the past, I needed to open two connections to the same host over ssh , and change to two different directories. I opened Konsole with a layout that had two panes. Then, Quick Commands allowed me to run a command in each pane to ssh and change to the right directory. This post will outline how to achieve that and more!

Goal: Launch a Konsole window with one tab that has multiple panes which run commands

💡 Note For more detailed instructions on using Konsole, please see the output of konsole --help and take a look at the Command-line Options section of the Konsole Handbook

A layout can save and load a set of panes. Unfortuately, it can't do anything else. We can, however, use profiles and the Quick Commands plugin to make the panes more useful.

Use case: See the output of different commands in the same window. For instance, you could be running htop in one pane and open your favorite editor in another.

Here's an overview of the steps:

• Set up a layout
• Use QuickCommands to run things in the panes

Set up a layout

Unfortunately, the online documentation for Konsole command line options doesn't say much about how to create a layout, or the format of its JSON file. It only mentions the command line flag --layout. Also make a note of -e which allows you to execute a command.

Fortunately, creating the layout is pretty easy. Note that a layout is limited to one tab. It will only save the window splits, nothing else. No profiles, directories, etc.

1. Set up a tab in Konsole with the splits you want it to have
2. Use View -> Save Tab Layout to save it to a .json file. (I personally recommend keeping these in a specific directory so they're easy to find later, and for scripting. I use ~/konsole-layouts).
3. You can then use konsole --layout ~/layout-name.json to load konsole with a tab that has the splits you saved.

Use Quick Commands to do useful things in your layout

As mentioned above, you can only save splits. you can't associate a profile, or run a command directly like you can with the tilix or kitty terminals. This has been requested. In the meantime, an easy thing you can do is load a layout and then load a profile manually in each pane. This is where Quick Commands come in. These are under Plugins - Quick Commands. (If you don't see this, contact your distro / the place you installed Konsole from).

You can use Quick Commands to run a command in each pane. You can also launch a profile (with different colors etc) that runs a command (part 1 showed how these might be used). Note, however, that running konsole itself from here will launch a new Konsole window.

End each command with || return so that you get to a prompt if the command fails.

Examples

htop || return

So, after you've launched Konsole with your layout as described above, you can do this: Go to Plugins -> Show Quick Commands Add commands you'd like to run in this session. Now, focus the pane and run a command.

Using these steps, I can run htop in one pane and nvtop in the other.

After you've gotten familiar with tabs and layouts, you can make a decently powerful Konsole session. Combine these with a shell function, and you can invoke that session very easily.

This is still too manual!

You're right. This post is about automating Konsole and having to click on things is not exactly that. You can use dbus commands in a script to load your tab layout and then run commands in each pane without using Quick Commands.

As we saw in the last post, you can use profiles to customize color schemes and launch commands. We can call those from a script in a layout. The demo scripts used below use dbus, take a look at the docs on scripting Konsole for details.

I'm using the layout file ~/konsole_layouts/monitoring.json for this example. This layout file represents two panes with one vertical split (horizontal orientation describes the panes being horizontally placed):

{
 "Orientation": "Horizontal",
 "Widgets": [
 {
 "SessionRestoreId": 0
 },
 {
 "SessionRestoreId": 0
 }
 ]
}

Here's an example of a simple script using that layout, which will launch fastfetch in one pane and btm in the other:

#!/usr/bin/env bash

# Define the commands to run
cmd1="fastfetch"
cmd2="btm"

# Opens a konsole tab with a saved layout
# Change the path to point to the layout file on your system
# KPID is used for renaming tabs

konsole --hold --layout $HOME/konsole_layouts/monitoring.json & KPID=$!

# Short sleep to let the tab creation complete
sleep 0.5

# Runs commands in Konsole panes
service="$(qdbus | grep -B1 konsole | grep -v -- -- | sort -t"." -k2 -n | tail -n 1)"

qdbus $service /Sessions/1 org.kde.konsole.Session.runCommand "${cmd1}"
qdbus $service /Sessions/2 org.kde.konsole.Session.runCommand "${cmd2}"

# Renames the tabs - optional
qdbus org.kde.konsole-$KPID /Sessions/1 setTitle 1 'System Info'
qdbus org.kde.konsole-$KPID /Sessions/2 setTitle 1 'System Monitor'

What it does:

• Loads a layout with 2 panes, horizontally arranged
• Runs clear and then fastfetch in the left pane; runs btm in the right pane

Wrap-up

That's how you can accomplish opening a number of panes in konsole which run different commands. Using this kind of shortcut at the start of every work / programming session saved a little time every day which adds up over time. The marketing peeps would call it "maximizing efficiencies" or something. I hope some folks find this useful, and come up with many creative ways of making konsole work harder for them.

Known issues and tips

• Running konsole from a Quick Command will open a new window, even if you want to just open a new tab.
• You may see this warning when using runCommand in your scripts. You can ignore it. I wasn't able to find documentation on what the concern is, exactly.

The D-Bus methods sendText/runCommand were just used. There are security concerns about allowing these methods to be public. If desired, these methods can be changed to internal use only by re-compiling Konsole. This warning will only show once for this Konsole instance.

Credits to inspirational sources

• Thanks to the Cool-Konsole-setup repo, where I found an example script for using commands in a layout via qdbus. Note: The scripts in that repo did not work as-is.
• This answer on Ask Ubuntu for improvements on the example scripts.

Tuesday, 1 April 2025. Today KDE releases a bugfix update to KDE Plasma 6, versioned 6.3.4.

Plasma 6.3 was released in February 2025 with many feature refinements and new modules to complete the desktop experience.

This release adds three weeks’ worth of new translations and fixes from KDE’s contributors. The bugfixes are typically small but important and include:

• Fix glitch while scrolling with touch. Commit.
• ToolsAreaManager: Store windows as a vector. Commit. Fixes bug #501688
• Kstyle: Don't replay scrollbar mouse event to same position. Commit.

Hey everyone!!

Welcome to my blog post. I am Roopa Dharshini, a mentee in Season of KDE 2025 for the KEcoLab project. In this blog, I will explain my work in the SoK mentorship program.

Getting Started With SoK

For my proposal I crafted a detailed timeline for each week. With this detailed plan and with the help of my wonderful fellow contributors and mentors, I was able to complete all the work before the end of the mentorship program.

CC-BY-SA-4.0 license.)" src="https://eco.kde.org/blog/images/2025-03-31-roopa-sok25-proposal.png" style="max-width: 100%; height: auto" />

I started by first week working to understanding the project's codebase, studying KECoLab's handbook and existing documentation, setting up a GitLab wiki in the forked repository, and discussing the GitLab wiki's Merge Request (MR) feature. I explored and discussed various technical documentation tools with the mentors. Initially, we had planned to continue with GitLab, but later due to the flexibility of KDE's community wiki, we proceeded with that as our preferred documentation tool.

CC-BY-SA-4.0 license.)" src="https://eco.kde.org/blog/images/2025-03-31-roopa-sok25-usage-scenario.png" style="max-width: 100%; height: auto" />

I got to work creating an outline for the entire technical documentation. Usage scenarios scripts are essential for executing the automation pipeline in KEcolab. So, my fellow mentees and I started our documentation process with usage scenario scripting: we drafted a short page describing it's importance, provided some scripts, and detailed their structure. This documentation is structured in a way that even non-technical contributors are able to follow the guidelines and create their own scripts.

CC-BY-SA-4.0 license.)" src="https://eco.kde.org/blog/images/2025-03-31-roopa-sok25-ci-cd.png" style="max-width: 100%; height: auto" />

After this, I wrote various texts for the technical documentation (CI/CD pipeline, Home Page) of the KEcoLab project. There was a change in the audience for our documentation: initially we focused on the users of KEcoLab, but later we decided to write documentation for both the people who wish to contribute and provide new changes to KEcoLab as well as those who use KEcoLab for their software measurements. This change had us writing in-depth technical documentation for developers who wish to change the code for better efficiency. The CI/CD pipeline is essential for the energy measurement automation in KEcoLab. Writing detailed CI/CD pipeline documentation that explains its use, structure, and job execution was challenging, yet rewarding.

Final Documentation Links

1. User Guide documentation for KEcoLab Users
2. Usage Scenario Script documentation
3. Accessing result documentation for users
4. CI/CD pipeline documentation for contributors
5. Contribution guidelines

How did I apply to Season of KDE?

CC-BY-SA-4.0 license.)" src="https://eco.kde.org/blog/images/2025-03-24-roopa-sok25-proposal.png" style="max-width: 100%; height: auto" />

Season of KDE is a mentorship program that happens every year between January and March. It is a three-month mentorship where mentees will be guided through a project they propose. You start by writing a proposal and timeline to work on from the projects listed on the KDE Ideas page. You tag the mentors in the issue, and they will review your proposal and check whether you are suitable or not. You can checkout my proposal for the KEcoLab project. After review, mentors will hopefully mark your proposal as accepted. And that’s how I got into it!

Challenges I faced

Applying to SoK was not easy for me. I ran into my first challenge when I tried to create a new KDE Invent account. I thought there were some technical issues with the website, so I tried every day to create an account (you are limited to one account creation chance per 24-hour period). After a long wait, I reached out to SoK admin Johnny for help, and he assisted me in creating an account. I was really scared to submit my proposal because there was only one week before the submission deadline, but I trusted my skills and submitted it. So, keep in mind that “it is never too late to apply."

The second challenge was team collaboration. Similar to me, there were 2 other contributors selected for this project. I was brand new to KDE. At first it was hard to communicate with my other contributors, but later on we started to work really well together. Those are the main challenges I faced during my contributions to SoK. Challenges are never an end point; they are a stepping stone to move further.

Thank You Note!

Challenges make the journey worthwhile. Without any challenges, I wouldn’t have known the perks of contributing to KDE in SoK. I take a moment here to thank my wonderful mentors Kieryn, Aakarsh, Karanjot, and Joseph for guiding me throughout this journey. Also, I want to thank my fellow contributors to the project Shubhanshu and Utkarsh for collaborating with me to achieve what we proposed successfully. Finally, I am thankful to the KDE e.V. and the KDE community for supporting us new contributors to the amazing KDE project.

KEcoLab is hosted on Invent. Are you interested in contributing? You can join the Matrix channels Measurement Lab Development and KDE Eco and introduce yourself.

Thank you!