Language Selection

English French German Italian Portuguese Spanish

Kde Planet

Syndicate content Planet KDE
Planet KDE | English
Updated: 8 hours 49 min ago

Communications Channels

Tuesday 25th of May 2021 10:00:00 PM

The idea of free, open, community-building chat for Open Source projects was, and is, a good one. I’m grateful to Freenode sponsors and Freenode volunteers over a great many years.

My Freenode Background

In 2018 Dave and I went to the Freenode#live conference, which was a cool celebration of all kinds of Open Source projects. I remember chatting with the Minetest folks and also the Private Internet Access table. The PIA configurations were quite convenient at various other conferences, too.

My Freenode account is younger than kid[0], but not by much:

[NickServ] Registered : Aug 29 22:00:09 2003 (17y 39w 1d ago)

I probably ended up on Freenode because of Lauri Watts, then KDE translations coordinator and FreeBSD-pusher. I don’t know whether I posted “contractions are now 10 minutes apart, I should sign off” (not my contractions, mind) in Freenode or EFNet, but kid[1] was reported on IRC at a very tender age a bit more than a year later.

In that time I’ve been active in various KDE communities – FreeBSD, then Solaris, then FreeBSD again – and going on 4 years of #calamares. Or is it 5? Time flies. There’s a few Freenode volunteers I’ve met in real life and would count among my friends.

And now I’m leaving Freenode because .. well, not because I directly have had problems, not because the #calamares channel has been taken over, but because other people and channels have. That’s not right, and I choose to trust people rather than shaky institutions.

Calamares Communications

Calamares, like many Free Software projects, has been using the Freenode network for many years for real-time communication, for idle chit-chat and for community-building. However, it’s time to update and modernize – and leave a platform that is no longer the kind of place the Calamares project wishes to inhabit.

For communications that can wait, like bug reports, issues, feature requests, the best place remains GitHub issues. This is where long-term discussions go, and where we can properly keep track of whether they are fixed or not.

For real time communication, chit-chat, discussing whether something is worth filing an issue for, notifications, and little things (typo’s, website stuff) there are two places, which are monitored with varying intensity by the Calamares team:

IRC is not persistent, so don’t ask-and-leave in the channel because you will never get an answer. It does not require registration, though. Matrix is persistent, but you will need to register somewhere on the Matrix federation. A KDE account is ok (, or a global Matrix account is ok ( or any other home-server will do as well.

Matrix is preferred. It has persistence, rich text, and better notifications.

This is where you can still find some remains, but it’s monitored less-actively:

Calamares Bots and Notifications

There is no bridge yet between Matrix and the channel. Once things settle down and the folks at have some time, I’ll poke them to set it up for Calamares as well.

Continuous Integration (that is, CI builds from git pushes as well as nightly builds) now sends messages to Matrix rather than IRC. I’ll write about setting that up (with GitHub actions) soon-ish.

Shaky Institutions

One thing that Freenode teaches us is that institutions are imporant. Having good governance in place for a project and for a community is really important to keep it healthy in the long run.

The folk have – this time around – established a Swedish non-profit organization. That means that there’s a relatively clear and open and public means for decisions to be made, and that decisions that affect overall operations and responsibilities will happen in a .. let’s call it a more community-oriented fashion.

Good for them!

The KDE community established something back in 1997 for the same purposes: clear and transparent decision-making and ensuring that the community as a whole can retain control. There’s also the manifesto outlining the moral stance of the KDE community. With nearly 25 years of hindsight, I think we can say that that was a good step to have made.

KDE DEVLOG 4: Finishing Up the Active Applet Indicator!

Tuesday 25th of May 2021 12:14:51 PM

KDE DEVLOG 4: Finishing Up the Active Applet Indicator!

Tech report of

Tuesday 25th of May 2021 09:35:35 AM

A few weeks ago, the Krita project announced the Krita Dev Fund. This project scope was the same as the Blender Dev Fund. Provide a stable way to fund the development of Krita via recurring donations.

Krita Fund

Since I was the one who helped with the technical bits on the website and I heard that were are interested FOSS communities that want to deploy something similar, I decided to write a small tech report about how we did it in Krita.

Luckily for us, when we started researching how to create something similar, we rapidly discovered that the Blender Fund website itself is open source and licensed under the same license as Blender: GPL. It made it easy to reuse the code.

The system is written with Django for the backend and uses Braintree as a payment provider. The code was built with Blender need in mind and not as a reusable project that I could use without any change, so a fork was inevitable. To make the maintenance more manageable, I decided to try to stay as near as possible to upstream in our Python code so that it’s easy to rebase the Krita fork when needed.

The code is hosted on invent.

Blender Fund is using its own authentification system (Blender ID) using OAuth2. To connect to Blender Id, a separate Django module for authentification exists (blender-id-oauth-client). This could be replaced by a custom implementation using default Django auth module or one of the many third-party Django ready-to-use authentification modules. In the case of Krita I just used blender-id-oauth-client with a few oauth2 parameters changed.

The most significant modifications I made were mainly around the HTML templates and CSS files. Most of these modifications were about replacing Blender with Krita, and updating the look of the homepage. We couldn’t just use Blender’s branding!

There was also quite a bit of work with the layouts of the page since Krita main CSS theme is using Bootstrap 3 and the Blender Fund website is using Bootstrap 4 and were was many subtle differences between both versions.

Updating only the templates made it possible to customize the website’s look and edit the content of the emails sends by the system to use Krita billing information instead of Blender one.

In terms of Python code changed, there was also a few instances of ‘Blender’ that got replaced by ‘Krita’. But all the other changes than were minors. For example, I added back the progress bar on the landing page since Blender removed it from since it wasn’t needed anymore. Another small change was adding to the homepage the amount of the current donation from the old system.

A few weeks before launching, I got a pleasant surprise as I wanted to rebase my prototype on top of upstream before moving Krita Fund to production. I discovered that the Blender team moved their internal library that handles all the payments to a separate library. It instantly made the amount of critical code in Krita’s fork smaller and my life much simpler.

That’s it! So if you want to support Krita and help them build the best painting application in the world and available for everyone, make sure to check out the Krita Fund.

And if you are enjoying my work all around KDE (Plasma Mobile, NeoChat, websites, …), feel free to check out my Liberapay account.

Asynchronous database access with QtSql

Monday 24th of May 2021 10:05:00 PM

In the past I’ve always been struggeling with asynchronous and yet simple database access with QtSql. I now came up with a quite nice solution and I hope I can help you with it.

Multithreading in Qt

When working with Qt most of the time you do not need to care about threading. Most things already work asynchronously, they don’t block and there’s no reason to mess with additional threads. This is the case for network requests via the QNetworkAccessManager where signals are used (as pretty much everywhere). If you’ve got other tasks like hash calculation of large files or image scaling, then there’s QtConcurrent::run() for you which will execute a function on the application’s thread pool.

QtConcurrent uses QFutures to report the results. In Qt 5 QFutures are not very handy (you need a QFutureWatcher to get the results asynchronously and you manually need to create and delete it). With Qt 6 this has changed and now there’s a pretty nice QFuture::then() function where you can directly pass a lambda handling the result:

QtConcurrent::run([]() { // do heavy calculations ... return value; }).then([](Result value) { qDebug() << "Calculation done:" << value; });

This simple way to chain QFutures creates a nice flow in your code. Instead of having (maybe multiple) slots that all need to be connected, here you can just write your code directly behind the QtConcurrent::run() call.

Databases and threading

That’s all pretty nice, but it doesn’t work with databases. You can’t just open a QSqlDatabase and execute queries on it via QtConcurrent. Most (if not all) SQL database drivers are going to complain that you’re using the database from the wrong thread. So, what you need to do is creating the database on the same thread as where the queries are executed. This means we can’t use QtConcurrent (at least not without some adjustments) since we don’t know on which thread our job is going to be executed.

Solution #1: Thread-Worker model with signals

My first idea on how to solve this and how I also did it in the past was creating a normal QThread and a database worker class running on the thread. The database is opened on this new thread and all queries are also executed on it. Now with this approach we somehow need to trigger queries and receive their results. Qt offers signals and slots with queued connections for this. My approach was to create two signals and a slot on the database worker. Let’s look at an example here:

class DatabaseWorker : public QObject { Q_OBJECT public: DatabaseWorker(QObject *parent = nullptr); signals: void fetchAllUsersRequested(); void allUsersFetched(const QList<User> &users); private slots: void fetchAllUsers(); }; DatabaseWorker::DatabaseWorker(QObject *parent) : QObject(parent) { connect(this, &DatabaseWorker::fetchAllUsersRequested, this, &DatabaseWorker::fetchAllUsers); } DatabaseWorker::fetchAllUsers() { // ... do query .. emit allUsersFetched(users); }

If you want to fetch the users, you’d do the following:

emit database->fetchAllUsersRequested();

As soon as the database has executed the query, it will emit the allUsersFetched() signal, which you can handle.

However this approach has some problems:

  1. You need to care about threading manually.
  2. You need to create signals and connect them for every new function.
  3. The caller (of fetchAllUsersRequested()) doesn’t know which request belonged to the results received from the signal (allUsersFetched()). This is not a problem in this case, but as soon as you’ve got multiple requests at the same time, this will get important.

The second point can be workarounded, but the code won’t be nice.

Solution #2: QtConcurrent with a one thread QThreadPool

Using QtConcurrent with QFutures would solve all three problems here, so we should have a deeper look at QtConcurrent. In the documentation we can see that QtConcurrent also provides the option to use a specific QThreadPool for the execution.

This helps us since with a custom thread pool we can set the maximum thread count to 1 and so this way can guarantee that everything is executed on the same thread. QThreadPool automatically deletes threads when they’re unused. We also need to prevent this, because the used thread of course must not change:

QThreadPool pool; // limit to one thread pool.setMaxThreadCount(1); // prevent automatic deletion and recreation pool.setExpiryTimeout(-1);

This basically already solved our problem. We now just need to do everything via QtConcurrent and our QThreadPool and we don’t need to care about threads at all anymore.

Our Database now could look like this:

class Database : public QObject { Q_OBJECT public: QFuture<void> open(); private: QThreadPool m_pool; } QFuture<void> Database::open() { return QtConcurrent::run(m_pool, []() { auto database = QSqlDatabase::addDatabase("QSQLITE", "main-connection"); database.setDatabaseName("/home/me/data.sqlite");; // of course you should do some more checks here to see // whether everything went well :) }); }

Other queries can be done like this now:

QFuture<QList<User>> Database::fetchUsers() { return QtConcurrent::run(m_pool, [this]() { QSqlQuery query(QSqlDatabase::database("main-connection")); query.exec("SELECT * FROM users"); QList<User> users; while ( { // ... } return users; }); }

And with Qt 6 you can pretty easily handle the results now:

database->fetchUsers().then([](const QList<User> &users) { // do something });

Unfortunately with Qt 5 it’s not so nice:

auto *watcher = new QFutureWatcher<QList<User>>(); connect(watcher, &QFutureWatcherBase::finished, [watcher]() { QList<User> users = watcher->result(); // do something with the result watcher->deleteLater(); }); watcher->setFuture(database->fetchUsers());

This is not very nice and things can go wrong, you could forget to delete the QFutureWatcher for example. Thus, we use a template function to simplify this:

template<typename T, typename Handler> void await(const QFuture<T> &future, Handler handler) { auto *watcher = new QFutureWatcher<T>(); QObject::connect(watcher, &QFutureWatcherBase::finished, [watcher, handler { std::move(handler) }]() { handler(watcher->result()); watcher->deleteLater(); }); watcher->setFuture(future); } await(database->fetchUsers(), [](QList<User> users) { // do something });

And that already looks much better! :)

We now got a solution with the following features:

  1. A database class running in the main thread. No manual thread management.
  2. No signals and slots for each new function. Just QFuture::then / await.
  3. Request and result handling can be easily ‘linked’ by using lambda captures.

This is a very nice solution for most of the use cases in our applications.

Do we want anything more? – Okay, maybe parallel queries with multiple threads, for building servers or a high-performing application, but that’s probably irrelevant in most of the cases. However, maybe we’ll see this in one of the next blog posts. :)

Call for Papers – Qt Developer Conference

Monday 24th of May 2021 09:00:37 AM

The Call for Papers for KDAB’s upcoming event, Qt DevCon, is now open. We are planning to make this our first in-person event after the shut-down. The event will take place September 28-30, featuring 1 training day and 2 days of technical talks from developers, for developers.

Call for Papers. What are we looking for?

Qt DevCon is primarily a technical event and we want our content to be as relevant and interesting as possible to our audience. The target audience is developers building software with Qt.

Topics for Talks

Proposals related to any aspect of development with Qt are welcome, as long as they:

  • bring practical knowledge for the attendees
  • discuss the unique technical challenges of creating Qt applications
  • are about Qt and its ecosystem

This conference aims to help the attendees become even better Qt programmers. Talks about general aspects of programming may be off-topic for this conference (as interesting as they may be). For instance, a talk like “C# for Qt developers” is off-topic; a talk like “Here’s what Qt should steal from WForms” could be accepted.

Here are some ideas:

  • Widgets vs Qt Quick
  • Architect your Qt application for multithreading
  • How to write more robust QML code
  • Using Python with Qt
  • Issues with running Qt Webassembly
  • QGraphicsView is still my best tool for…
  • In-depth technical discussion on Qt features
  • Cross-platform development using Qt
  • Creating mobile applications with Qt
  • Automated testing strategies
  • Practical experiences using Qt on real-world applications

These are just suggestions – we welcome any submission!


The likelihood of acceptance of your proposal depends on the quality of your abstract.

While we don’t need to see your entire presentation in advance, your abstract should still be detailed enough to enable the committee members to assess your talk on its merits. Therefore, your abstract should help the committee members understand what your talk will be about, what specific topics will be discussed, which limitations the proposed approach has (if applicable; e.g., is it platform-specific?), and so on. If the talk was already presented in the past, please mention so, and possibly discuss what is going to be different since the last time it was presented.

Especially important are the takeaways from your talk. What will the audience have learned? How will it improve the attendees’ everyday life as software developers using Qt?

As the goal of the conference is to improve the technical skills of the participants, your talk should help us achieve that. A talk should not be a product ad.


Your slot is 60 min, ~45 min talk + 15 min Q&A. Please rehearse your speech to be sure it fits the time frame. Each presentation will be live-streamed, recorded, and redistributed on multiple video hosting platforms. Successful applicants will be contacted for general info and asked to send a photograph and bio.

All talks will be presented live, on-site in Berlin, as we expect travel and in-person attendance to be safe under recommended safety measures by that time.


We will assist you with the technical setup; you only need your laptop.

You can enter proposals until 2021-06-13 00:00 (Europe/Stockholm)


More information on the event can be found here and here.

Talks can be submitted here.


About KDAB

If you like this article and want to read similar material, consider subscribing via our RSS feed.

Subscribe to KDAB TV for similar informative short video content.

KDAB provides market leading software consulting and development services and training in Qt, C++ and 3D/OpenGL. Contact us.

The post Call for Papers – Qt Developer Conference appeared first on KDAB.

KDE Goals Update – May 2021

Sunday 23rd of May 2021 10:00:00 AM

Hello! This is the first entry in a hopefully reoccurring series of blog posts about the KDE Goals.

The purpose of this series is to provide a frequent update about the Goals, to highlight what cool things are happening.

Of course, our Goal Champions can still create additional content about their goals in any form they want: short blog posts, videos, in-depth articles, etc. This blog will aggregate that content and also give the champions a way to share quick updates without spending too much time blogging.

And with that, let’s take a look at the updates!


Plasma 5.22 is coming, and with that a lot of improvements and fixes to Wayland support. Readers of Nate’s blog have surely seen many of those highlighted.

Personally, I’m very excited about variable refresh rate (FreeSync) support being added. I asked Xaver, author of the merge request (and the GPU hot-plug one!) to write about the new features. Hopefully, we’ll get some juicy details soon!

Meanwhile, you can start testing Plasma 5.22 right now! David has a post about that. Be sure to report any bugs found and see if the list of Wayland showstoppers needs updating.


Niccolo sent over a full list of recent consistency updates!

1. We are adding a new re-usable component called KHamburgerMenu that will make hamburger menus consistent throughout Plasma. It’s cool because it adapts to your toolbar: if you take an action off it will appear in the hamburger menu, and if you add an action it will disappear from it.

2. Ark now has a welcome screen!

3. Gwenview sidebar has been made more consistent with our current humane interface guidelines

4. Discover now uses standard cards to display reviews instead of custom component

5. Viewswitcher in libhandy now are more consistent to Plasma style

6. Calendar has been completely redesigned and now uses Plasma style elements more consistently: the top area, the vertical line like in kickoff, etc

7. Work in progress: we are bringing the highlight from Plasma everywhere on applications as well! A great step forward for our consistency goal of using the same highlight everywhere.

Oof, who knew there’s so much work to do just to stay consistent!

KDE is All About the Apps

In a different kind of news, Jonathan has stepped down as the Goal Champion. Thank you very much for all the work done to make KDE a better home for apps, Jonathan.

The Goal’s new champion is Aleix. He wants to start by asking the community to discuss a range of topics regarding the Goal. Here’s a list from Aleix:

  • platforms
    • linux
      • flatpak
      • appimage
      • snap
      • distros
    • bsd
    • android
    • windows
    • os x
      ??? to discuss: ways to reach the platform, our unique selling points there to focus
  • promo
    • website presence
  • business
    • making money for devs
    • fundraising for KDE
  • suites
    • PIM
    • Edu
    • Calligra
  • developer story
  • Plasma
    • Plasma & apps
      • which apps should be just considered plasma-specific/oriented? what can we leverage from this specificity?
      • what apps are we lacking?
    • Plasma mobile
    • Plasma desktop (?)
    • other form factors: TV, tablet, etc
  • Tech used
    • Kirigami and KDE Apps
    • KXMLGUI and KDE Apps

I’m sure we’ll need a couple of meetings to cover all of that! If you’re interested in participating in the discussion of ANY of those topics, please reach out specify which ones. This will help narrow down the focus of the first meeting.


While I’m not actually working on any of the Goals, I do help how I can with the KDE Goals initiative as a whole. This blog is part of that. Additionally, I plan to write a description of the Goal Champion role, since currently we don’t have anything “official”. Let me know if you have ideas about what such a description should include.

A Week In Tok

Saturday 22nd of May 2021 03:22:01 PM
Slim Mode

Tok now has a “slim mode”, for those who prefer a denser layout that follows IRC clients closer than it does mainstream messaging clients.

New Message Colours

The colours of messages have been adjusted to be more contrasting.

Keyboard Shortcuts

Tok now has alt-up and alt-down shortcuts for quickly switching between adjacent chats in the chat list.


Tok has seen some optimisation; switching between chats should now be much faster.


Titlebar dragging in the MauiKit style now works as expected.

Obtaining Tok

Tok can be built from source from

The support/development room is at


Interested in contributing? Come on by the dev chat and say hello.

Tags: #libre

ISO Codes API for KDE Frameworks

Saturday 22nd of May 2021 08:00:00 AM

As mentioned in a previous post I’m looking into collecting, extending and unifying various APIs we have for dealing with countries, country subdivisions, timezones, languages, etc in a single library in KDE Frameworks. While a lot of this is still work in progress, at least some features are ready for a closer look.

What is this about?

A number of our applications rely on knowledge about geospatial features (ie. properties of a location). In some cases that is fairly obvious, like KDE Itinerary needing to know the timezone of your travel destination to accurately show times. More often this is more indirect though, e.g. the initial device setup suggesting the most likely language and timezone, to avoid the user having to search through lists with possibly hundreds of entries. And of course we want to have all this properly translated.

Qt provides some of this via QLocale and in the 4 era there were additional features in KLocale and its associated classes in kdelibs. On top of that various libraries and applications carrying own code for this.

There’s a KF6 Phabricator task for the goals and requirements, and there’s now a Gitlab work branch with the ongoing work, aiming at integration in the KI18n framework. A lot of this isn’t even new code but merely another iteration of things that already exist in other Frameworks, Plasma or applications.

I’ll try to present the features in there in a few blog posts, as they become ready for testing.


The first set of features is about translating various codes used to identify countries (ISO 3166-1) or country subdivisions (ISO 3166-2), and about obtaining the translated name for a country or country subdivision. Bits of this are currently found in KContacts (ISO 3166-1 alpha 2 -> name), KItinerary (ISO 3166-1 alpha3 -> ISO 3166-1 alpha2) and KHolidays (translated country and subdivision names). There’s also half a dozen sets of translations for country names in all our translation catalogs, coming from various applications.

In the new API this is provided by the KCountry and KCountrySubdivision classes. Those types are very lightweight (2 and 4 bytes respectively, and allocation free) and introspectable by Qt’s property system for use in QML. Ultimately those types just represent ISO 3166-1/2 codes, all their functionality is implemented as lookups into internal data tables.

Besides the mapping to and from ISO codes and getting translated names, there’s also mapping to and from the QLocale::Country enum, to provide interoperability with QLocale, something that Qt has built in but isn’t exposing in its API unfortunately.

A new feature that none of the existing APIs was providing is access to country and country subdivision hierarchies. That is listing subdivisions of a country (or another subdivision, for countries where this has more than one level), and vice versa. This was originally needed internally for more efficient storage, but it is also useful e.g. for an address editor offering the right subdivisions for a selected country.

Another new method is KCountry::emojiFlag(), which returns the Unicode sequence for the corresponding country flag.

Data Source

Fortunately there is an existing set of data that provides all of what is needed for the above, and that we already depend on in a few places even, iso-codes. Technically this consists of a number of JSON files containing the ISO codes, subdivision hierarchies and their corresponding English text, and Gettext catalogs with the translations of those.

So to get started all we need is reading those JSON files and putting their content in a few maps.


A naive implementation like this however comes at a price. For just the country data it’s costing about 125kB of non-shared heap memory and takes about 100ms to do. That might not seem like a lot, but this multiplies per application needing this, and that doesn’t even cover the country subdivision data yet (which has about 20x more entries).

At the same time, this is code which is used on performance-sensitive paths, such as locale aware sorting in a (larger) model.

This is not a new problem though, KContacts for example solved this by compiling in an optimized representation of the iso-codes data. This is only about 5kB in size and requires no allocations and due to ending up in the read-only section of the library is automatically shared between all applications using this.

This approach was rightfully criticised for its higher maintenance and the risk of the library and the installed iso-codes translation catalogs going out of sync. So I tried a different solution here.

On first use we now create a compact binary lookup table out of the iso-codes JSON files, which then is mmap’ed as shared/read-only data. If the iso-codes data changes, the cache files are rebuilt. Ignoring the first run, this achieves the same performance characteristics as KContacts.

We could also optimize this further for fully bundled applications (AppImage, APK, etc), and allow those to ship pre-generated cache files rather than the JSON source files, as we fully control the updates of the iso-codes data there.


Feedback for this is very welcome, on the implementation but also regarding use-cases and requirements you have in your application. Check the corresponding Phabricator task and the Gitlab branch for this, or find me in the #kde-devel channel on Matrix, the weekly KF6 meetings Saturday 15:00 CEST or the kde-frameworks-devel mailing list.

The next part is probably going to be about querying the timezone for a country or country subdivisions.

This week in KDE: KCommandBar delivers ludicrous-mode productivity

Saturday 22nd of May 2021 04:45:48 AM

This week I have another exciting new UI element to present: KCommandBar! You might have gotten the impression by my fawning over KHamburgerMenu that we care more about casual or novice users today… not so! KCommandBar is an expert-focused UI element implementing a HUD-style popup that aggregates all of the actions in a KDE app’s full menu structure, so that you can quickly activate features at the speed of thought! It’s like a KRunner inside your apps. You can also use it as a search, if you think a feature may exist somewhere but you don’t know where.

Hmm, does kate have a Block Selection mode? How do I activate it?

Oh, like that!k

Notice how it shows you the action’s keyboard shortcut too, so you can learn how to activate it even faster next time!

This UI element has been merged into the code but not yet rolled out for all KDE apps. Once this merge request is merged, all QWidgets-based KDE apps that use our KXMLGui framework (which is to say, most of them) will automatically get this feature for free! Big thanks to Waqar Ahmed for creating it!

Bugfixes & Performance Improvements

Dolphin’s split view closing animation no longer briefly shows the wrong view content in the left view before being closed (Felix Ernst, Dolphin 21.08)

Plasma no longer sometimes crashes when using the Audio Volume widget with full PipeWire support (David Redondo, Plasma 5.22)

In the Plasma Wayland session, connecting or disconnecting an external screen no longer sometimes immediately causes Plasma to crash (David Edmundson, Plasma 5.22)

In the Plasma Wayland session, windows that automatically close themselves no longer get stuck on the screen as half-transparent phantoms if you happened to have been dragging them at the moment when they closed themselves (Vlad Zahorodnii, Plasma 5.22)

We pushed a better fix to prevent the network applet from erroneously showing a huge traffic spike the first time you open it that should hopefully fix it for good this time (David Redondo, Plasma 5.22)

System Monitor widgets now display the correct information when located on a panel (David Redondo, Plasma 5.22)

The new Plasma System Monitor app no longer sometimes visibly flickers when table views of apps or processes are updated (David Edmundson, Plasma 5.22)

In the Plasma Wayland session, sub-menus of hamburger menus from interactive notifications (e.g. for newly-taken screenshots) no longer open in their own separate windows (David Redondo, Plasma 5.22)

In the Plasma Wayland session, showing the titlebar app menu no longer temporarily makes an item named “KDE Daemon” appear in your Task Manager (David Redondo, Plasma 5.22)

In the Plasma Wayland session, Aurorae window decorations are no longer visually corrupted when using high DPI scaling (David Edmundson, Plasma 5.22)

When using the Breeze application style, the cursor no longer gets stuck in the “double headed arrow” shape when first moving over a resizable divider and then into a terminal panel, as in Dolphin (Fabian Vogt, Plasma 5.22)

The Icons-Only Task Manager’s “currently playing audio” indicator no longer overlaps with its numbered badge when the badge is visible (Bharadwaj Raju, Plasma 5.22)

The adaptive panel transparency feature and the Minimize All applet now work properly when using KWin’s “keep thumbnails for minimized windows” setting (Bharadwaj Raju and Abhijeet Viswa, Plasma 5.22)

In the Plasma Wayland session, external screens are now detected properly on multi-GPU systems (Xaver Hugl, Plasma 5.23)

Selecting folders in the folder selector dialog for Flatpak apps and others using XDG portals now works (Bharadwaj Raju, Frameworks 5.83)

When using a recent version of Qt, automatic spellchecking in Kate and KDevelop and other KTextEditor-based apps once again works out of the box without need to be turned off and back on again (Antonio Rojas, Frameworks 5.83)

User Interface Improvements

The tabs at the bottom of Gwenview’s sidebar now become icons-only at very small widths where the text would have previously been elided, and become icons+text at very wide widths (Noah Davis, Gwenview 21.08):

Dolphin’s Trash entry in the Places panel now has a context menu item to open the trash settings window (Saravanan K, Dolphin 21.08):

In Elisa, the inline Play button for playlist items now resumes playback when paused, rather than going back to the beginning of the song (Tranter Madi, Elisa 21.08)

System Tray applets with hamburger menus no longer redundantly show the same configure action inside them that is already visible available as a button on the header itself (me: Nate Graham, Plasma 5.22):

In the new Plasma System Monitor app, you can now terminate the selected process/app by hitting the Delete key, just like you could in KSysGuard (Kai Uwe Broulik, Plasma 5.22)

Clicking on any of the media controls on the lock screen no longer takes the keyboard focus away from the password field (Jan Blackquill, Plasma 5.22)

Using the Task manager’s “cycle through tasks with mouse wheel” no longer un-minimizes minimized tasks (Abhijeet Viswa, Plasma 5.22)

Widgets on the desktop now have a blurred background, making them more legible and better-looking compared to the previous transparent-without-blur background (Marco Martin, Plasma 5.23):

Retro wallpaper shows the effect better!

The Audio Volume applet’s Applications tab now distinguishes between applications that are currently playing or recording audio, and those that are not (Kai Uwe Broulik, Plasma 5.23):

The System Settings Boot Splash page has been moved to the “Appearance” category (me: Nate Graham, Plasma 5.22)

…And everything else

Keep in mind that this blog only covers the tip of the iceberg! Tons of KDE apps whose development I don’t have time to follow aren’t represented here, and I also don’t mention backend refactoring, improved test coverage, and other changes that are generally not user-facing. If you’re hungry for more, check out, where you can find blog posts by other KDE contributors detailing the work they’re doing.

How You Can Help

Have a look at to discover ways to be part of a project that really matters. Each contributor makes a huge difference in KDE; you are not a number or a cog in a machine! You don’t have to already be a programmer, either. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

Finally, consider making a tax-deductible donation to the KDE e.V. foundation.

Web Review, Week 2021-20

Friday 21st of May 2021 11:58:04 AM

Let’s go for my web review for the week 2021-20.

Modern Javascript: Everything you missed over the last 10 years

Tags: tech, javascript

A nice list of somewhat recent features which made it to JavaScript.

Privacy activists are winning fights with tech giants. Why does victory feel hollow? | Evgeny Morozov | The Guardian

Tags: tech, privacy, democracy, innovation

There is so much more to criticize about tech giants than just privacy and fake news issues. It’s important to not mistake the tree for the forest. They’re also killing quite a lot of democratic and institurional innovations.

5 steps to faster web fonts /// Iain Bean

Tags: tech, web, frontend, fonts

A few nice tips for dealing with fonts on the web.

Try This One Weird Trick Russian Hackers Hate – Krebs on Security

Tags: tech, security, funny

OK, now that’s a funny consequence of how authorities behave which are taken into account by criminals.

Tutorial: breaking myths about AI fairness | Towards Data Science

Tags: tech, ai, machine-learning

Very nice tutorial, explores a good set of common biases. Also show that it’s not that simple to get rid of them.

Building Outer Wonders for Linux – Utopixel

Tags: tech, portability, linux, rust, elf

This is Rust focused but still, shows a good way to increase binary portability across distributions. I suspect a couple of things would be easier with elf-dissector even.

freenode now belongs to Andrew Lee, and I’m leaving for a new network.

Tags: tech, irc, freenode

The Freenode network is very much in trouble… This is so sad, my account there dated back from the early days of my KDE involvement. Needless to say it felt a bit weird to let it go.

Welcome to Libera Chat | Libera Chat

Tags: tech, irc, freenode

Hopefully, here is the safe haven for the people coming from Freenode. Time for a new account…

Game Engines Aren’t Just for Gaming Anymore | Hacker Noon

Tags: tech, 3d

Not that I needed to be convinced, but it’s now becoming clear 3D engines are getting out of games to become more pervasive.

Software Estimation Is Hard. Do It Anyway. - Jacob Kaplan-Moss

Tags: tech, project-management, estimates

I got a slightly different view on the topic. To me there’s value in the process of estimating, the estimation itself less so. The process often helps you refine both your understanding of the technical domain but also of the business domain.

Bye for now!

KDE's Author Avatars and Not Phoning Home

Friday 21st of May 2021 11:43:00 AM

For a long time now, KDE's about dialogues (the ones you find in the help menus in many of our apps) have supported the ability to fetch a bunch of information about the authors of our applications from the KDE Store through the Open Collaboration Services API. It does this by sending a request to the store for each of the authors who have an ocs username defined, to get the information on user avatars, profile links, and a few other potentially interesting details.

Phoning Home

If you are paying attention, you are now squinting at the screen and going "wait, I saw that title up there, and it clearly says not phoning home, and this is phoning home". You are, of course, entirely correct, and while it certainly was never done with ill intent, it is hard to dispute the fact that it is, in fact, phoning home. As a result, we have been poking about with ways of fixing this, without dropping overly much of the functionality.

Some of those crazy author people what make Discover happen

You might now be thinking what functionality, and sure, it's seems like perhaps a small thing, but remember: KDE is a world-wide community of people who work on this massive pile of software, and the about dialogue is basically the first place where many people are likely to learn of that concept, if they decide to go and look. As such, we want to put our best face forward, and in this case what we want is to firstly not be causing any undue internet traffic (because nobody wants that), but also we want to literally put faces forward.

Not Phoning Home

As of a couple of weeks ago, the KDE Store has had a simple url which will give you a redirect to the avatar that you have set on there, at the scale you need of it, and that's what we're using now. You can use it yourself as well - there's a short introduction to it over here. You can also link directly to your profile in a similar manner, by just linking to - for example, mine is

Oh look, authors what do money managementy things!

The result is two patches, which landed recently: One for Kirigami, and one for KXMLGui. All of this was originally spawned from a desire to reduce the complexity of KXMLGui itself, and specifically removing the requirement on Attica, which while certainly not heavy, was still doing an inordinate amount of work for an arguably small gain in this particular instance.

There is more to be done on this, mind you - if you read comments on the Kirigami patch, you will notice that one intention is to expand this avatarness to support things other than the store as well, and while i do have some ideas on the topic, if you've got some, don't hesitate to give me a poke! (not "why don't you just use gravatar", that's not the point here, any expansion of this needs to be generic, otherwise it doesn't make a huge deal of sense - the reason we're doing it this way is in part that the ocsUsername field is a part of KAboutData already, and it will Just Work(TM) for anybody who already uses that data structure).

Over To You?

Part of this work could arguably have been done before (specifically that not phoning home part, which from a user perspective is a checkbox which defaults to being off), but since this was originally based on removing the Attica requirement, frankly, this particular angle is something which i must confess, sadly, to have quite entirely missed.

And that, i guess, is the point here: It is staggeringly obvious in hindsight that this was totally a case of phoning home, and while it was never intended to be that, and to my knowledge was never used like that, it took someone pointing at it and going "yeah, this is doing a phoney homey thing" for me to go "yup, it clearly is, let's make that not happen". So that's what you can do here: Be that person that points out a blindingly obvious case of phoning home to someone who's just not noticed in a decade that that's what's happening, furthering KDE's goal of ensuring our software operates in a privacy conscious manner.

Finally, a direct question: Having to tick those boxes in each about dialogue is, arguably, a little far the other direction again, and having that tick apply to all about dialogues in our software would make that bit of life just a tiny bit simpler. Not a lot, arguably, but a little is also good, of course. The question, then, is this: Is it an acceptable tradeoff in privacy terms to let this tick box affect the about boxes in all our software, or should it be per-application? Personally i'm leaning toward it being acceptable, but i wanted to put it to the wider community before diving into that bit of the code.

The word of the day is: Care. Because we should, and we do :)

QJSValue vs QJSManagedValue/QJSPrimitiveValue

Friday 21st of May 2021 08:46:00 AM

When Qt 6.1 got released you might have read about QJSManagedValue and how it “give[s] more fine grained control over JavaScript execution”. But what does that actually mean? To understand this, let’s first recap what QJSValue is all about, and then compare it with the new classes.

Plasma gets Prettier and more Blurred by the day!

Friday 21st of May 2021 06:16:45 AM

Plasma gets Prettier and more Blurred by the day!

1 year update on the ThinkPad X1 Yoga laptop

Friday 21st of May 2021 12:50:07 AM

Last year I replaced my old laptop with a Lenovo ThinkPad X1 Yoga, and I wrote a preliminary review of it. This laptop is my only computer, used for both work and play. I’ve had it for a year, gotten used to some of my initial annoyances, and discovered a few new ones. So I thought I’d provide an update with some more long-term impressions.

What’s still annoying Location of PrintScreen key

I have not been able to get used to having the PrintScreen key between the right Alt and Ctrl keys. I hit it by accident and open Spectacle all the time. So I have re-bound it in the Keyboard KCM to be a second Meta key, which is much more useful. Now I can do window tiling with one hand! However this means I lose my PrintScreen key. I initially re-bound the stupid useless Insert key to be a new PrintScreen key using xmodmap, but that only works on X11, and I have not yet found a Wayland-compatible solution that I am capable of making work over the long haul. I did succeed in performing the re-mapping using config files and submitted a merge request upstream to offer “Insert key is Printscreen” as a keyboard option, but it was rejected. Since applying the patch locally relied on modifying system files, my changes gets blown away on every system upgrade. Our keyboard KCM is in need of a generic and user-friendly way to let people re-bind keyboard keys without having to mess around with config files.

Battery life

Battery life remains lower than I would prefer, even after a number of kernel upgrades. I usually limit charging to 90% to preserve battery longevity, but when I let it charge to 100%, I’m still getting 5 hours max, even when I baby it and don’t use power-hungry apps. This is quite disappointing. The laptop I replaced easily got 8 hours, even with a smaller battery. So I know it isn’t my software being an energy pig. I haven’t done any international travel over the past year due to the pandemic, but once I do, this will become a real pain real fast.

Screen resolution and aspect ratio

While I love the sharpness of the laptop’s 3840×2160 4K display, this resolution is overkill for its 14″ screen size. At 200% scaling, things are too small. Currently I am using 200% scale with 11pt Noto Sans font, which takes advantage of a bug in Noto Sans in that 11pt is 22% bigger than 10pt, not 10% bigger like you would expect. The super high resolution also results in excessive power consumption, contributing to poor battery life. And the 16:9 aspect ratio is not ideal.

Later models of this laptop have a 16:10 screen, but with the same excessive 4K resolution. Boo.

A 14″ laptop screen ideally needs a resolution of 3200×2000 so that when you scale it to 200%, you get an effective resolution of 1600×1000. This is still perfectly sufficient to make the individual pixels invisible, but would draw less power and yield un-problematic 200% scaling for perfectly crisp and pixel-aligned visuals.

Lousy Intel CPU

This laptop has an Intel Comet Lake 10th gen Core i7-10510U CPU manufactured with a 14nm process. While it is faster than what I had before, performance is disappointing compared to AMD’s Ryzen CPUs, which also generate less heat and consume less power due to their more advanced 7nm manufacturing process. Graphics performance is also quite bad, though the 11th gen version is apparently much better. But overall a monster Ryzen 4800 or 5800 series CPU would be a much better fit, providing superior performance, lower heat, and better battery life. Sadly Lenovo does not offer those CPUs in this laptop. They should, because AMD’s offerings are clearly better in almost every way. You’d lose Thunderbolt support, but I haven’t plugged in one Thunderbolt device in ten years of owning laptops with Thunderbolt ports. I don’t even know if any of then work.

Can only charge it from the left side

It’s a minor thing, but after a year of use from many locations, it’s annoying to have to wrap the cord around the back of the laptop when I happen to be somewhere where the nearest power outlet is on my right side rather than my left side. This might be less of an issue if the machine got better battery life so I didn’t have to keep it plugged in all the time–but it doesn’t, so I do, and it is.

Wobbly USB-C ports

This is a common problem in many laptops, but I expect better for an expensive one. There is really no excuse for USB-C cord to be super wobbly after plugging it into the laptop. It makes the whole thing seem flimsy and weak. More firmness would be much appreciated.

What’s still great

Everything else! The touchpad, rest of the keyboard, speakers, display quality, build quality, durability, portability, port selection, and design are all wonderful. The software issues I ran into before have largely been fixed (at least in the Plasma Wayland session, which is almost usable day-to-day for me). With the above-mentioned problems fixed, it would be a perfect computer.

Alas, they persist, and I have not found one that meets all of my requirements. The hunt continues…

Sharing your amortisation schedule to anyone

Wednesday 19th of May 2021 12:00:00 AM

Last month, my company allowed me to claim some benefits through a dedicated platform. This platform is specifically built for this purpose and allows you to recover these benefits not only in the form of coupons or discount codes, but also as reimbursements for medical visits or interest on mortgage payments.

I wanted to try the latter.

I logged on to the platform and then I filled in all the (many) details about the loan that the plaform asks you to fill in, until I had to upload my amortisation schedule which contains a lot of sensitive data. In fact, a strange thing happened at this step: my file was named document.pdf, but after uploading it was renamed to document_2.pdf.

How do I know? Well, let’s have a look to the UI:

It clearly shows the file name and that’s also a hyperlink. Let’s click then.

The PDF opens in my browser. This is expected, but what happens if we take the URL and try to open it in a private window?? Guess what?

You guessed it.

Let’s have a look to the URL again. It’s in the form: https://<host>/media/mutuo/file/d/o/document_2.pdf.

That’s tempting, isn’t?

I wanted to have some fun and I tried the following:

Both the curl output and the checksums are enough to understand that some document has been downloaded there (but discarded since I didn’t download them to my disk…).

Thus, since the d and o parent folders match the two initial letters of my file, I successfully tried with stuff like:

  • /c/o/contratto.pdf, /c/o/contratto_2.pdf, …
  • /c/o/contract.pdf, …
  • /p/r/prospetto.pdf, …

and it does also work with numbers too (to find this out I had to upload a file named 1.pdf

Krita’s Google Summer of Code Students

Tuesday 18th of May 2021 01:27:50 PM

This year, like every year since its inception, Krita participates in the abbreviated version of the Google Summer of Code program. It’s shorter than it used to be, but let’s see what our students are going to do!

  • Santosh will be working on making more operations work with multiple selected layers. You can read his project plan here.
  • Tanmay Chavan will be working on implementing an efficient algorithm to find the intersection of bezier curves in Krita’s vector layers. His project plan is here.
  • Sachin Jindal will be working on extending the reference image docker. His plan is here.

Congratulations on getting selected, all of you!

Part of the work our sponsored developers do is mentoring our students. Google’s mentor stipend goes to KDE, not to the mentors, so this is another reason to join our development fund!

The post Krita’s Google Summer of Code Students appeared first on Krita.

LAS 2021 and improvements in the applications infrastructure

Tuesday 18th of May 2021 01:05:35 PM

Last week I attended and even gave a small talk to the Linux App Submit (LAS). LAS is a cross-distro and cross-desktop event around Linux applications. It’s a good place to learn about all the new cool thing making it easier to build and distribute Linux applications. This motivated me to improve a bit more the presence of Plasma Mobile applications in Flathub, but also make various improvements to

Plasma Mobile and Flathub

Jonah, Devin and myself started packaging more Plasma Mobile applications to Flathub. Currently we added Koko, Index, Vvave, Alligator and Pix to Flathub and more pull request are already open and hopefully soon merged. also got a few updates. Volker fixed a regression caused by my latest rewrite of the website that was preventing the application page to show links to F-Droid and the Play Store when available. This prompted me to also add additional links to Flathub, but also to the nightly Windows build.

GCompris is really everywhere

Another small improvements and not yet visible in the UI is that it’s now possible to list all applications available on specific platforms. For example to see all the applications available on Android, you can use Similarly to see all the applications available on the Microsoft Store, you can use

On the Android page, some applications have been removed from the store and we should probably update the metadata accordingly or bring them back. Hint: It’s a good oportunity to get involved!

The next step is to expose these links in the homepage of the website.

Release tooling

A while ago, I added support for release information in Unfortunately the <release> tag isn’t often added in KDE applications for new release. Currently only a handful of applications like Krita, KDevelop, NeoChat or Calindori are using them. It’s a bit sad because it allows to link to the release announcements, but also link to the tarball and other artifacts (.exe, .dmg, .AppImage, …). Additionally this information are also displayed on Flathub and Discover.

To improve a bit the situation, for at least the package released by the release service, I started a merge request for the release-tools that adds more information to the AppStream file. This includes bugs fixed in the last version, a link to the tarball and the link to the announcement. A solution for other types of artifacts still need to be figured out, but since not all applications in the release service provide AppImages or Windows/macOS package, it’s more complicated.


Another application related improvement I have been working is a revamp of Discover homepage. This is still work in progress and the final visual result might change, but here is how it currently looks:

Discover new applications with Discover

DEVLOG 3: A Newer, Better Active Applet Line?

Tuesday 18th of May 2021 12:26:44 PM

DEVLOG 3: A Newer, Better Active Applet Line?

Plasma 5.22 Beta testing day

Tuesday 18th of May 2021 10:15:36 AM

Plasma 5.22 is now in beta. This gives us, KDE developers, one month of intense testing, bugfixing and polishing. During this time we need as many hands on deck to help find regressions, triage incoming reports and generally be on top of things as much as possible.

With that in mind, you are officially invited to our "Beta Review Day". Join us online and do QA with us together as a group.


Any Plasma user able to install the latest beta or run a live ISO with our beta on it and who wants to help.


Saturday 22nd May. A full timetable with areas of focus is available on the wiki:


Join us over videoconferencing at There will be plenty of room available, and you can join with a camera and a microphone or just use the classic text chat.

What will we do?

• Introduce you to Bugzilla so you can support us filing or triaging bugs
• Assign short lists to experienced participants so you can validate and de-duplicate bugs
• Go through a defined list of all the new areas of Plasma to check for regressions
• Devs will be online so you can give us debug info for issues you have, and identify and fix things in real time

What should I prepare?

Set up a machine, real or virtual, with the latest Plasma beta desktop. Go here: and download choose and install a distro that ships either the master or Plasma 5.21.90.

See you all soon!

Krita Dev Fund Campaign: Second Update!

Tuesday 18th of May 2021 10:09:46 AM

Here’s our second update on the state of Krita 5. We’re bringing you these updates to show what’s going on in Krita and why it’s a good idea to join the Krita development fund!  There are already more than 100 members of the dev fund! But let’s have some excitement first. The new smudge brush engine landed in Krita’s master branch last week, the culmination of months of work by Dmitry Kazakov and Peter Schatz:

If you want to give this a try, download one of the Krita Next nightly builds. There’s also a zip file with the presets Ramon created for testing the new engine! Now, take care! These are development builds, so make a backup of Krita’s settings and of the resources folder. Have fun!

Last week was also the week Halla gave a presentation on funding Krita development during the Linux App Summit. The video hasn’t been cut up in separate videos for each presentation. Her presentation starts at 2:58.

We also released the results of the contest we organized together with Huion. That was really fun, and there were so many awesome submissions!

Watch out Leon!

Now for the work that landed since our last update. It was mostly a bug fix week, where 21 authors have pushed 90 commits to master and 97 commits to all branches — we have been nicely busy!

  • Dmitry spent most of the week finishing the integration of the new color smudge engine. That’s in, as you’ve seen!
  • Alvin added console versions of Krita and kritarunner. This means you get a much better experience if you’re on Windows and you use Krita’s commandline options to convert images, for instance.
  • Amyspark was sponsored to work on making Krita build with the Microsoft Visual Studio C++ compiler. This is pretty tricky, because of bugs in that compiler. But we’re in touch with the Microsoft compiler team who have told us they all love Krita, so it might be possible to get these issues fixed! After that, Amyspark started looking into updating our Python plugin to the latest version of the Python and PyQt, which turns out to be really tricky, especially on Windows.
  • Emmet, Halla and Wolthera all have worked on the new animation input feature, adding a warning when you’re trying to import too many frames for your system to handle. This was sponsored work.
  • Deif Lou fixed color dodge/burn and hard mix for brush masking.
  • Sharaf Zaman was sponsored to fix issues for Android — and issues in general, like the transform tool no longer transforming the selection itself.
  • Halla was sponsored to continue working on the resource system rewrite. It’s been taking ages, but we’re getting results. Importing and creating gradients now works properly again. She also spent a day fixing bugs.
  • Agata was sponsored to work on the resource system rewrite as well, and she fixed saving mypaint brush presets into bundles as well as the layout of the tag selection widget. And she fixed showing the individual brushes of ABR (Photoshop) brush collection libraries.
  • Reinold Rojas worked on the grid brush engine: he made sure all grid particle types have brush outlines and added a shortcut to change the offset of the grid brushes.
  • Eoin and Emmet were sponsored to work on fixing animation related bugs and documentation fo rhte new animation features.
  • Wolthera was sponsored to work on the manual for Krita 5/

So, if you like what we’re doing, join the development fund!


The post Krita Dev Fund Campaign: Second Update! appeared first on Krita.

More in Tux Machines

Fete de la Musique and why I don’t use Google

Today is Fete de la Musique in the French-speaking world. It feels like the perfect time to release the video of former GNOME employee Magdalen Berns singing Zombie. I recorded this at the Google Mentor Summit in 2014. Magdalen is no longer with us, she died of cancer in 2019. If Magdalen was alive today, would she recognize the GNOME organization? People are gradually coming to realize that the recent attacks on Dr Richard Stallman crossed far too many red lines. Working for a non-profit organization is a privilege and when certain GNOME employees attacked a volunteer, Dr Stallman, they undermined the principle of volunteering everywhere. We already see people who signed the petition in the heat of the moment are asking to remove their names. The choice of the song's title is subject to debate. Are zombies the people trying to stamp out independent thought from leaders like Dr Stallman? Or are they the volunteers silenced by mindless groupthink? Read more

The best 10 videos conferencing tool for enterprises in 2021

Some problems are just too big and complex for any one person who handles them alone, for these challenges we need to collaborate, but what that means? Read more Also: Mike Gabriel: BBB Packaging for Debian, a short Heads-Up

today's howtos

  • How to install Raspberry Pi OS with desktop on Raspberry Pi 4

    The Raspberry Pi 4 is seriously impressive, with some considerable hardware improvements over the Pi 3. As a result, many are picking it up to use as a Linux computer. One of the best operating systems to run on the Pi 4 is Rasberry Pi OS. Here’s how to get it set up.

  • How To Install Froxlor on Ubuntu 20.04 LTS - idroot

    In this tutorial, we will show you how to install Froxlor on Ubuntu 20.04 LTS. For those of you who didn’t know, Froxlor is an open-source lightweight server management control panel to effectively manage web hosting, domain names, FTP accounts, email accounts, support tickets, and customers that are associated with them and are licensed under GPL. This article assumes you have at least basic knowledge of Linux, know how to use the shell, and most importantly, you host your site on your own VPS. The installation is quite simple and assumes you are running in the root account, if not you may need to add ‘sudo‘ to the commands to get root privileges. I will show you the step-by-step installation of the Froxlor server management panel on Ubuntu 20.04 (Focal Fossa). You can follow the same instructions for Ubuntu 18.04, 16.04, and any other Debian-based distribution like Linux Mint.

  • How to Enable / Configure Multi-Touch Gestures in Ubuntu 20.04 & Higher | UbuntuHandbook

    This simple tutorial shows how to enable & configure the multi-touch gestures in Ubuntu 20.04, Ubuntu 21.04, Ubuntu 21.10 using touchegg. For those running Ubuntu on laptop or PC with external touchpad, multi-finger gestures enable users with more actions to control your system. Since Ubuntu does not offer a utility to configure multi-touch functions, touchegg is a free open-source tool to enable this feature for you. And it supports for both global gestures or gestures for Firefox, Chromium, Google Chrome only.

  • How To Get Public IP From Command Line

    In this tutorial we’ll learn how to get Public IP address from Terminal or Command Line. This will be useful to find public IP address of a cloud instance like EC2 instance, Lightsail instance, or DigitalOcean Droplets. We can also use this method to find Public IP of a VPS or any bare metal server that have Public IP Address.

Audiocasts/Shows: XPLR, GNU World Order, and Emacs

  • XPLR: Insanely Hackable Lua File Manager

    My main file manager is LF and most of the file managers I look at are of the same style but today is different, today we're looking at XPLR which is a single pane file manager with extra sub windows that can be 100% customized in Lua.

  • GNU World Order 412

    **gcc-go** and **gcc-java** from the **d** software series of Slackware.

  • Transform Words Into Pretty Symbols In Emacs

    Emacs has a really neat mode built into it called prettify-symbols-mode. You add a block of code into your Emacs config listing words and corresponding symbols. Anytime you type one of the words, Emacs replaces with the symbol or emoji that you specify.