Language Selection

English French German Italian Portuguese Spanish

Kde Planet

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

SeExpr status update!

10 hours 37 min ago

Hey all!

It’s been quite a while since my last post. Exams for my teaching certification have not gone as expected – had to pull out after being flattened in quite a critical one…

Buuuut! I am glad to announce that the SeExpr documentation is now available in the Krita manual!

The SeExpr tutorial, available now.

Along with this tutorial, you will find:

And, the most important, a great set of examples is now packed along with every Krita build for you to test and play with.

I am planning additional code-wise goals, but none fits within the two weeks remaining for the program… so, I’ll use the remaining two weeks for something project-related. I’m glad to announce that I’ll be taking part in this year’s Akademy– not only as part of the Student Showcase, but with a talk of my own!

The talk is entitled “Integrating Hollywood Open Source with KDE Applications”, and in it I’ll tell you about the itty-gritty bits of this journey. More formally,

In this presentation, I will guide the audience through the pitfalls and challenges of integrating this library with the Krita codebase. Developers in the audience will be interested in learning how SeExpr’s build system, platform support, and dependencies were harmonized with Krita’s. The creation of its layer generator, and formal specification of its storage requirements, will also be addressed. Artists will be interested in how SeExpr’s UI and UX was adapted to suit their current workflow, as well as KDE’s accessibility and internationalization requirements.

The talk is scheduled for September 5 at 19:30 GMT.

Thank you all for supporting me, and see you at Akademy!



Week 9 and 10 : GSoC Project Report

14 hours 37 min ago

Last two weeks I worked on implementing saving and loading of storyboard items and fixed some bugs. For implementing saving and loading I created a copy of the data from the models in KisDocument. That data is kept in sync with the data in models.

Saving and loading of storyboard items are working now. You can save a krita document with storyboards in it and the storyboard data will be saved. Thumbnails are not saved into the .kra file but are loaded using the frame number when the document is loaded. Other than that all data related to the storyboard such as scene name, comments, duration are saved. Since the data is in KisDocument we will have storyboards for each of the .kra files.

I worked on the Export dialog GUI and implemented some of the functions. The user can choose the range of items to render. The layout of the document to be exported can be decided either using the custom options i.e. Rows, Columns and Page Size or it can be specified using an SVG file. On clicking the “Specify layout using SVG file” button the a dialog to choose file would be created to choose the layout file. If the SVG file is selected the custom layout options would be disabled and cannot be changed as they are of no use. On clicking the Export button the user would get to choose the file name and location of the export file.

Other than that I fixed some bugs and changed tests to match new changes made. Also I wrote code documentation for most of the parts implemented till now.

This week I will work on creating a layout for exporting, specifying layout using SVG file and then maybe work on the actual exporting part as well. Other than that I plan to improve on the user documentation based on feedback received.

QML Online - Qt 5.15, Kirigami, Breeze and more!

Monday 10th of August 2020 07:20:39 PM

I'm happy to announce that QML Online is now running with the last version of Qt (5.15) and with an initial Kirigami integration with breeze icons!

There is also a couple of updates for quality of life, like:

  • HTML fixes/corrections
  • Better integration with Firefox
  • New Qt version information label
  • Support for QtQuick.XmlListModel

But sadly, with new features we do have new bugs! As I said before, the Kirigami integration is an initial version, there are some know bugs with it, like:

  • OverlayDrawer has a transparent background (the issue appears to be common in low performance environments)
  • Kirigami version is a bit old (v5.70), newer versions need Qt future feature for QFuture and friends
What is next

I'll be working closer with Kirigami to fix these bugs, and the new feature of multiple instances of QML Online on the same webpage will be in hold for now.

As a reminder, please be free to send Merge Requests, feature requests, opinions and issues.


I would like to thank all users of QML Online, and the people that are sending kind works about how it's improving their workflow and how useful the tool is! That really helps to move the project forward.

KDE neon Rebased on 20.04

Monday 10th of August 2020 04:20:40 PM

KDE neon is our installable Linux with continuous integration and deployment. It’s based on Ubuntu who had a new Long Term Support Release recently so we’ve rebased it on Ubuntu 20.04 now.

You should see a popup on your install in the next day or so. It’ll ask you to make sure your system is up to date then it’ll upgrade the base to 20.04 which takes a while to download and then another while to install.

Afterwards it should look just the same because it’s the same wonderful Plasma desktop.

Upgrade Instructions

The installable ISOs are also updated and this time they all use the Calamares installer.

Testing and Unstable edition, these are built from the soon-to-be-released Git branches and the untested Git branches. Alas trying the installable ISOs today we found some bugs in the Git Calamares installer so they’re not published yet but the upgrader will still popup on existing installs. Update these are up now

We implemented OEM install mode in Calamares so the other way to get neon is to buy a KDE Slimbook III and it’ll use that.

We also implemented a full disk encryption tickbox in Calamares.

The Docker images are still to be updated and the Snap packages also need moved over.

Old truths remain

Sunday 9th of August 2020 10:00:00 PM

This week I was going through the locale module in Calamares, bumped into a odd combination of new and deleteLater(), and something started nagging; that code can be better. I first did the “obvious” and moved things to the stack (er .. automatic storage duration) and then asked around, and in 2009 Frank Osterfeld blogged exactly about my problem, and explained that I’d done exactly the wrong thing.

Read Frank’s original on crashing KDE applications through modal dialogs, because he explains it very well.

Why do I bring this up? It’s old hat. Yesterday’s news. Common knowledge. Basic stuff everyone should know.

The thing is, common knowledge is kind of uncommon, and since senior developers don’t know everything, it’s worth repeating that kind of knowledge now-and-again.

Speaking of, at Akademy 2020 there will be a talk about this kind of old institutional knowledge. Tune in to Kevin on the last day of the conference.

KPhotoAlbum 5.7.0 out now

Sunday 9th of August 2020 07:33:00 AM

We’re pleased to announce a new release of KPhotoAlbum, the KDE photo management software! This time, it’s mostly a maintenance release with a lot of code cleanup and bug fixes. Nevertheless, there are also some changes and new features. In detail:

  • Custom color schemes: Most notably, we added support for custom color schemes. KPhotoAlbum now also has a “Dark Mode”: Comparison: Light and Dark Theme

    Note: This feature replaces the custom background color for the thumbnail view.

  • Image search: We now offer experimental options for image search tuning.

  • Thumbnails: We added the new CLI utility kpa-thumbnailtool to manage KPA’s thumbnail cache. The cache now also contains the thumbnail size. Please notice that after the thumbnail cache was converted to the new format, older versions of KPhotoAlbum can no longer read it!

  • Privacy lock: The fake password-protection has been removed from privacy lock. Even with the warning message it might give somebody a false sense of security.

  • HTML export: HTML export themes missing a name are no longer displayed.

In addition to other bugfixes, these have been addressed in the new release:

  • Make sure tag groups are always added to tag list as well (Fixes #423334).

  • Fixed handling of negation in searches (Fixes #334672).

  • Fix crash when dragging an image beyond the last thumbnail (Fixes #418251).

  • Fixed crash when ffmpeg can’t extract video thumbnails (Fixes #422555).

  • Removing a token no longer makes it disappear from the annotation dialog (Fixes #423978).

  • Sanitize input for the Tokens category, make Folder and Media Type categories read-only (Fixes #423979).
    We now have three types of list selects:

    "Normal" editable category (left), category that can only be selected (middle), read-only category (right)

The complete list of changes and fixes is listed in the ChangeLog.

Distribution-specific changes

This may be of interest esp. for the distributors:

  • Marble/libkgeomap: We no longer use Digikam’s libkgeomap to display geographic information and map views. Instead, we now utilize Marble directly.

  • KIPI plugins: The support for KDE’s KIPI plugins has been removed in favor of the new Purpose infrastructure.

  • Python 2: KPhotoAlbum’s Python 2 API has been dropped, along with all associated Python 2 scripts.

  • Qt 5.15: KPA’s code has been widely reworked and modernized (esp. speaking of using C++11 features instead of their old Qt macro counterparts) and now compiles again warning-free with Qt 5.15.

Thanks to everybody involved

According to git, the following individuals did commits this time (in alphabetical order):

  • Yuri Chornoivan
  • Robert Krawitz
  • Tobias Leupold
  • Jesper K. Pedersen
  • Johannes Zarl-Zierl

Thanks a lot to everybody having put work in this release!

— Tobias

Senior Developers don’t know Everything

Saturday 8th of August 2020 10:00:00 PM

For about 20 years, I’ve been doing C++ and Qt and KDE development. I suppose that makes me a “senior software engineer”, also in the sense that I’ve hacked, programmed, futzed, designed, architected, tested, proved-correct, and cursed at a lot of software. But don’t let the label fool you: I look up just as much in the documentation as I ever did; senior developers don’t know everything.

Documentation I looked up today:

Some of that documentation is going to remain fresh in my mind for a bit, some is going to be forgotten almost immediately (like the JSON schema bits: I need it to write a schema, but the schema is write-and-forget because automatic tools take over from there at least until the schema needs a change, which could be over a year from now).

None of this information is essential to my work as a developer as long as I know how to look it up, and can do so quickly and effectively: trivia knowledge is not a measure of developer worthyness.

So, you know, if you’re interviewing for a job position and get quizzes on this kind of things, then there are two possibilities:

  • the job is all about doing-this-one-thing, in which case the knowledge is necessary and yes, knowing it already is a thing, or
  • this is an incidental, once-a-year item where gatekeeping over it is unadulterated cow poop (from which, I learned this week, you can distill vanilla aroma).

Keep learning, but don’t be afraid to forget.

How to rock: First tips

Saturday 8th of August 2020 08:28:00 AM

After working for some time collaborating with open source/free software projects, I started to help newcomers to contribute and push the development further with good practices.

This post will try to itemize some important tips that can be used for software collaboration and personal projects, hopefully it'll help you to have a solid ground of good practices and advices for your contributions in a project. It contains information abut good code practices, a simple guide of helpful API design, code organization, comments, naming variables, development flow and self-criticism. Please enjoy, and any feedback (including critics) is much appreciated!

Code practices
  • Encapsulate magic variables:

    ...// First version start_communication(0, 1, 232); // Reviewer: What is the meaning of 0 ? What is 1 ? Why 232 ? ...// Second version enum class Messages { ... RequestStatus = 232, } ... const uint8_t vid = 0; const uint8_t cid = 1; start_communication(vid, cid, Messages::RequestStatus); // Reviewer: What is vid ? What is cid ? ...//Final version ... const uint8_t vehicle_id = 0; const uint8_t component_id = 1; start_communication(vehicle_id, component_id, Messages::RequestStatus);

    As you can see, the final version makes everything more readable, we know that we are starting the communication with a vehicle that has an id of 0 and the vehicle probably contains a component with id 1, and while calling this function we are also requesting the status. Much better than 0, 1 and 232 right ? Doing this will help the reviewers and future developers to understand what is the meaning of such numbers. It's also necessary to avoid variables that contains only single letters or really short abbreviations, is much harder to understand this: $$C^2 = A^2 + B^2$$ over this: $$hypotenuse^2 = catheti_1^2 + catheti_2^2$$

  • Avoid multiple arguments:

    ...// First version auto vehicle = new Vehicle( VehicleType::Car, 4, {28, 31}, Fuel::Electric, 1.2, 613 ); // Reviewer: What is the meaning of all this values ? // How can we make it better ? ...// Second version auto vehicle = new Vehicle(VehicleType::Car) vehicle->setNumberOfTires(4); vehicle->setTirePressure({28, 31}); vehicle->setFuel(Fuel::Electric); vehicle->setWeightInTons(1.2); vehicle->setAutonomyInKm(613); ...// It's also possible to use aggregate initialization in C++20 // and user-defined literals from C++11 auto vehicle = new Vehicle({ .type = VehicleType::Car, .numberOfTires = 4, .tirePressure = {28_psi, 31_psi}, .fuel = Fuel::Electric, .weight = 1.2_tn, .autonomy = 613_km, });

    Both second and C++20/C++11 alternatives are valid for a better readability of the code, to choose between both alternatives will depend of how are you going to design your API, probably if you are more familiar with the Qt API, the second version appears to be the most common, the C++20/C++11 alternative appears to be a bit more verbose but can be useful to avoid multiple function calls and helpful when dealing with a simpler code base.

  • Encapsulate code when necessary, try to break functions in a more readable and explanatory way:

    ...// Original version void Serial::start_serial_communication() { // Check if we are open to talk if (!_port || _port->register() != 0xb0001) { log("Serial port is not open!"); return; } // Send a 10ms serial break signal _port->set_break_enabled(true); msleep(10); _port->set_break_enabled(false); usleep(10); // Send intercalated binary for detection _port->write('U'); _port->flush(); // Send start AT command _port->write("AT+start"); } // Reviewer: Try to make it more readable encapsulating // some functionalities ...// Second version bool Serial::is_port_open() { return !_port || _port->register() != 0xb0001; } void Serial::force_baudrate_detection() { // Send a 10ms serial break signal _port->set_break_enabled(true); msleep(10); _port->set_break_enabled(false); usleep(10); // Send intercalated binary for detection _port->write('U'); _port->flush(); } void Serial::send_message(Message message_type) { _port->write(messageFromType(message_type)); } void Serial::start_serial_communication() { if (!is_port_open()) { log("Serial port is not open!"); return; } force_baudrate_detection(); send_message(Message::Start) }

    As you can see, the reason behind each block of code is clear now, and with that, the comments are also not necessary anymore, the code is friendly and readable enough that's possible to understand it without any comments, the function name does the job for free.

  • Avoid comments, that's a clickbait, comments are really necessary, but they may be unnecessary when you are doing something that's really straightforward, and sometimes when something isn't, it's better to encapsulate it.

    ...// Original version void blink_routine() { // Use the LED builtin const int led_builtin = LED_BUILTIN; // Configure ping to output setPinAsOutput(led_builtin); // Loop forever while(true) { // Turn the LED on turnPinOn(led_builtin); // Wait for a second wait_seconds(1); // Turn the LED off turnPinOff(led_builtin); // Wait for a second wait_seconds(1); } }

    Before checking the final version, let me talk more about it:

    • For each line of code you'll have a comment (like a parrot that repeat what we say), and the worst thing about these comments is that the content is exactly what you can read from the code! You can think that this kind of comment is dead code, something that has the same meaning as the code, but it does not run, resulting in a duplicated amount of lines to maintain. If you forget to update each comment for each line of code, you'll have a comment that does not match with the code, and this will be pretty confuse for someone that's reading it.

    • One of the most important skills about writing comments, is to know when not to write it!

    • A comment should bring a value to the code, if you can remove the comment and the code can be understandable by a newcomer, the comment is not important.

    ...// Final version void blink_routine() { const int led_builtin = LED_BUILTIN; setPinAsOutput(led_builtin); while(true) { turnPinOn(led_builtin); wait_seconds(1); turnPinOff(led_builtin); wait_seconds(1); } }

    There is a good video about this subject by Walter E. Brown in cppcon 2017, "Whitespace ≤ Comments << Code".

    And to finish, you should not avoid comments, you should understand when comments are necessary, like this:

    // From ArduPilot - GPIO_RPI void set_gpio_mode_alt(int pin, int alternative) { // **Moved content from cpp for this example** const uint8_t pins_per_register = 10; // Calculates the position of the 3 bit mask in the 32 bits register const uint8_t tree_bits_position_in_register = (pin%pins_per_register)*3; /** Creates a mask to enable the alternative function based in the following logic: * * | Alternative Function | 3 bits value | * |:--------------------:|:------------:| * | Function 0 | 0b100 | * | Function 1 | 0b101 | * | Function 2 | 0b110 | * | Function 3 | 0b111 | * | Function 4 | 0b011 | * | Function 5 | 0b010 | */ const uint8_t alternative_value = (alternative < 4 ? (alternative + 4) : (alternative == 4 ? 3 : 2)); // 0b00'000'000'000'000'000'000'ALT'000'000'000 enables alternative for the 4th pin const uint32_t mask_with_alt = static_cast<uint32_t>(alternative_value) << tree_bits_position_in_register; const uint32_t mask = 0b111 << tree_bits_position_in_register; // Clear all bits in our position and apply our mask with alt values uint32_t register_value = _gpio[pin / pins_per_register]; register_value &= ~mask; _gpio[pin / pins_per_register] = register_value | mask_with_alt; }

    Mostly of the lines in this code can be impossible to understand without access or reading the datasheet directly, the comments are here to understand what is going on and why, otherwise anyone that'll touch this code will need to do a reverse engineer to understand it.

Development flow
  • Avoid creating multiple Pull Requests (PRs), update the ones that are still open.

    • E.g: You created a Pull Request called "Add button feature", some modifications will be necessary after the review process, and for that you'll need to update the same branch over creating new ones. That's necessary to help the project maintainers to see previous comments and the development history. Creating multiple PRs will only make the maintainers confuse and unable to track old comments, suggestions and your code changes between PRs.
  • Create atomic and self-contained commits, avoid doing multiple tasks in the same commit.

    • E.g: You created a commit to fix the serial communication class, and inside the same commit you are doing 3 different tasks, removing trailing spaces, fixing a pointer validation check and a typo in the documentation of a different class. This appear to be silly and bureaucratic, but there are good reasons to break this simple commit and at least 3 different commits, one for the pointer check, a second one for the typo and a third one for the trailing space.

      Developers usually track lines history to understand the changes behind a functionality, it's common to search with grep history from commits or line changes in specific commits to understand the history of a library, function, class, or a small feature, if the commits start to be polluted with unnecessary changes, this development practice will be almost impossible to be done, since a bunch of unrelated lines will me changed between commits and this technic will be unable to help the dear developer. git blame will also be of little help.

      The example was also really simple, but you can imagine what happens if you change different parts of the code, for unrelated things, and a bug appears, technics such as git bisect will still work, but the result will be much harder to understand and to find which line is the one that created such bug.

  • Create atomic and self-sustained PRs, avoid doing multiple things in the same PR, like different features. They may appear simple with small pieces of code/functionality but they can escalate quickly after a review process, and if both features are somehow related or dependently, it's recommended to break it in multiple PRs with code to maintain compatibility with current code base.

    • E.g: You have applied a PR for software notifications, and somehow you also added a URL fetch functionality to grab new software versions from the server. After the first review, the maintainer asks to create a more abstracted way to fetch data from a REST API and to deal with network requirements, this will start to convolute the PR, moving the initial idea of the notification feature to an entire network REST API architecture. With that, it's better to break the PR in two, one that only provides the notification and a second PR that is used for the REST API related code.
  • Do your own review, the final and probably most important tip of all, doing that will train your mind and eyes to detect poor code standards or bad practices, it'll also make your PR be merged easily and faster, since you'll be able to catch problems before the reviewer feedback. Some reviewers may think that reviewing your own PR is a must, since we are talking about open source projects and free software, you should understand that the people that are reviewing your code are not obligated to do so, the majority are collaborating and donating their own time to help the development and maintenance of such projects, doing your own review is a sign of empathy about the project and maintainer time.

Final comment

This is the first post of a series that I'm planning to do. Hope that some of these points may help you in your journey.


This week in KDE: window thumbnails on Wayland

Saturday 8th of August 2020 05:27:43 AM

This week we got tons and tons of stuff done, including window thumbnails on Wayland! This much-awaited feature brings our Wayland session ever closer to parity with the X11 session. But wait, there’s more:

New Features

Konsole now lets you configure how dark inactive terminals become when using the “darken inactive terminals” feature (Tomaz Canabrava, Konsole 20.12.0)

Task Manager window thumbnails now work on Wayland! (Aleix Pol Gonzalez, Plasma 5.20)

Discover can now be used to perform updates of content downloaded through the Get New Stuff dialogs (Dan Leinir Turthra Jensen, Plasma 5.20)

Plasma applets now feature an “About” page in their settings windows (David Redondo, Plasma 5.20)

Kate and other KTextEditor-based apps now show a zoom indicator in the status bar when the current zoom level is not 100% (Jan Paul Batrina, Frameworks 5.74)

Bugfixes & Performance Improvements

Opening an audio file from the filesystem in Elisa from Dolphin or KRunner or another app now works (Matthieu Gallien, Elisa 20.08.0)

Switching screens while in Okular’s Presentation Mode now works (David Hurka, Okular 20.08.0)

Fixed a case where KWin could crash when logging out of a Wayland session (Andrey Butirsky, Plasma 5.20)

In a Plasma Wayland session, XWayland no longer brings down the whole session when it crashes; it just restarts normally (Vlad Zahorodniy, Plasma 5.20)

Changing the list of active KRunner plugins now takes effect immediately rather than requiring KRunner to be restarted (Alexander Lohnau, Plasma 5.20)

The Search widget now respects the current list of active KRunner plugins (Alexander Lohnau, Plasma 5.20)

The mouse cursor no longer sometimes gets stuck when using screen rotation on Wayland (Aleix Pol Gonzalez, Plasma 5.20)

Edge swipe gestures and showing a hidden panel by tapping the screen edge now work on Wayland (Xaver Hugl, Plasma 5.20)

Adding a new network interface no longer messes up the display in the Networks system monitor (David Edmundson, Plasma 5.20)

Changing the systemwide scale factor now invalidates the Plasma SVG cache, causing SVG-based user interface elements throughout Plasma to be re-drawn with the correct scale, which should fix a wide variety of minor graphical glitches seen after changing the scale factor (David Edmundson, Frameworks 5.74)

The Baloo file indexer now skips files that repeatedly fail to index rather than repeatedly trying to re-index them anyway and failing in a loop that trashes your CPU (Stefan Brüns, Frameworks 5.74),

User Interface Improvements

When applying a tag to a file in Dolphin, if the tags menu only had one item in it, it now automatically closes after applying the tag (Ismael Asensio, Dolphin 20.08.0)

The current date is now shown in the Digital Clock applet by default (Claudius Ellsel, Plasma 5.20)

Animation speeds throughout the Breeze Widgets and Decoration themes now respect the global animation speed (Martin Sandsmark and Marco Martin, Plasma 5.20)

It’s now possible to do multiplication in KRunner using “x” as the multiplication operator, not just “*” (Alexander Lohnau, Plasma 5.20)

KRunner now shows tooltips for entries that don’t entirely fit, so you now have a way to read the dictionary text (Alexander Lohnau, Plasma 5.20)

And yes, multi-line output is coming soon as well

Kubuntu 20.04.1 has been released today, featuring the beautiful KDE Plasma 5.18 LTS

Friday 7th of August 2020 08:47:40 PM

The Kubuntu Team is happy to announce that Kubuntu 20.04.1 LTS “point release” is available today, featuring the beautiful KDE Plasma 5.18 LTS: simple by default, powerful when needed.

As usual, this point release includes many updates, and updated installation media has been provided so that fewer updates will need to be downloaded after installation. These include security updates and corrections for other high-impact bugs, with a focus on maintaining stability and compatibility with Kubuntu 20.04 LTS.

More details can be found in the release notes:

In order to download Kubuntu 20.04.1 LTS, visit:

Download Kubuntu

Users of Kbuntu 18.04 LTS will soon be offered an automatic upgrade to 20.04.1 LTS via Update Manager/Discover. For further information about upgrading, see:

As always, upgrades to the latest version of Kubuntu are entirely free of charge.

We recommend that all users read the 20.04.1 LTS release notes, which document caveats and workarounds for known issues, as well as more in-depth notes on the release itself. They are available at:

If you have a question, or if you think you may have found a bug but aren’t sure, you can try asking in any of the following places:

#kubuntu on

Linux App Summit Goes Online in November

Wednesday 5th of August 2020 04:36:24 PM

Once again, KDE and GNOME are teaming up to bring you THE conference for people interested in establishing Linux as a great end-user platform. At the Linux App Summit we work on making app creation for users easy and worthwhile.

Since travel is complicated nowadays, we decided to make LAS 2020 a virtual conference. The event will open Thursday, 12th November and we'll wrap up on Saturday, 14th November. Our goal is to engage people in multiple time zones and make the content available online after the conclusion.

The Call for Talks is now open! Please take a look at the suggested topics and send in your ideas. We encourage new speakers, so don’t hesitate to submit a proposal!

Save the date on your calendar and we look forward to seeing you at LAS 2020!

Learn more about LAS 2020.

Important Dates:
  • Call for Papers opens: Today!
  • Call for Papers closes: September 15th
  • Speakers announced: October 1st
  • Conference: November 12th to November 14th

KBibTeX 0.10-alpha2 aka 0.9.81

Wednesday 5th of August 2020 03:32:47 PM

The release of KBibTeX 0.10 is approaching with the release of KBibTeX 0.10-alpha2 aka 0.9.81.

Improvements and changes since 0.9.2 are less on the user interface, but on the code behind it:

Read more... )

Many thanks go to contributors such as bug reporters, translators, and everyone else who contributed to KBibTeX!

Source code is available as tar ball, cryptographically signed using GnuPG key 1808CB466328F4380685A3B1A264FD738D861F41.


The structure of KDE, or how anarchy sometimes works

Tuesday 4th of August 2020 06:09:03 PM

KDE is a funny beast. In a lot of ways, it’s an anarchic society that actually works!

Engineers and designers work on KDE software and websites, but none of them are paid by KDE itself. Most are volunteers but some (myself included) are paid by 3rd-party companies. These people work on what they want or what they are sponsored by their company to work on, not what anyone in KDE tells them to work on.

KDE has a board of directors, but they are elected by KDE’s membership rather than stockholders (there is no stock lol), and they do not control KDE’s strategic direction as in a corporation. Rather, they mostly take care of financial and legal matters, sort out copyright claims, help to organize the yearly Akademy conference, and so on.

There is no formal “upper management” or even “middle management” layer. We have the “gardening team” whose members are in essence volunteer managers, but we mostly do things like triaging bugs, following up on stuck merge requests, performing QA on unreleased software, and so on. We support the people doing the work, rather than telling them what to do.

So how does anything get done around here?!

Well, just because KDE is an anarchy, does not mean that there is no organization and coordination! It’s just all done on a voluntary basis, with slightly unusual motivation techniques. Anarchy is not the absence of governance and decision-making, it’s just different from how it’s typically done.

In a corporation, managers motivate their employees by offering them them money, benefits, bonuses, promotions, and internal social perks. Bad work or bad behavior is punished by reprimands, demotion, or being fired.

But in KDE, most people are unpaid volunteers, so KDE has no financial leverage over them. Those who are paid are hired by 3rd-parties rather than KDE itself. Neither the carrot nor the stick will work!

Instead, motivation within KDE uses the currency of excitement. When a project is cool and its contributors publicly demonstrate its coolness and their enthusiasm for it, other people want to join in and help out! This turns out to be a very effective way to motivate free people to work on something: you make them feel like they want to be a part of something big and special, and you organize the discussion in a way that makes them feel like they can be included.

KDE’s design team (the VDG group) does a lot of this, constantly churning out astonishingly beautiful mockups and organizing discussions about important topics. People gravitate to the VDG’s proposals because they seem cool and there’s buzz and excitement surrounding it. The promo team works to generate that buzz and excitement. Other teams do similar things. You have to keep people excited and happy or else they will drift away.

This leads to an important point: you have to minimize negativity! For most people, conflict destroys energy and motivation. Internal arguments and politics need to be minimized and driven towards a consensus rather than simmering forever. Even if you have to bend a bit and give up some of what you want, that’s a better option than getting nothing because everyone is burned out by endless arguing. And new contributors in particular must be treated with kindness, given the benefit of the doubt, and made to feel welcome.

Similarly, if you’re a user who’s frustrated with the lack of progress on something you care about, insulting the developers or KDE itself in the bug report is the worst thing you could do: it will damage the motivation of the people in a position to do the work, reducing the chance that you will get what you want. Gently pinging people without negativity is the way to go–or even better, work on it yourself! Like all FOSS projects, KDE encourages self service.

Announcing Krita’s Scripting School!

Tuesday 4th of August 2020 12:13:40 PM

In 2018, we reintroducted scripting to Krita. Unlike our previous attempts to provide scripting, this time it took off! People are making all kinds of useful and fun extensions for Krita. Like a new color picker and mixer, a plugin to modify the way Krita’s subwindows are handled, new toolboxes, integration with other applications like Autodesk Shotgun,

But what was missing was a good overview of the various areas that could be scripted. Tutorials and example code on how to use the scripting API in bite-size chunks. The regular API documentation is generated automatically from the APIDOX comments. It is a good reference but can be difficult to understand since it is generated from the C++ code that provides the scripting bindings.

Scott Petrovic, Krita’s UX designer and website maintainer, created a fresh new tutorial website: Scripting with Krita:

Scripting with Krita

And there are not just the lessons teaching you about creating scripts, running them, using the Krita scripting API and how to develop plugins, there are also really useful overviews of the actions your script can trigger and the icons you can use!

The post Announcing Krita’s Scripting School! appeared first on Krita.

Plasma Browser Integration 1.7.6

Tuesday 4th of August 2020 07:00:00 AM

I’m pleased to announce the immediate availability of Plasma Browser Integration version 1.7.6 on the Chrome Web Store as well as Firefox Add-Ons page. This release comes with a few bug fixes, performance improvements, and translation updates.

Konqi surfing the world wide web

Plasma Browser Integration bridges the gap between your browser and the Plasma desktop. It lets you share links, find browser tabs in KRunner, monitor download progress in the notification center, and control music and video playback anytime from within Plasma, or even from your phone using KDE Connect!

What’s new?

(also see the Changelog Page on our Community Wiki)

Detecting camouflaged Chromium-based browsers

Chromium-based browsers such as Vivaldi and Brave have recently changed their user agents to match that of regular Chrome to avoid being spuriously blocked. However, this also meant that media controls and other extension features were mapped to Chrome instead. This has been addressed by also checking our parent process – something a website can’t so, so you’ll still be impersonating a “proper” Chrome on the web. If there’s any other Chrome-based browser you want to see explicitly supported, let us know!

Better video iframe handling

The extension is loaded into every website as well as its iframes. When navigating away from the page that is currently playing, media controls will be rescinded. Due to a bug this did not work for iframes, leading to a popuplar bug where Plasma would show ghost videos playing on pages like Tweetdeck.

Moreover, the website’s DOM is also monitored to notice when a player is dynamically added or removed, for instance when a video overlay opens or closes. Unfortunately, this monitoring can be quite expensive and became a bottleneck on pages with lots of dynamically loaded content like is the case when viewing a large merge request on KDE’s GitLab instance. This release significantly improves performance here.

Improved media controls

As usual, this release brings some improvements to media controls. Short sounds and videos are currently ignored to avoid trying to control e.g. a “new message” sound or short hover video previews. However, some live stream implementations don’t report the correct duration of Infinity but gradually fill up their time bucket every few seconds. Previously, the extension only checked duration once to determine whether to provide media controls. With this update duration is continuously checked and media controls would become available eventually.

Furthermore, for websites that do not set album art through Media Session API, the video player’s poster is now used as album cover. This is the cover image that is often shown when the video isn’t playing.

QML Online - Can be everywhere!

Monday 3rd of August 2020 06:59:39 PM

A new feature of QML Online is already available, allows it to run in any site/blog with minimal js/html code!

Hopefully, our experience with QML examples, tutorials and documentation should change in the near future.

Ff you don't know what QML Online is, please take a look in my previous posts:

What are we talking about ?

QML Online now can be used in any blog or website without much work, like this:

import QtQuick 2.7 import QtQuick.Controls 2.3 import QtQuick.Layouts 1.12 Rectangle { color: "#179AF3" anchors.fill: parent ColumnLayout{ anchors.bottom: parent.bottom anchors.right: parent.right CheckBox { checked: true text: "Check this!" } CheckBox { text: "Or this!" } } Text { text: "KDE" font.pixelSize: 80 font.bold: true color: "#82CB38" anchors.centerIn: parent RotationAnimator on rotation { running: true loops: Animation.Infinite from: 0 to: 360 duration: 1500 } } } --> const qmlonline = new QmlOnline("qmlonline") qmlonline.registerCall({ qmlMessage: function(msg) { console.log(`qml message: ${msg}`) }, qmlError: function(data) { console.log(`qml message: ${JSON.stringify(msg)}`) }, posInit: function() { qmlonline.setCode(`import QtQuick 2.7 import QtQuick.Controls 2.3 import QtQuick.Layouts 1.12 Rectangle { color: "#179AF3" anchors.fill: parent ColumnLayout{ anchors.bottom: parent.bottom anchors.right: parent.right CheckBox { checked: true text: "Check this!" } CheckBox { text: "Or this!" } } Text { text: "KDE" font.pixelSize: 80 font.bold: true color: "#82CB38" anchors.centerIn: parent RotationAnimator on rotation { running: true loops: Animation.Infinite from: 0 to: 360 duration: 1500 } } }`) }, }) qmlonline.init()

And how can this new feature be used ?

It's quite simple, check this minimal HTML example:

<html> <head> <title>Qml Online minimal example</title> </head> <body> <script type="text/javascript" src=""></script> <script type="text/javascript" src=""></script> <div id="qmlonline"></div> <script type='text/qml'> import QtQuick 2.7 import QtQuick.Controls 2.3 Rectangle { color: "#179AF3" anchors.fill: parent Text { text: "KDE" font.pixelSize: 80 font.bold: true color: "#82CB38" anchors.centerIn: parent RotationAnimator on rotation { running: true loops: Animation.Infinite from: 0 to: 360 duration: 1500 } } } </script> <script type='text/javascript'> const qml = new QmlOnline("qmlonline") qml.registerCall({ qmlMessage: function(msg) { console.log(`qml message: ${msg}`) }, qmlError: function(data) { console.log(`qml error: ${JSON.stringify(data)}`) }, posInit: function() { qml.setCode(Array.prototype.slice.apply(document.getElementsByTagName('script')).find(e => e.type == 'text/qml').text) }, }) qml.init() </script> </body> </html>

As you can see, there is three steps, include both qtloader.js and qml.js, add a div DOM and create a QmlOnline object. Since I'm not a web expert, probably there is a better way to organize this approach for the user and bugs may exist. Be free to create Merge Requests, or get in touch with feature requests and issues.

What is next ?

From my planned objectives, sharing QML Online as library to be available for any website was one of the final points, the only one that's still missing is the Kirigami support, that's still in progress and hopefully will be finished until the end of the year (if everything goes fine).

There is also a small bug, where it's not possible to use multiple QML Online instances on the same webpage.

MyPaint Brush Engine [Final Phase]

Monday 3rd of August 2020 09:45:00 AM
We are in the final phase of GSoC. I don't even remember how quickly the last two months flew by. Coming to my project, it is almost complete apart from some finalisation related stuff that still is remaining. Perhaps, some review changes that my mentors shall give me once my current patch has been reviewed are also remaining.
This month, (20 days remaining before the final submissions start actually) I need to complete two items:
  1. Refactorizing the plugin for master branch: There were a lot of changes in master due to the complete resource-rewrite. Because of this, I need to change my way of handling mypaint brush files (.myb files) in master. This requires a bit of refactorization. I am afraid its been a while since I have seen the master and don't what changes I need to do to make this plugin work in master. I just hope it does not turn out to be something complex.
  2. User Documentation: Apart from refactorization, I need to start with writing user documentation ASAP. The advanced mypaint brush settings don't make much sense to me though, that might cause a bit trouble. I don't know what to write for those. Will require some help for this from my mentors I guess.
I don't know why, but I always seem to have this feeling at the back of my head that something will come up that will be tough to handle and ruin my project. Though this has been happening even before GSoC started. That scares me a bit :( Anyways.
Good bye :)

GSoC'20 progress : Phase II

Sunday 2nd of August 2020 06:30:00 PM
Work progress during the second phase of Google Summer of Code

Latte Dock v0.10~ | July Update

Sunday 2nd of August 2020 01:35:00 PM

Hello everyone,

in the following you can read July development news from Latte Dock v0.10~ git version. [~, stands for rapid development, in your distro package repos is mentioned as git version]


1. New Auto Hide Sidebar visibility mode
Thanks to Martijn Vogelaar a new visibility mode for sidebars is supported. The new mode triggers Latte panel showing/hiding through the Latte Sidebar Button applet and global shortcuts but at the same time if the panel does not contain mouse for a period of time (can be set from Show timer) then it auto hides itself.
Visibility modes in general have updated their organization in order to be grouped much better. Currently they look like:

- visibility modes organization -

2. Background with All Corners

Users can now force background corners at all cases. I suppose this could be helpful if someone wants to replicate ChromeOS layout or play with different appearance styles.
- chromeos layout possibilities -

- all corners option in background -

3. Memory Consumption

A lot of improvements have been implemented in that regard. All Edit Mode windows (Canvas window, Main Settings with Behavior/Apperarance/Effects, Secondary small window) are now created only first time called and afterwards are reused for ALL Views (docks/panels) when requested. Because of this you are going to notice a very big memory usage drop when editing your panels and docks compared to any previous Latte version.
Even more, Indicators Config UIs found at Effects page are also following the new rule (create only once and reuse afterwards). In the past, indicators config uis were recreated its time a View was requesting editing. Because of that change I notice very stable memory usage that does not increase/decrease all the time when showing editing windows.
I think that the best way to calculate Latte memory consumption in v0.10~ is the following. Create your panels and docks the way you like them and change their properties and appearance to your liking. Close Latte afterwards and restart it. Start using your docks and panels by triggering popups, parabolic effect etc. Afterwards notice your memory usage but make sure that you have not triggered any docks/panels editing.

4. Layout Details Window

I am pretty proud of the new Layout Details window found in Layout Editor. With the new window you can add icons and backgrounds to your layouts in very nice and user friendly manner.
- layout details window / choose background color -

5. Layout Background Badges

- background badges -

When playing with Layouts in the editor it is nice to distinguish your different layouts fast and easy. Icons, colors and backgrounds are helping with this. Background badges take up the task and they are identified with the following priority:
   a. Layout icon is always preferred if it has been set by the user
   b. Layout assigned Plasma Activities icons are used if there is no layout icon
   c. Canvas Background is used there is no layout icon and that layout is not assigned to any activities
That was possible because layouts in the Editor are provided through QTableModel that has made the implementation pretty concrete and future proof.

6. Noteworthy Fixes

  • When a layout was deleted from Layouts Editor there were cases that could break the layouts model data validity.
  • Loading/Unloading different layouts could create a crash pointing in plasma frameworks because some codepaths were trying to access applets() that had already been destroyed.
  • Enable Hide Timer for ZERO value [instant use]
  • Enable dock/panel hiding only after any slide-in event has finished
  • Fix Panel/Dock types enforcement through Editing windows
  • Live Editing mode at all times even when "Rearranging and Configuring Applets". Latte is auto-adjusting dock and panel modes based on different user preferences immediately after such changes occur.
  • fix vertical system trays appearance for Plasma >= 5.19
  • Support XCB::SHAPE in order to define which dock areas are accepting mouse input and for all the rest input is forwarded to underlying windows [case of client sided background shadows used in docks].
  • Support GTK_FRAME_EXTENTS in order to define which dock areas are actually really used from docks and ignore all the rest. This way the compositor is informed about docks real geometry and locates underlying application windows accordingly [case of client sided background shadows that must be ignored from window manager].

7. Estimated Time of Arrival

There is none. Latte v0.10 will be ready, when it is ready. That may take up even one more year. I am developing Latte as my fun project and I want to keep it that way. If you think it is too far, do not hesitate, come, join and help...

8. Donations

Personally I do not think donations are necessary. Easier thing you can do is to just install from KDE Store the Latte related widgets, they work just fine even with plasma panels. KDE Store provides me some monthly beers because of this. Funny thing in that Latte Separator that I developed in a day provides me most of the beers and Latte Dock that I develop plenty of hours daily for the last three years provides me almost none.. :) I mention it as a funny fact, please do not take it differently.

In a case, if you still want to donate you can use the following:

You can find Latte at Liberapay ,    

or you can split your donation between my active projects in kde store.

Kate - User Feedback - August 2020

Sunday 2nd of August 2020 11:28:00 AM

Starting with the 20.04 release, Kate allows the user to turn on some telemetry submission. This is a purely opt-in approach. We do not submit any data if you not actively enable this feature! For details about the introduction of this feature, see this post.

After some months of having this out in the wild, I think it is time to show up with the first data we got.

Submission numbers

First, how many submission do we get?

Actually, not that many, even in July we got just ~800 data submission. As we hopefully have a lot more active users, it seems that not a large percentage of the users actually turned on user feedback submission. For the installations via the Windows Store we know we have ~20.000 active users in the lasts months per month (with some telemetry enabled), I would assume we have more on Unices.

What can already be learned from the data we got?

Kate versions in use

Most people use the the stable 20.04.x series and not some developer snapshot at the moment. And one sees that e.g. the 20.04.0 really got replaced by most users with one of the patch releases. How fast people really update from release to release needs to be seen, given the code is in since 20.04 and 20.08 is not yet out, that can’t be seen at the moment.

Qt versions in use

Next interesting data: which Qt versions are in use? Here, most people are already on Qt 5.15.

That is on one side nice, as the latest Qt version is the version I use most often for testing. On the other side, Qt 5.15.0 unfortunately has some breakage in the QJSEngine we use (actually, Qt 5.14, too), that means, if you see random crashes with backtraces into the QJSEngine parts, hope for some 5.15.x update (or backports done by your distribution). We can’t really work around that (beside if we would use a completely different engine, that would be a major effort).

Let’s see how the feedback submissions develop in the next months. Thanks already to all people already providing feedback!


If you want to chime in on this, feel free to join the discussion at the KDE reddit.

If you want to contribute, just join us at or on

More in Tux Machines

Linux Devices and Open Hardware

  • Mini-PC and SBC build on Whiskey Lake

    Supermicro’s 3.5-inch “X11SWN-H-WOHS” SBC and “SYS-E100-9W-H” mini-PC based it feature an 8th Gen UE-series CPU, HDMI and DP, 4x USB 3.1 Gen2, 2x GbE, and 3x M.2. Supermicro has launched a fanless, 8th Gen Whiskey Lake SBC and mini-PC. The SYS-E100-9W-H mini-PC (or SuperServer E100-9W-H), which was reported on by Fanless Tech, is certified only to run Windows 10, but the 3.5-inch X11SWN-H-WOHS SBC supports Ubuntu. Applications include industrial automation, retail, smart medical expert systems, kiosks, interactive info systems, and digital signage.

  • Exor nanoSOM nS02 System-on-Module Features the 800MHz version of STM32MP1 Processor

    Exor provides a Linux RT board support package (BSP) or Android BSP for the module which also fully supports the company’s X Platform including Exor Embedded Open HMI software, Corvina Cloud IIoT platform, and IEC61131 CODESYS or Exor xPLC runtime.

  • Onyx Boox Poke2 Color eReader Launched for $299

    Manga and comics fans, rejoice! After years of getting black & white eReaders, the first commercial color eReaders are coming to market starting with Onyx Boox Poke2 Color eReader sold for $299 (but sadly sold out at the time of writing). The eReader comes with a 6-inch, 1448 x 1072 E-Ink display that supports up to 4096 colors, and runs Android 9.0 on an octa-core processor coupled with 2GB RAM and 32GB storage.

  • xDrill Smart Power Drill Supports Intelligent Speed/Torque, Laser Measuring, Digital Leveling (Crowdfunding)

    Many home appliances now have smart functions, and in my cases, I fail to see the added value, and I’m not sure why I’d want/need a connected refrigerator with a touchscreen display. So when I first saw somebody make a “smart” power drill with a small touchscreen display I laughed. But after having a closer look, Robbox xDrill smart power drill could actually be a very useful device saving you time and helping work better.

  • Raspberry Pi calls out your custom workout routine
  • Odyssey Blue: A powerful x86 and Arduino machine that supports Windows 10 and Linux

    It has been a few months since we reported on the Odyssey, a single-board computer (SBC) designed by Seeedstudio. Unlike many SBCs, the Odyssey, or ODYSSEY-X86J4105800 to give it its full name, supported the x86 instruction set. While the Odyssey can run Windows 10, it is also compatible with the Arduino ecosystem. Now, Seeedstudio has expanded on the design of the Odyssey with the Odyssey Blue.

  • Bring two analog meters out of retirement to display temperature and humidity

    Tom of Build Comics created a unique analog weather station that shows temperature and humidity on a pair of recycled gauges. An Arduino Nano reads the levels using a DHT22 sensor and outputs them in the proper format for each display. Both units have a new printed paper backing to indicate conditions, along with a trimmer pot for calibration. To set the build off nicely, the Nano and other electronics are housed inside a beautiful custom wooden box, to which the antique meters are also affixed.

Programming Leftovers

  • Engineer Your Own Electronics With PCB Design Software

    A lot of self-styled geeks out there tend to like to customize their own programs, devices, and electronics. And for the true purists, that can mean building from the ground up (you know, like Superman actor Henry Cavill building a gaming PC to the delight of the entire internet). Building electronics from the ground up can mean a lot of different things: acquiring parts, sometimes from strange sources; a bit of elbow grease on the mechanical side of things; and today, even taking advantage of the 3D printing revolution that’s finally enabling people to manufacture customized objects in their home. Beyond all of these things though, engineering your own devices can also mean designing the underlying electronics — beginning with printed circuit boards, also known as PCBs. [...] On the other hand, there are also plenty of just-for-fun options to consider. For example, consider our past buyer’s guide to the best Linux laptop, in which we noted that you can always further customize your hardware. With knowledge of PCB design, that ability to customize even a great computer or computer setup is further enhanced. You might, for instance, learn how to craft PCBs and devices amounting to your own mouse, gaming keyboard, or homemade speakers — all of which can make your hardware more uniquely your own. All in all, PCB design is a very handy skill to have in 2020. It’s not typically necessary, in that there’s usually a device or some light customization that can give you whatever you want or need out of your electronics. But for “geeks” and tech enthusiasts, knowledge of PCB design adds another layer to the potential to customize hardware.

  • Programming pioneer Fran Allen dies aged 88 after a career of immense contributions to compilers

    Frances Allen, one of the leading computer scientists of her generation and a pioneer of women in tech, died last Tuesday, her 88th birthday. Allen is best known for her work on compiler organisation and optimisation algorithms. Together with renowned computer scientist John Cocke, she published a series of landmark papers in the late '60s and '70s that helped to lay the groundwork for modern programming. In recognition of her efforts, in 2006 Allen became the first woman to be awarded the AM Turing Award, often called the Nobel Prize of computing.

  • Excellent Free Tutorials to Learn ECMAScript

    ECMAScript is an object‑oriented programming language for performing computations and manipulating computational objects within a host environment. The language was originally designed as a scripting language, but is now often used as a general purpose programming language. ECMAScript is best known as the language embedded in web browsers but has also been widely adopted for server and embedded applications.

  • Alexander Larsson: Compatibility in a sandboxed world

    Compatibility has always been a complex problems in the Linux world. With the advent of containers/sandboxing it has become even more complicated. Containers help solve compatibility problems, but there are still remaining issues. Especially on the Linux desktop where things are highly interconnected. In fact, containers even create some problems that we didn’t use to have. Today I’ll take a look at the issues in more details and give some ideas on how to best think of compatibility in this post-container world, focusing on desktop use with technologies like flatpak and snap. [...] Another type of compatibility is that of communication protocols. Two programs that talk to each other using a networking API (which could be on two different machines, or locally on the same machine) need to use a protocol to understand each other. Changes to this protocol need to be carefully considered to ensure they are compatible. In the remote case this is pretty obvious, as it is very hard to control what software two different machines use. However, even for local communication between processes care has to be taken. For example, a local service could be using a protocol that has several implementations and they all need to stay compatible. Sometimes local services are split into a service and a library and the compatibility guarantees are defined by the library rather than the service. Then we can achieve some level of compatibility by ensuring the library and the service are updated in lock-step. For example a distribution could ship them in the same package.

  • GXml-0.20 Released

    GXml is an Object Oriented implementation of DOM version 4, using GObject classes and written in Vala. Has a fast and robust serialization implementation from GObject to XML and back, with a high degree of control. After serialization, provides a set of collections where you can get access to child nodes, using lists or hash tables. New 0.20 release is the first step toward 1.0. It provides cleaner API and removes old unmaintained implementations. GXml is the base of other projects depending on DOM4, like GSVG an engine to read SVG documents based on its specificacion 1.0. GXml uses a method to set properties and fill declared containers for child nodes, accessing GObject internals directly, making it fast. A libxml-2.0 engine is used to read sequentially each node, but is prepared to implement new ones in the future.

  • Let Mom Help You With Object-Oriented Programming

    Mom is a shortcut for creating Moo classes (and roles). It allows you to define a Moo class with the brevity of Class::Tiny. (In fact, Mom is even briefer.) A simple example: Mom allows you to use Moo features beyond simply declaring Class::Tiny-like attributes though. You can choose whether attributes are read-only, read-write, or read-write-private, whether they're required or optional, specify type constraints, defaults, etc.

  • Perl Weekly Challenge 73: Min Sliding Window and Smallest Neighbor

    These are some answers to the Week 73 of the Perl Weekly Challenge organized by Mohammad S. Anwar. Spoiler Alert: This weekly challenge deadline is due in a few days from now (on Aug. 16, 2020). This blog post offers some solutions to this challenge, please don’t read on if you intend to complete the challenge on your own.

  • [rakulang] 2020.32 Survey, Please

    The TPF Marketing Committee wants to learn more about how you perceive “The Perl Foundation” itself, and asks you to fill in this survey (/r/rakulang, /r/perl comments). Thank you!

Hardware With Linux Support: NUVIA and AMD Wraith Prism

  • Performance Delivered a New Way

    The server CPU has evolved at an incredible pace over the last two decades. Gone are the days of discrete CPUs, northbridges, southbridges, memory controllers, other external I/O and security chips. In today’s modern data center, the SoC (System On A Chip) does it all. It is the central point of coordination for virtually all workloads and the main hub where all the fixed-function accelerators connect, such as AI accelerators, GPUs, network interface controllers, storage devices, etc.

  • NUVIA Published New Details On Their Phoenix CPU, Talks Up Big Performance/Perf-Per-Watt

    Since leaving stealth last year and hiring some prominent Linux/open-source veterans to complement their ARM processor design experts, we have been quite eager to hear more about this latest start-up aiming to deliver compelling ARM server products. Today they shared some early details on their initial "Phoenix" processor that is coming within their "Orion" SoC. The first-generation Phoenix CPU is said to have a "complete overhaul" of the CPU pipeline and is a custom core based on the ARM architecture. They believe that Phoenix+Orion will be able to take on Intel/AMD x86_64 CPUs not only in raw performance but also in performance-per-Watt.

  • Take control of your AMD Wraith Prism RGB on Linux with Wraith Master

    Where the official vendor doesn't bother with supporting Linux properly, once again the community steps in to provide. If you want to tweak your AMD Wraith Prism lighting on Linux, check out Wraith Master. It's a similar project to CM-RGB that we previously highlighted. With the Wraith Master project, they provide a "feature-complete" UI and command-line app for controlling the fancy LED system on AMD's Wraith Prism cooler with eventual plans to support more.

The Massive Privacy Loopholes in School Laptops

It’s back to school time and with so many school districts participating in distance learning, many if not most are relying on computers and technology more than ever before. Wealthier school districts are providing their students with laptops or tablets, but not all schools can afford to provide each student with a computer which means that this summer parents are scrambling to find a device for their child to use for school. Geoffery Fowler wrote a guide in the Washington Post recently to aid parents in sourcing a computer or tablet for school. Given how rough kids can be with their things, many people are unlikely to give their child an expensive, premium laptop. The guide mostly focuses on incredibly low-cost, almost-disposable computers, so you won’t find a computer in the list that has what I consider a critical feature for privacy in the age of video conferencing: hardware kill switches. Often a guide like this would center on Chromebooks as Google has invested a lot of resources to get low-cost Chromebooks into schools yet I found Mr. Fowler’s guide particularly interesting because of his opinion on Chromebooks in education... Read more Also: Enabling Dark Mode on a Chromebook (Do not try this at home)