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 week we finished polishing up Plasma 6.4 for release, and started to turn our heads to bigger topics — notably including Wayland protocols and accessibility!

Notable New Features

Plasma 6.5.0

Implemented support for an experimental version of the Wayland picture-in-picture protocol that allows apps also implementing it (such as Firefox) to finally display proper PiP windows in advance of the upstream version of the protocol eventually being merged. (Vlad Zahorodnii, link)

Notable UI Improvements

Plasma 6.3.6

Reduced the rate at which the “visual bell” accessibility feature can flash the screen so there’s no way it can cause seizures. (Nicolas Fella, link)

Plasma 6.4.0

Made the Kicker Application Menu widget able to horizontally scroll for searches that return results from many KRunner plugins, so you have the opportunity to see them all. (Christoph Wolk, link)

Plasma 6.4.1

Improved text contrast for labels used in subtitles or other secondary roles throughout Plasma. (Nate Graham, link 1, link 2, link 3, link 4, link 5, link 6, and link 7)

Discover’s search field now trims all whitespace, to prevent errors when copy-pasting text that ends in a space or something. (Nate Graham, link)

Plasma 6.5.0

In System Settings, moved the Invert and Zoom settings into the Accessibility page, which is a more sensible place for them than the Desktop Effects page was. (Oliver Beard, link 1, link 2, and link 3)

Merged KWin’s Background Contrast effect into the Blur effect, since neither makes sense to turn on or off without the other. (Marco Martin, link 1 and link 2)

On Wayland, virtual desktops can now be re-ordered from the Pager widget, and re-ordering them in the Overview effect’s grid view now re-orders them in the Pager widget too. (Marco Martin and Vlad Zahorodnii, link 1, link 2, and link 3)

Spectacle now makes it clearer that you can end a screen recording by pressing the same keyboard shortcut you used to start it, by telling you this in the notification and also by using clearer names for the global shortcuts. (Noah Davis, link)

The Breeze application style’s animated effects for clicking checkboxes and radio buttons now work in QtQuick-based apps and System Settings pages as well. (Kai Uwe Broulik, link)

The Disks & Devices, Networks, and Bluetooth widgets now use standard-style section headers. (Nate Graham, link 1, link 2, and link 3)

Improved the searching UX in the Emoji Selector app: now the search field is always visible, and doing a search will always search through the full set of all emojis if there aren’t any matches on the current page. (Nate Graham, link 1, link 2)

The Display Configuration widget and OSD no longer thinks your primary screen is always connected to a laptop; now it uses more generic terminology. (Nate Graham, link)

Notable Bug Fixes

Plasma 6.3.6

Using a non-default font or font size no longer causes the selection rectangles for files or folders on the desktop to be displayed at the wrong size and cause subtle layout and positioning glitches. (Nate Graham, link)

Plasma 6.4.0

Fixed several more cases where putting a widget on a huge panel could cause Plasma to freeze. (Christoph Wolk, link 1, link 2, link 3, link 4, link 5, link 6, and link 7)

Fixed a case where Discover could crash while offering you the replacement for an end-of-support Flatpak app. (Akseli Lahtinen, link)

Fixed a bug that caused the Open/Save dialogs invoked from Flatpak-based browsers (or when forcing the use of portal-based dialogs) to sometimes not allow the preview pane to be opened. (David Redondo, link)

Fixed a weird bug that could cause a standalone Folder View widget on the desktop to become visually glitchy when you drag files or folders to it from Dolphin. (Akseli Lahtinen, link)

Fixed a bug that broke printing at the correct sizes in Flatpak-packaged GTK apps. (David Redondo, link)

Installing or uninstalling an app no longer unexpectedly clears the search field and results view in Kicker or Kickoff if they happened to be visible at the moment the transaction completed. (Christoph Wolk, link)

Frameworks 6.15

Fixed a cause of crashes in apps and Plasma system services using System Monitor charts. (Arjen Hiemstra, link)

Frameworks 6.16

Fixed an intermittent source of crashes in System Monitor when switching process views. (Arjen Hiemstra, link)

Fixed a weird issue that could cause Open/ Save dialogs to close when hovering over certain files. (David Redondo, link)

KDE Gear 25.04.3

Fixed an issue that could cause the thumbnailer to crash on X11 when using certain widget styles. (Nicolas Fella, link)

Other bug information of note:

• 3 very high priority Plasma bugs (same as last week). Current list of bugs
• 23 15-minute Plasma bugs (up from 21 last week). Current list of bugs

Notable in Performance & Technical

Plasma 6.4.0

Improved startup speed for System Monitor by loading the column configuration dialog’s content on-demand, rather than at launch. (David Edmundson, link)

Made sure that the Environment Canada data source for weather reports keeps working, since the provider is changing their data format soon and we needed to adapt. (Ismael Asensio, link)

Frameworks 6.15

Improved startup speed for System Monitor by loading the tree view indicator arrows on demand, rather than at launch. (David Edmundson, link)

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-24.

Google’s nightmare: How a search spinoff could remake the web

Tags: tech, web, google, search, monopoly, economics

There’s clearly something tempting about a web index somehow separated from Google. It always felt like a natural monopoly and so a type of public service. Now that push arrives a tad late so the impacts are unclear. Overall I still think this would be a net positive if there are more web search companies built onto such an index.

https://arstechnica.com/google/2025/06/googles-nightmare-how-a-search-spin-off-could-remake-the-web/

How much EU is in DNS4EU?

Tags: tech, dns, privacy

Early days for that service. Let’s hope it improves infrastructure wise.

https://techlog.jenslink.net/posts/dns4eu/

Trusting your own judgement on ‘AI’ is a huge risk

Tags: tech, ai, machine-learning, gpt, copilot, programming, cognition, scam, criticism

An excellent piece which explains well why the current “debate” is rotten to the core. There’s no good way to engage with those tools without reinforcing some biases. Once the hype cycle is over we have a chance at proper research on the impacts… unfortunately it’s not happening now when it’s badly needed.

https://www.baldurbjarnason.com/2025/trusting-your-own-judgement-on-ai/

Avoiding generative models is the rational and responsible thing to do – follow-up to “Trusting your own judgement on ‘AI…’”

Tags: tech, ai, machine-learning, gpt, copilot, programming, cognition, scam, criticism

A nice followup which acts as a TL;DR for the previous piece which was fairly long indeed.

https://www.baldurbjarnason.com/2025/followup-on-trusting-your-own-judgement/

Poison everywhere: No output from your MCP server is safe

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

OK, this is definitely concerning for the use of tools with so called coding agents. The trust model is really not appropriate at this stage and that opens the door to a wide range of attacks.

https://www.cyberark.com/resources/threat-research-blog/poison-everywhere-no-output-from-your-mcp-server-is-safe

How we decreased GitLab repo backup times from 48 hours to 41 minutes

Tags: tech, gitlab, git, complexity, profiling, optimization

Nice simple fix in Git but with a large impact on backups. A good proof that profiling and keeping an eye on algorithmic complexity can go a long way in improving software.

https://about.gitlab.com/blog/2025/06/05/how-we-decreased-gitlab-repo-backup-times-from-48-hours-to-41-minutes/

Sandboxing Adoption in Open Source Ecosystems

Tags: tech, unix, system, sandbox

Interesting paper about the use of sandboxing in several ecosystems. It’s not used much directly but there are clear differences in term of complexity to set them up.

https://arxiv.org/abs/2405.06447

Curate your shell history

Tags: tech, tools, shell

Interesting thinking and trick. We clearly pile up too much noise in our shell history.

https://esham.io/2025/05/shell-history

magic namerefs

Tags: tech, shell, scripting

Didn’t know bash got this feature now. I’m torn between “it looks so cool” and “we’ll never see the end of debugging issues which use this”.

https://gist.github.com/izabera/e4717562e20eb6cfb6e05f8019883efb

Too Many Open Files

Tags: tech, unix, system, filesystem

Need to play with file descriptors on Unix systems? This is a fun and gentle introduction.

https://mattrighetti.com/2025/06/04/too-many-files-open

Is Rust faster than C?

Tags: tech, rust, c, performance

Or why this kind of question never have an absolute answer.

https://steveklabnik.com/writing/is-rust-faster-than-c/

Patterns for Modeling Overlapping Variant Data in Rust

Tags: tech, programming, rust, type-systems, data

Interesting selection of options to model data structure with some variability in Rust.

https://mcmah309.github.io/posts/patterns-for-modeling-overlapping-variant-data-in-rust/

GPU Memory Consistency: Specifications, Testing, and Opportunities for Performance Tooling

Tags: tech, gpu, memory, performance

The memory models for GPU programming are complex. This isn’t easy to squeeze more performance without introducing subtle bugs.

https://www.sigarch.org/gpu-memory-consistency-specifications-testing-and-opportunities-for-performance-tooling/

The Concurrency Trap: How An Atomic Counter Stalled A Pipeline

Tags: tech, multithreading, caching, cpu, rust

A good example of how you can get bitten by cache coherency algorithms in the CPU.

https://www.conviva.com/platform/the-concurrency-trap-how-an-atomic-counter-stalled-a-pipeline/

Malleable software: Restoring user agency in a world of locked-down apps

Tags: tech, programming, ux, design

A long essay but contains a lot of interesting insights. There’s definitely more to do design wise to produce software people can really bend to their needs.

https://www.inkandswitch.com/essay/malleable-software/

Write Unit Tests, Don’t Waste Our Money!

Tags: tech, tests, business

This is one way to frame it I guess. Code is indeed an investment, tests are here to protect it.

https://www.yegor256.com/2025/06/08/pull-request-without-test.html

Test Contra-variance

Tags: tech, tdd, tests, design

A good reminder of the reasons why the organization of your tests shouldn’t necessarily match the organization of the application code. You don’t want fragile tests, do you?

https://blog.cleancoder.com/uncle-bob/2017/10/03/TestContravariance.html

Pinning Tests

Tags: tech, legacy, tests

I’m using the term regularly when dealing with legacy code. Finally remembered when I saw it first.

https://wiki.c2.com/?PinningTests

Analyzing Metastable Failures in Distributed Systems

Tags: tech, failure, safety, distributed

Interesting paper about metastable failures and novel approaches to try to analyse them. It’s early days but we would need to get toward better prevention.

https://muratbuffalo.blogspot.com/2025/06/analyzing-metastable-failures-in.html?m=1

How I structure my apps (in Rust and other languages)

Tags: tech, architecture, design, rust

Of course, don’t take everything at face value here. Still this gives good ideas on how to combine some design and architectural ideas together. The whole thing is not really Rust specific.

https://dpc.pw/posts/how-i-structure-my-apps-in-rust-and-other-languages

ADRs

Tags: tech, architecture

Nice little post helping advocate for the use of Architectural Decision Records.

https://www.beflagrant.com/blog/adrs

Beck Design Rules

Tags: tech, xp, design

Nice and short explanation on the design rules Kent Beck had in mind when devising XP. It still generally applies in my opinion.

https://martinfowler.com/bliki/BeckDesignRules.html

Tech debt can’t be solved as a roadmap item. It needs to be part of your daily routine

Tags: tech, quality, technical-debt, project-management

Definitely this, too often I see projects treating the technical debt as one-off large tasks. Really it’s something you should deal with bite sized and over time.

https://software.rajivprab.com/2025/05/10/tech-debt-cant-be-solved-as-a-roadmap-item/

The Real Cost of Change

Tags: tech, agile, technical-debt, planning, risk

It will fluctuate with time so it needs to be kept in check. Indeed, some things are commodities so can be decided upfront, but the rest of the functional envelope will change over time. Also make sure you drive the project by risks to have early feedback where it matters most.

https://lizkeogh.com/2012/01/30/the-real-cost-of-change/

Blameless PostMortems and a Just Culture

Tags: tech, failure, culture, management

Mistakes happen, but shrugging them off with blaming people or pushing them to be more careful is counter-productive. Instead, you want to find the organizational issues which made them possible in the first place.

https://www.etsy.com/codeascraft/blameless-postmortems/

Building An Impact Brewery: A Toolkit for R&D Leaders to Drive Impact

Tags: tech, research, leadership, tech-lead, organization

Not fond of the metaphor used here which leads to quite some noise. Still, this article contains interesting ideas to try to push R&D initiatives forward. Definitely needed to improve any kind of organisation.

https://medium.com/panorays-r-d-blog/building-an-impact-brewery-a-toolkit-for-r-d-leaders-to-drive-impact-f2336d51109e

Elephant Carpaccio facilitation guide

Tags: tech, agile, tests, tdd, teaching

This is one of those workshops I like to do with teams from time to time. Didn’t do it for a while. I wish this resource was on a safer space than google docs.

https://docs.google.com/document/d/1TCuuu-8Mm14oxsOnlk8DqfZAA1cvtYu9WGv67Yj_sSk/pub

5 People Who Destroy Your Culture

Tags: management

This kind of articles are always a bit caricatural. Still there is some good advice in there. Keep an eye open for the harmful behaviors.

https://blog.eladgil.com/p/5-people-who-destroy-your-culture

Bye for now!

Learn how to use Cucumber-CPP and Gherkin to implement better black box tests for a C++ library. We developed a case-study based on Qt OPC UA.

Continue reading Improved Black Box Testing with Cucumber-CPP at basysKom GmbH.

Friday, 13 June 2025

KDE today announces the release of KDE Frameworks 6.15.0.

This release is part of a series of planned monthly releases making improvements available to developers in a quick and predictable manner.

New in this version

Intro

One of the largest hurdles in any job or activity is getting your resources set up. Luckily for you, Krita has one of the most detailed and straightforward documentation for setup. In this blog I will go over my experience setting up Krita and provide quick links to answer all the questions you may have during set up.

Setup

One Stop Shop for Links
Download and Install Ubuntu
Create KDE account
Fork Krita Repository
Follow build instructions
If you use QTCreator to Build and Run Krita follow this video Krita Chat - Create account, join chat room, introduce yourself and ask questions

The goal is to get Krita running on your machine. For my setup and for simplicity of instructions, I use Oracle's Virtualbox to run a virtual machine(VM) with Ubuntu on my windows machine. You can use any VM host for set up. The Follow build instructions should be straightforward to follow. The great thing about these instructions is that you don't need to know a lot of detail about docker or C++ yet, but you will need to understand some basic linux and git commands.

In the above links, follow the instruction in the hyperlink title.

My Experience

When I set up Krita for the first time, I felt a sense of accomplishment. Not only was I able to set up Krita, but I was able to deepen my understanding of git, learn about docker, VMs and QT.

I think the biggest take away from setting up Krita is to never give up, ask questions in chat, ask yourself "What do I not understand?" before moving to the next instruction.

Conclusion

Setting up Krita is as simple as you make it out to be. The hardest part is finding the resources to be successful. I hope this blog post can simplify set up for newcomers and experienced users.

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

To briefly recap, Natalie Clarius and I applied for an NLnet grant to improve gesture support in Plasma, and they accepted our project proposal. We thought it would be a good idea to meet in person and workshop this topic from morning to evening for three days in a row. Props to Natalie taking the trip from far away in Germany to my parents' place, where we were kindly hosted and deliciously fed.

Our project plan starts with me adding stroke gesture support to KWin in the first place, while Natalie works on making multi-touch gestures customizable. Divvying up the work along these lines allows us to make progress independently without being blocked on each other's work too often. But of course there is quite a bit of overlap, which is why we applied to NLnet together as a single project.

The common thread is that both kinds of gestures can result in similar actions being triggered, for example:

• Showing Plasma's Window Overview
• Starting an app / running a custom command
• Invoking an action inside a running app

So if we want to avoid duplicating lots of code, we'll want a common way to assign actions to a gesture. We need to know what to store in a config file, how Plasma code will make use of it, and how System Settings can provide a user interface that makes sense to most people. These are the topics we focused on. Time always runs out faster than you'd like, ya gotta make it count.

Three days in a nutshell

Getting to results is an iterative process. You start with some ideas for a good user experience (UX) and make your way to the required config data, or you start with config data and make your way to actual code, or you hit a wall and start from the other end going from code to UX until you hit another wall again. Rinse and repeat until you like it well enough to ship it.

On day 1, we:

• Explored some code together, primarily in:
  • KWin, which recognizes gestures;
  • KGlobalAccelD, which manages global shortcut configurations;
  • the KGlobalAccel framework, which asks KGlobalAccelD to to register a global shortcut,
  • and the Shortcuts page in System Settings, a.k.a. kcm_keys.
• Figured out why Natalie's KWin session wouldn't produce systemd logs.
  • (Answer: a leftover config entry.)
• Collected a comprehensive list of gestures (and gesture variants) to support.

On day 2, we:

• Collected a broad list of actions (and action types) to invoke when a gesture is triggered.
• Sketched out UI concepts for configuring gestures.
• Weren't quite satisfied, came up with a different design which we like better.
• Discussed how we can automatically use one-to-one gesture tracking when an assigned action supports it.
• Drafted a config file format to associate (gesture) triggers with actions.

On day 3, we:

• Drafted a competing config file format which adds the same data to the existing kglobalshortcutsrc file instead.
• Reviewed existing gesture assignments and proposals.
• Created a table with proposed default gesture assignments (to be used once gestures are configurable).
• Collected remaining questions that we didn't get to.

What I just wrote is a lie, of course. I needed to break up the long bullet point list into smaller sections. In reality we jumped back and forth across all of these topics in order to reach some sort of conclusion at the end. Fortunately, we make for a pretty good team and managed to answer a good amount of questions together. We even managed to make time for ice cream and owl spottings along the way.

Since you asked for it, here's a picture of Natalie and I drawing multi-touch gestures in the air.

Next up in gestures

So there are some good ideas, we need to make them real. Since the sprint, I've been trying my hand on more detailed mockups for our rough design sketches. This always raises a few more issues, which we want to tackle before asking for opinions from KWin maintainers and Plasma's design community. There isn't much to share with the community yet, but we'll involve other contributors before too long.

Likewise, my first KWin MR for stroke gesture infrastructure is not quite there yet, but it's getting closer. The first milestone will be to make it possible for someone to provide stroke gesture actions. The second milestone will be for Plasma/KWin to provide stroke gesture actions by itself and offer a nice user interface for it.

Baby steps. Keep chiseling away at it and trust that you'll create something decent eventually. This is not even among the largest efforts in KDE, and yet there are numerous pieces to fit and tasks to tackle. Sometimes I'm frankly in awe of communities like KDE that manage to maintain a massive codebase together, with very little overhead, through sheer dedication and skill. Those donations don't go to waste.

At this point I would also like to apologize to anyone who was looking for reviews or other support from me elsewhere in Plasma (notably, PowerDevil) which I haven't helped with. I get stressed when having to divide my time and focus between different tasks, so I tend to avoid it, in the knowledge that someone or something will be left wanting. I greatly admire people who wear lots of different hats simultaneously, and it would surely be so nice to have the aptitude for that, but it kills me so I have to pick one battle at a time.

Right now, that's gestures. Soon, a little bit of travel. Then gestures again. Once that's done, we'll see what needs work most urgently or importantly.

Take care & till next time!

Display Widget Windows in Qt Quick Applications

An animation shows a small window with QML's and Widget's ComboBoxes opening for comparison purposes

// Locate libraries
find_package(Qt6 6.5 REQUIRED COMPONENTS
    Quick
    Widgets)

// Link build target to libraries
target_link_libraries(${TARGET_NAME} PRIVATE
    Qt6::Quick
    Qt6::Widgets)

// Replace ${TARGET_NAME} with the name of your target executable

QApplication app(argc, argv);

// widgetFormHandler.h
#pragma once
class WidgetFormHandler : public QObject
{
    Q_OBJECT
    QML_ELEMENT

public:
    explicit WidgetFormHandler(QObject *parent = nullptr);
};

// widgetFormHandler.cpp

WidgetFormHandler::WidgetFormHandler(QObject *parent)
    : QObject(parent)
{
}

// widgetFormHandler.h
#pragma once
class WidgetsForm;
class WidgetFormHandler : public QObject
{
    Q_OBJECT
    QML_ELEMENT

public:
    explicit WidgetFormHandler(QObject *parent = nullptr);
~WidgetFormHandler();

private:
    std::unique_ptr<WidgetsForm> m_window;
}

// widgetFormHandler.cpp
#include "widgetFormHandler.h"

WidgetFormHandler::WidgetFormHandler(QObject *parent)
    : QObject(parent)
    , m_window(std::make_unique<WidgetsForm>())
{
    // ...
}

WidgetFormHandler::~WidgetFormHandler() = default;

// widgetFormHandler.h
#pragma once
class WidgetsForm;

class WidgetFormHandler : public QObject
{
    Q_OBJECT
    QML_ELEMENT
    Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged)

public:
    explicit WidgetFormHandler(QObject *parent = nullptr);    
~WidgetFormHandler();
    const bool isVisible();    
    void setVisible(bool);

signals:
    void visibleChanged();

private:
    std::unique_ptr<WidgetsForm> m_window;
};

// widgetFormHandler.cpp
#include "widgetFormHandler.h"

#include "widgetForm.h"

WidgetFormHandler::WidgetFormHandler(QObject *parent)
    : QObject(parent)
    , m_window(std::make_unique<WidgetsForm>())
{
    // Hide window by default
    m_window->setVisible(false);
}
WidgetFormHandler::~WidgetFormHandler() = default;
const bool WidgetFormHandler::isVisible()
{
    return m_window->isVisible();
}
void WidgetFormHandler::setVisible(bool visible)
{
    m_window->setVisible(visible);
    emit visibleChanged();
}

Qt Designer shows UI file with a button named pushButton, in camel case.

// widgetsForm.h
#pragma once
#include <QWidget>

namespace Ui
{
    class WidgetsForm;
}

class WidgetsForm : public QWidget
{
    Q_OBJECT
public:
    explicit WidgetsForm(QWidget *parent = nullptr);
    ~WidgetsForm();
signals:
    void buttonClicked();
    // Signal to expose button click from Widgets window
private:
    std::unique_ptr<Ui::WidgetsForm> ui;
};

// widgetsForm.cpp
#include "widgetsform.h"
#include "ui_widgetsform.h"

WidgetsForm::WidgetsForm(QWidget *parent)
    : QWidget(parent)
    , ui(std::make_unique<Ui::WidgetsForm>())
{
    ui->setupUi(this);
    // Expose click
    connect(ui->pushButton, &QPushButton::clicked, this, &WidgetsForm::buttonClicked);
}

WidgetsForm::~WidgetsForm() = default;

// widgetFormHandler.h
[..]
signals:
    void visibleChanged();
    void qmlSignalEmitter();  // Signal to relay button press to QML
[..]

// widgetFormHandler.cpp
[..]
WidgetFormHandler::WidgetFormHandler(QObject *parent)
    : QObject(parent)
    , m_window(std::make_unique<WidgetsForm>())
{
    QObject::connect(m_window, &WidgetsForm::buttonClicked, this,
    &WidgetFormHandler::qmlSignalEmitter);
}
[..]

import NameOfAppQmlModule  // Should match qt_add_qml_module's URI on CMake

WidgetFormHandler {
    id: fontWidgetsForm

    visible: true  // Make the Widgets window visible from QML

    onQmlSignalEmitter: () => {
        console.log("Button pressed in widgets")  // Log QPushButton's click event from QML
    }
}

The post Display Widget Windows in Qt Quick Applications appeared first on KDAB.

Qt AI Assistant v0.9.2 introduces the first agentic AI functionality and supports two additional Large Language Models.

Release notes: https://kde.org/announcements/gear/25.04.2/

Now available in the snap store!

Along with that, I have fixed some outstanding bugs:

Ark: now can open/save files in removable media

Kasts: Once again has sound

WIP: Updating Qt6 to 6.9 and frameworks to 6.14

Enjoy everyone!

Unlike our software, life is not free. Please consider a donation, thanks!

• GoFundMe Donate
• Patreon Donate
• GitHub Donate
• DonorBox Donate

Kdenlive 25.04.2 is now available, containing several fixes and small workflow improvements. Some highlights include:

• Remember title editor window width
• Fix audio thumbnails have an offset in long files
• Fix OTIO import path on Windows
• Better feedback when auto mask fails

Some last minute fixes were also included in the Windows/Mac/AppImage versions:

• Fix OTIO export tracks order and ensure .otio file extension is correctly added

See the full changelog below.