So, while working with caching and scrapping, I understood the difference between immutable and mutable objects/datatypes very clearly. I had a scenario, where I am webscraping an API, the code looks like this.

from aiocache import cached

@cached(ttl=7200)
async def get_forecast(station_id: str) -> list[dict]:
 data: dict = await scrape_weather(station_id)
 # doing some operation
 return forecasts

and then using this utility tool in the endpoint.

async def get_forecast_by_city(
 param: Annotated[StationIDQuery, Query()],
) -> list[UpcomingForecast]:
 forecasts_dict: list[dict] = await get_forecast(param.station_id)
 forecasts_dict.reversed()

 forecasts: deque[UpcomingForecast] = deque([])
 for forecast in forecasts_dict:
 date_delta: int = (
 date.fromisoformat(forecast["forecast_date"]) - date.today()
 ).days
 if date_delta <= 0:
 break
 forecasts.appendleft(UpcomingForecast.model_validate(forecast))

 return list(forecasts)

But, here is the gotcha, something I was doing inherently wrong. Lists in python are mutable objects. So, reversing the list modifies the list in place, without creating a new reference of the list. My initial approach was to do this

Welcome to a new issue of This Week in Plasma!

This week we put the finishing touches on Plasma 6.6! It’s due to be released in just a few days and it’s a great release with tons of impactful features, UI improvements, and bug fixes. I hope everyone loves it!

Meanwhile, check out what folks were up to this week:

Notable UI Improvements

Plasma 6.7.0

Moved System Settings’ “Remote Desktop” page to the “Security & Privacy” group in System Settings. (Nate Graham, krdp MR #139)

After

Before

Improved the way loop devices are handled in the Disks & Devices widget. (Bogdan Onofriichuk, plasma-workspace MR #6260)

Reduced visual jagginess in the split image effect of wallpaper previews that show both a light and dark version. (Fushan Wen, plasma-workspace MR #6283)

The Kicker Application Menu widget now supports using a non-square icon for its panel button, just like Kickoff does. (Christoph Wolk, plasma-desktop MR #3522)

Added a dedicated global action for un-tiling a quick-tiled window. It doesn’t have a keyboard shortcut by default, but you can assign one yourself. (Kevin Azzam, KDE Bugzilla #500636)

Videos in SDDM login screen themes can now be previewed in System Settings. (Blue Terracotta, sddm-kcm MR #99)

Improved the appearance of various dialogs created by KWin. Read more here! (Kai Uwe Broulik, kwin MR #8702)

You can now configure how long it takes the window switcher to appear after you start holding down Alt+Tab. (Guilherme Soares, KDE Bugzilla #486389)

Frameworks 6.24

In Kirigami-based apps, hovering the pointer over buttons that can be triggered with keyboard shortcuts now shows the shortcuts. (Joshua Goins, kirigami MR #2040)

After

Before

Gear 26.04.0

Setting up a Samba share for one of your folders so people can connect to it over the network now turns on the Samba service (on systemd-based distros) if needed. This completes the project to make Samba sharing relatively painless! (Thomas Duckworth, KDE Bugzilla #466787)

Notable Bug Fixes

Plasma 6.5.6

Monitor names shown in the Brightness & Color widget now update as expected if you connect or disconnect them while the system is asleep. (Xaver Hugl, KDE Bugzilla #495223)

Fixed multiple issues that caused custom-tiled windows on screens that you disconnect to move to the wrong places on any of the remaining screens. (Xaver Hugl, kwin MR #7999)

Plasma 6.6.0

Hardened KWin a bit against crashing when the graphics driver resets unexpectedly. (Vlad Zahorodnii, kwin MR #8769)

Fixed a case where Plasma could crash when used with the i3 tiling window manager. (Tobias Fella, KDE Bugzilla #511428)

Fixed a potential “division by 0” issue in system monitoring widgets and apps that messed up the display percentage of Swap sensors on systems with no swap space. (Kartikeya Tyagi, libksysguard MR #462)

Worked around a Wayland bug (yes, an actual Wayland bug — as in, a bug in one of its protocol definitions!) related to input method key repeat. Why work around the bug instead of fixing it? Because it’s already fixed in a newer version of the protocol, but KWin needs to handle apps that use the old version, too. (Xuetian Weng, kwin MR #8700)

Unified the appearance of HDR content in full-screen windows and windowed windows. (Xaver Hugl, KDE Bugzilla #513895)

Fixed a layout glitch in the System Tray caused by widgets that include line breaks (i.e. \n characters) in their names. (Christoph Wolk, KDE Bugzilla #515699)

The Web Browser widget no longer incorrectly claims that every page you visit tried to open a pop-up window. (Christoph Wolk, kdeplasma-addons MR #1003)

Fixed a layout glitch in the Quick Launch widget’s popup. (Christoph Wolk, kdeplasma-addons MR #1004)

You can now launch an app in your launcher widget’s favorites list right after overriding its .desktop file; no restart of plasmashell is required anymore. (Alexey Rochev, KDE Bugzilla #512332)

Fixed an issue that made inactive windows dragged from their titlebars get raised even when explicitly configured not to raise in this case. (Vlad Zahorodnii, KDE Bugzilla #508151)

Plasma 6.6.1

When a battery-powered device is at a critically low power level, putting it to sleep and charging it to a normal level no longer makes it incorrectly run the “oh no, I’m critically low” action immediately after it wakes up. (Michael Spears, powerdevil MR #607)

The overall app ratings shown in Discover now match a simple average of the individual ratings. (Akseli Lahtinen, KDE Bugzilla #513139)

Searching for Activities using KRunner and KRunner-powered searches now works again. (Simone Checchia, KDE Bugzilla #513761

Frameworks 6.24

Worked around a Qt bug that caused extremely strange cache-related issues throughout Plasma and Kirigami-based apps that would randomly break certain components. (Tobias Fella, kirigami MR #2039)

Notable in Performance & Technical

Plasma 6.6.0

Added support for setting custom modes for virtual screens. (Xaver Hugl, kwin MR #8766)

Added GPU temperature monitoring support for additional GPUs. (Barry Strong, ksystemstats MR #123)

Plasma 6.7.0

Scrolling in scrollable views spawned by KWin (not Plasma, just KWin itself) no longer goes 8 times slower than it ought to. Thankfully there are very few such views, so almost nobody noticed the issue. However fixing it facilitates adding a “scroll to switch virtual desktops” feature to the Overview effect for Plasma 6.7! (Kai Uwe Broulik, kwin MR #8800)

Frameworks

Moving a file to the trash is now up to 50 times faster and more efficient. (Kai Uwe Broulik, kio MR #2147)

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.

Would you like to help put together this weekly report? Introduce yourself in the Matrix room and join the team!

Beyond that, you can help KDE by directly getting involved in any other projects. Donating time is actually more impactful than donating money. 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.

You can also help out by making a donation! This helps 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 bug fix mentioned here

Push a commit to the relevant merge request on invent.kde.org.

Hey everyone!

I am Siddharth Chopra, a second year engineering student at the Indian Institute of Technology, Roorkee. I'm really excited to be working on Marknote as a part of the Season of KDE program this year, under the mentorship of Carl Schawn.

Marknote, as it is aptly named, is KDE's own markdown based note taking app. The aim of my project is to improve Marknote by adding the much requested source mode, alongside other enhancements.

Progress so far

3 weeks into the project, I have been successful in adding a working source mode functionality to the editor. When source mode is activated, the contents of the source markdown file are allowed to be edited directly, instead of showing the rendered markdown. This is incredibly useful, in cases where the user needs manual control over the contents of the note, or in case there is some glitch in the rendering (which unfortunately still happens often).

Demo Video

Technical Roadmap & Challenges

The main editor of Marknote comes from the file EditPage.qml. As part of my initial approach, I added a global property here to check if source mode was enabled, and then conditionally changed components of this editor. Although this worked, but it brought along some of its own issues. First of all it made the code unnecessarily complex. It also meant that components like the formatting bar now needed to be repurposed to work with source mode, which is a challenge in itself.

So, my mentor suggested to move the raw editor into a new file, to keep the code maintainable. This led to the original EditPage being split into RichEditPage and RawEditPage. Similarly, the respective backends were also split in two, as the needs of both the editors are significantly distinct.

Additionally, I had to consider specially the source mode for images. Because when loaded, image URL's are not kept intact, instead they are replaced with a hash, that maps to the image in memory. Also, the editor internally uses html for rendering images, which I also had to convert back to markdown for source mode.

And someone who is not a designer by any means, deciding the form and placement of the mode toggle button was in itself a mini lesson in UI design ;) Initially I went with a toggle switch. But when I shared that for feedback, I learnt that a checkable button is the ideal UI element here.

Future Plans

My proposal mentions features apart from the source mode, which I plan to complete. While working on the current feature, I noticed multiple bugs in the app, which I intend to fix as well.

Overall experience

It has been a great experience working with the KDE community, and really exciting to be able to contribute to an app that so many users around the world use every day! I would also like to express my gratitude towards my mentor, for being there for whatever issue I faced!

Let’s go for my web review for the week 2026-07.

The Media Can’t Stop Propping Up Elon Musk’s Phony Supergenius Engineer Mythology

Tags: tech, politics, journalism, business

There’s really a problem with journalism at this point. How come when covering the tech moguls they keep leaving out important context and taking their fables at face value?

https://karlbode.com/the-press-is-still-propping-up-elon-musks-supergenius-engineer-mythology/

But they did read it

Tags: tech, literature, scifi, business, politics

Indeed, don’t assume they misunderstood the sci-fi and fantasy they read and you know. Clearly they just got different opinions about it because their incentives and world views are different from your.

https://tante.cc/2026/02/12/but-they-did-read-it/

Microsoft’s AI-Powered Copyright Bots Fucked Up And Got An Innocent Game Delisted From Steam

Tags: tech, game, dmca, copyright, law

Automated DMCA take downs have been a problem for decades now… They still bring real damage, here is an example.

https://www.techdirt.com/2026/02/12/microsofts-ai-powered-copyright-bots-fucked-up-and-got-an-innocent-game-delisted-from-steam/

Launching Interop 2026

Tags: tech, web, browser, interoperability

This is a very important initiative. For a healthy web platform we need good interoperability between the engines. I’m glad they’re doing it again.

https://hacks.mozilla.org/2026/02/launching-interop-2026/

How I built Fluxer, a Discord-like chat app

Tags: tech, foss, messaging

Clearly early days… Could that become a good place to land for people fleeing off Discord?

https://blog.fluxer.app/how-i-built-fluxer-a-discord-like-chat-app/

New And Upcoming IRCv3 Features

Tags: tech, messaging, irc

It’s nice to still see some activity around IRC.

https://libera.chat/news/new-and-upcoming-features-3

Uses an ESP8266 module and an Arduino sketch to display the local time on a inexpensive analog quartz clock

Tags: tech, hardware, embedded, ntp, time

This is definitely a cool hack. Now I feel like doing something like this to every clock I encounter.

https://github.com/jim11662418/ESP8266_WiFi_Analog_Clock

LLVM: Concerns about low-quality PRs beeing merged into main

Tags: tech, ai, machine-learning, copilot, foss, codereview

Clearly Free Software projects will have to find a way to deal with LLM generated contributions. A very large percentage of them is leading to subtle quality issues. This also very taxing on the reviewers, and you don’t want to burn them out.

https://discourse.llvm.org/t/concerns-about-low-quality-prs-beeing-merged-into-main/89748

An AI Agent Published a Hit Piece on Me

Tags: tech, ai, machine-learning, copilot, foss, commons

I guess when you unleash agents unsupervised their ethos tend to converge on the self-entitled asshole contributors? This raise real questions, this piece explains the situation quite well.

https://theshamblog.com/an-ai-agent-published-a-hit-piece-on-me/

Spying Chrome Extensions: 287 Extensions spying on 37M users

Tags: tech, browser, security, attention-economy, spy

Oh this is bad! The amount of data exfiltrated by those malicious extensions. Data brokers will do anything they can to have something to resell. This is also a security and corporate espionage hazard.

https://qcontinuum.substack.com/p/spying-chrome-extensions-287-extensions-495

ReMemory - Split a recovery key among friends

Tags: tech, tools, security

Accidents can happen in life. This might come in handy if you loose memory for some reason. It requires planning ahead though.

https://eljojo.github.io/rememory/

Penrose

Tags: tech, tools, data-visualization

Looks like a nice option for visualisations.

https://penrose.cs.cmu.edu/

Boilerplate Tax - Ranking popular programming languages by density

Tags: tech, programming, language, statistics, type-systems

Interesting experiment even though some of the results baffle me (I’d have expected C# higher in the ranking for example). Still this gives some food for thought.

https://boyter.org/posts/boilerplate-tax-ranking-popular-languages-by-density/

The cost of a function call

Tags: tech, c++, optimisation

If you needed a reminder that inlining functions isn’t necessarily an optimisation, here is a fun little experiment.

https://lemire.me/blog/2026/02/08/the-cost-of-a-function-call/

It’s all a blur

Tags: tech, graphics, blur, mathematics

Wondering if blurs can really be reverted? There’s some noise introduced but otherwise you can pretty much reconstruct the original.

https://lcamtuf.substack.com/p/its-all-a-blur

Simplifying Vulkan One Subsystem at a Time

Tags: tech, graphics, vulkan, api, complexity

There are lessons and inspirations to find in how the Vulkan API is managed. The extension system can be unwieldy, but with the right approach it can help consolidate as well.

https://www.khronos.org/blog/simplifying-vulkan-one-subsystem-at-a-time

What Functional Programmers Get Wrong About Systems

Tags: tech, data, architecture, system, type-systems, functional, complexity

Interesting essay looking at how systems evolve their schemas over time. We’re generally ill-equipped to deal with it and this presents options and ideas to that effect. Of course, the more precise you want to be the more complexity you’ll have to deal with.

https://www.iankduncan.com/engineering/2026-02-09-what-functional-programmers-get-wrong-about-systems/

Modular Monolith and Microservices: Modularity is what truly matters

Tags: tech, architecture, modules, microservices, services, complexity

No, modularity doesn’t imply micro services… You don’t need a process and network barrier between your modules. This long post does a good job going through the various architecture options we have.

https://binaryigor.com/modular-monolith-and-microservices-modularity-is-what-truly-matters.html

Using an engineering notebook

Tags: tech, engineering, note-taking, memory, cognition

I used to do that, fell into the “taking notes on the computer”. And clearly it’s not the same, I’m thinking going back to paper notebooks soon.

https://ntietz.com/blog/using-an-engineering-notebook/

On screwing up

Tags: tech, engineering, organisation, team, communication, failure

Everyone makes mistakes, what matters is how you handle them.

https://www.seangoedecke.com/screwing-up/

Why is the sky blue?

Tags: physics, colors

Excellent piece which explains the physics behind the atmospheric colours. Very fascinating stuff.

https://explainers.blog/posts/why-is-the-sky-blue/

Bye for now!

This release brings improvements to generators, better build system integration and several bugfixes.

As always, big thanks to everyone who reported issues and contributed to QCoro. Your help is much appreciated!

Directly Awaiting Qt Types in AsyncGenerator Coroutines

The biggest improvement in this release is that QCoro::AsyncGenerator coroutines now support directly co_awaiting Qt types without the qCoro() wrapper, just like QCoro::Task coroutines already do (#292).

Previously, if you wanted to await a QNetworkReply inside an AsyncGenerator, you had to wrap it with qCoro():

QCoro::AsyncGenerator<QByteArray> fetchPages(QNetworkAccessManager &nam, QStringList urls) {
 for (const auto &url : urls) {
 auto *reply = co_await qCoro(nam.get(QNetworkRequest{QUrl{url}}));
 co_yield reply->readAll();
 }
}

Starting with QCoro 0.13.0, you can co_await directly, just like in QCoro::Task:

QCoro::AsyncGenerator<QByteArray> fetchPages(QNetworkAccessManager &nam, QStringList urls) {
 for (const auto &url : urls) {
 auto *reply = co_await nam.get(QNetworkRequest{QUrl{url}});
 co_yield reply->readAll();
 }
}

Other Features and Changes

• Generator’s .end() method is now const (and constexpr), so it can be called on const generator objects (#294).
• GeneratorIterator can now be constructed in an invalid state, allowing lazy initialization of iterators (#318).
• qcoro.h now only includes QtNetwork and QtDBus headers when those features are actually enabled, resulting in cleaner builds when optional modules are disabled (#280).

Bugfixes

• Fixed memory leak in QFuture coro wrapper when a task is destroyed while awaiting on a QFuture (#312, Daniel Vr√°til)
• Fixed include paths when using QCoro with CMake’s FetchContent (#282, Daniel Vr√°til; #310, Nicolas Fella)
• Fixed QCoroNetworkReply test on Qt 6.10 (#305, Daniel Vr√°til)

Full changelog

See changelog on Github

Support

If you enjoy using QCoro, consider supporting its development on GitHub Sponsors or buy me a coffee on Ko-fi (after all, more coffee means more code, right?).

Going into Week 3, my next task was clear. I had successfully stopped the Lokalize menubar from jumping around, but it left me with top-level menus that were clickable but completely empty depending on which tab you were using. My goal was to figure out how to dynamically grey out those useless menu headers, like the "Sync" menu in the Project Overview, so users wouldn't be tricked into clicking them.

I started by checking the Qt documentation and a very helpful discussion on the Qt forums to see how to properly handle this. The forum thread highlighted a crucial distinction in the Qt API: using setVisible(false) completely hides a menu, while setEnabled(false) keeps it visible but greys it out. This was an important detail. If i had used setVisible(), the menus would have vanished completely, bringing back the jumping ui bug I had just fixed in Week 1. I needed to use setEnabled() to keep the menu structure frozen in place while making the empty headers unclickable.

To implement this, I hooked directly into the application's tab-switching logic. I wrote a new function that gets triggered every single time a user changes tabs. It grabs the main menubar and loops through every top-level action. For each menu it finds, it checks if the menu has any currently visible actions. If the answer is no, it disables that specific menu header using action->setEnabled(false), turning the menu grey so the user knows it cannot be clicked.

void LokalizeMainWindow::updateMenuAvailability()
{
    QMenuBar *bar = menuBar();
    if (!bar)
        return;

    // Refresh top-level menu state based on currently available actions.
    for (QAction *action : bar->actions()) {
        QMenu *menu = action->menu();
        if (!menu)
            continue;

        // Disable top-level menu when it has no visible actions.
        action->setEnabled(menuHasVisibleAction(menu));
    }
}

bool LokalizeMainWindow::menuHasVisibleAction(const QMenu *menu) const
{
    for (QAction *action : menu->actions()) {
        if (action->isSeparator() || !action->isVisible())
            continue;

        if (QMenu *subMenu = action->menu()) {
            // Check submenu actions too.
            if (menuHasVisibleAction(subMenu))
                return true;
            continue;
        }
        return true;
    }
    return false;
}

The tricky part was writing the helper function to accurately figure out if a menu was actually "empty." It wasn't enough to just check if the menu contained items. Inside the helper, I loop through the menu's actions. If an item is just a ui line (a separator) or is already hidden, the code skips it. I also had to account for nested submenus, so if the action is a submenu, the function calls itself recursively to check inside it. The implementation is completely generic-meaning if anyone adds new menus or actions to Lokalize in the future, this code will handle them automatically.

I opened the merge request, and i'm happy to say it was quickly merged into master! The Lokalize menus now update smoothly based on the context of the active tab. They stay exactly where they belong, and empty menus disable themselves as expected. With this menubar issue resolved:)

The world of free and open-source software (FOSS) is full of big-hearted, altruistic people who love serving society by giving away their labor for free. It’s incredible. These folks are supporting so many people by providing the world with high quality free software, including in KDE, my FOSS community of choice.

But while they do it, who’s supporting them? We don’t talk about this as much.

A recent Reddit post by a volunteer developer burning out reminded me of the topic, and it’s not the first one. Denis Pushkarev of core-js wrote something similar in 2023, and we’re probably all familiar with this XKCD comic:

The topic is also not limited to the FOSS world; it’s broadly applicable to all volunteer activities. Can’t feed the homeless in a soup kitchen if you’re sick and sneezing into the soup! Can’t drive to the library to teach adult reading classes if your car’s broken down.

In order to support others, you need support yourself! Who can provide that support? Here are a bunch of cases that work:

• Yourself in the present (with a job — related or unrelated to your FOSS work)
• Yourself in the past (retired)
• Your partner in the present (married to a primary or sole income-earner)
• Your partner in the past (partner left you lots of money after death or divorce)
• Your parents in the present (you’re their dependent)
• Your parents in the past (born rich or received a big inheritance later)
• The state (disabled, a student, or on a similar program)

All these cases work. They provide enough money to live, and you still get to work on FOSS!

There are lots of other good options, but here are some of the bad ones that don’t work:

• Other people via donations: you never get enough donations, and if you put the effort into fundraising required to make it work, that becomes your job.
• Yourself in the future: if you’re living off loans, you’re screwing over future you!
• Nobody: if you’re eating up your savings, you’ll eventually run out of money and be destitute. If you’re fortunate enough to live in a place where “The state” is an option, it will be at a diminished standard of living.

We must always answer for ourselves the question of how we’re going to be supported while we continue to contribute to the digital commons. If you don’t do it for a living, it’s a critically important question. Never let anyone guilt-trip you into doing volunteer work you don’t have the time or money for! It’s a sure road to burnout or worse.

Airplane safety briefings tell people to “put on your mask before helping others.” Why? Same reason as what we’re talking about here: you can’t support others if you’re not first supported yourself. If you try, you’ll fail, either immediately, or eventually. You must be properly supported yourself before you can be of use to others.

As explained in one of my previous blog posts where I revamped the unresponsive window dialog, KWin isn’t really designed to show regular desktop windows of its own. It instead relies on helper programs to display messages. In case of the “no border” hint, it just launched kdialog, a small utility for displaying various message boxes from shell scripts. This however came with a couple of caveats that have all been addressed now:

First of all, the dialog wasn’t attached to the window that provoked it. When the window was closed, minimized, or its border manually restored, it remained until manually dismissed. Secondly, it said “KDialog” and used a generic window icon (that would have been an easy fix of course). Further, the user might not even have kdialog installed which actually was the case on KDE Linux until very recently. Ultimately and most importantly, it told you that you were screwed if you didn’t have a keyboard but didn’t offer and help if you really went without one. I therefore added an option to restore the border right from the dialog. Should you have a dedicated global shortcut configured for this action, it will also be mentioned in the dialog.

The dialog when manually setting a window full-screen has similarly been overhauled, including an undo option. While at it, I removed the last remaining code calling kdialog, too: the “Alt+tab switcher is broken” message. It is now a proper KNotification. Something you should never see, of course.

Another dialog that I gave some attention was the prompt when copying a file would overwrite its destination. If you have Kompare installed and copy a plain text file (that includes scripts, source code, and so on), the dialog displays a “Compare Files” button. It already guesstimated whether the files are similar but now you can actually see it for yourself.

KIO’s PreviewJob that asynchronously generates a file preview now provides the result of its internal stat call, too. This means that once you receive the preview, you also get the file’s properties, such as size, modified time, and file type basically for free. The rename dialog then displays this information in case it wasn’t provided by the application already. Dolphin now also makes use of this information while browsing a folder which should improve responsiveness when browsing NFS and similarly mounted network shares. At least when previews are enabled, it no longer determines file types synchronously in most scenarios.

Since the rename dialog is able to fetch file information on demand, Ark, KDE’s archiver tool, rewrites the source URL it displays in the dialog to a zip:/ URL (or tar:/ or whatever supported archive type). This way the dialog can display a preview transparently through the Archive KIO worker which also gained the ability to determine a file’s type from its contents. In case you didn’t know, you can configure Dolphin to open archives like regular folders.

Finally, most labels in KIO that show the mtime/ctime/atime no longer include the time zone unless it is different from the system time zone. Showing “Central European Standard Time” in full after every date was a bit silly. Unfortunately, QLocale isn’t very flexible and only knows “short” (19:00) or “long” (19:00:00 Central European Standard Time) formats. You can’t explicitly tell it to generate a time string with seconds, or with 12/24 hour clock, or a date with weekday but no year, and unfortunately the “long” time format includes the full time zone name.