Planet KDE
Qt for MCUs 2.5.3 LTS Released
Qt for MCUs 2.5.3 LTS (Long-Term Support) has been released and is available for download. As a patch release, Qt for MCUs 2.5.3 LTS provides bug fixes and other improvements, and maintains source compatibility with Qt for MCUs 2.5.x. It does not add any new functionality.
Recursive Instantiation with Qt Quick and JSON
Recently I was tasked to come up with an architecture for remote real time instantiation and updating of arbitrary QML components.
This entry shows how you can use a simple variation of the factory method pattern in QML for instantiating arbitrary components. I’ve split my findings into 3 blog entries, each one covering a slightly different topic. Part 1 focuses on the software design pattern used to dynamically instantiate components. Part 2 shows how to layout these dynamic components by incorporating QML’ s positioning and layout APIs. The last entry, consisting of Parts 3 and 4, addresses the anchors API and important safety aspects.
This is Part 1: Recursive Instantiation with Qt Quick and JSON.
The original factory method pattern made use of static methods to programmatically instantiate objects of different classes, instead of having to call their constructors. It achieved that by having the classes share a common ancestor. Our variation of the popular pattern uses a Loader to choose which component to load, and a Repeater to dynamically instantiate arbitrary instances of this loader using a model.
Here we specify which components with a JSON array and use a Repeater to load them.
id: root // A JSON representation of a QML layout: property var factoryModel: [ { "component": "Button", }, { "component": "Button", } ] // Root of our component factory Repeater { model: root.factoryModel delegate: loaderComp }To be able to instantiate any kind of item, you can use a Component with a Loader inside, as the Repeater’s delegate. This allows you to load a different component based on the Repeater’s model data.
// Root component of the factory and nodes Component { id: loaderComp Loader { id: instantiator required property var modelData sourceComponent: switch (modelData.component) { case "Button": return buttonComp; case "RowLayout": return rowLayoutComp; case "Item": default: return itemComp; } } }To assign values from the model to the component, add a method that gets called when the Loader’s onItemChanged event is triggered. I use this method to take care of anything that involves the component’s properties:
// Root component of the factory and nodes Component { id: loaderComp Loader { id: instantiator required property var modelData sourceComponent: switch (modelData.component) { case "Button": return buttonComp; case "RowLayout": return rowLayoutComp; case "Item": default: return itemComp; } onItemChanged: { // Pass children (see explanation below) if (typeof(modelData.children) === "object") item.model = modelData.children; // Button properties switch (modelData.component) { case "Button": // If the model contains certain value, we may assign it: if (typeof(modelData.text) !== "undefined") item.text = modelData.text; break; } // Item properties // Since Item is the parent of all repeatable, we don't need to check // if the component supports Item properties before we assign them: if (typeof(modelData.x) !== "undefined") loaderComp.x = Number(modelData.x); if (typeof(modelData.y) !== "undefined") loaderComp.y = Number(modelData.y); // ... } } }Examples of components that loaderComp could load are defined below. To enable recursion, these components must contain a Repeater that instantiates children components, with loaderComp set as the delegate:
Component { id: itemComp Item { property alias children: itemRepeater.model children: Repeater { id: itemRepeater delegate: loaderComp } } } Component { id: buttonComp Button { property alias children: itemRepeater.model children: Repeater { id: itemRepeater delegate: loaderComp } } } Component { id: rowLayoutComp RowLayout { property alias children: itemRepeater.model children: Repeater { id: itemRepeater delegate: loaderComp } } }The Repeater inside of the components allows us to instantiate components recursively, by having a branch or more of children components in the model, like so:
// This model lays out buttons vertically property var factoryModel: [ { "component": "RowLayout", "children": [ { "component": "Button", "text": "Button 1" }, { "component": "Button", "text": "Button 2" } ] } ]Here we’ve seen how we can use a Repeater, a JSON model, a Loader delegate, and simple recursive definition to instantiate arbitrary QML objects from a JSON description. In my next entry I will focus on how you can lay out these arbitrarily instantiated objects on your screen.
Thanks to Kevin Krammer and Jan Marker whose insights helped improve the code you’ve seen here.
I hope you’ve found this useful! Part 2 may be found already or later by following this link.
Reference- To see a real world application of this factory design pattern in action, watch “QML for building beautiful desktop apps | Dev/Des 2021”, by Prashanth N. Udupa https://www.youtube.com/watch?v=l2nC-onPGQs
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 Recursive Instantiation with Qt Quick and JSON appeared first on KDAB.
How Selenium Helps Build Sustainable Software (And More)
In a general sense, sustainability refers to "the ability to maintain or support a process continuously over time". But what does it mean in terms of software?
With a rise in new technologies over the past half a century, the energy consumption of digital technology has greatly increased as well. Take, for example, large LLM models and cryptocurrency technology: both of these have heavy energy requirements. Software directly or indirectly consumes natural resources. The way software is written has a significant influence on resource consumption, such as with software-induced hardware obsolescence, when hardware vendors drive sales of new hardware through software updates that are incompatible with older hardware. The result is electronic waste and the unnecessary consumption of resources and energy in producing and transporting new hardware.
Sustainability in software means minimizing this waste. How? By designing software to limit energy consumption and have a smaller environmental impact. For this, we need tools to measure how much energy our software — and the hardware which runs it — needs. Without measurements, we cannot compare and we cannot improve!
KDE Eco has been working on KEcoLab, a project from Karanjot Singh to make KDE's measurement laboratory accessible to contributors from all over the world. KEcoLab needed a tool to easily playback usage scenarios for energy consumption data, and this is exactly what Selenium does by running automatic functional testing! But that's not all. Selenium also helps achieve the "KDE For All" goal by enabling accessibility improvements for everyone. It helps achieve the "Automate & Systematize Internal Processes" goal by creating functional tests to ensure the high quality of new code. In this way, Selenium helps achieve all three of KDE's goals!
Writing Tests In SeleniumSelenium AT-SPI is a Selenium-based tool used in KDE for automated tests of GUI applications. It works by identifying accessibility elements for a particular action. To know more about how Selenium AT-SPI functions internally, you can check out this blog post.
Writing a Selenium test is comprised of the following steps:
- Identifying QML elements where the action needs to be performed.
- Add accessibility code to QML elements. Accessibility code is basically a locator which will help Selenium identify that element and interact with it.
- Get elements by its locator. Once we are done with the previous step, we can now access those elements.
- Perform events on the elements. Once we are able to access elements, we can write code to interact with them.
You can follow this guide to setup Selenium AT-SPI and start writing basic tests. You can also check out this blog post for an in-depth overview.
Figure : Video "Selenium AT-SPI: How Selenium Helps Achieve KDE's Goals" (screenshot from Pradyot Ranjan published under a CC-BY-4.0 license). Introducing Selenium To More KDE ContributorsThis project was done under SoK'24 with these deliverables in mind:
- Improve the setup process of Selenium.
- Create video guides to introduce Selenium-based GUI testing to more KDE contributors.
I am achieving this by:
- Enhancing the Selenium setup guide. You can find the updated Setup and Getting Started guides here. It includes all of the latest packages and info about distro-specific packages and dependencies required to setup Selenium. I've also updated the Writing Tests section to account for deprecated function arguments.
- Creating slides and videos. I have created video presentations for newcomers to Selenium so that it is a smooth transition. For this I'm using KDE's Kdenlive software for video editing. Once the videos are published online, I will update this blog post with links. The videos broadly cover these topics:
-
An intro video about what Selenium is and how it is useful in achieving KDE's goals.
-
Setting up Selenium.
-
Using the accerciser utility to discover accessibility elements.
-
Writing accessibility code and tests to show how to access elements.
Some challenges that I faced were:
- Updating the setup guide so it is relevant with the latest changes. Selenium-AT-SPI is a moving target with a lot of internal changes and developements. Tracking down distro specific packages and making a list of deprecated/missing dependencies was time-consuming. The latest version of the setup guide can be found here.
- Making videos for using Selenium. With no prior experience, this was a challenge for me. I am proud to have done it!
As we move ahead, we have some plans for this project. Some of them are:
- We will be creating support rooms in Matrix to provide further support for KDE developers.
- We will use Selenium to adapt usage scenario scripts originally written with xdotool so we can compare the energy profiles of the emulation tools themselves.
If you are interested in contributing to Selenium-AT-SPI, you can join the Matrix channels KDE Energy Efficiency and Automation & Systematization Goal and introduce yourself. Selenium-AT-SPI is hosted here. Thank you to Emmanuel, Rishi, Nitin, and Joseph as well as the whole KDE e.V. and the wonderful KDE community for supporting this project and for all the help along the way. You can also reach out to me via email or on Matrix: @pradyotranjan:gitter.im.
KDE Gear 24.02.2
Over 180 individual programs plus dozens of programmer libraries and feature plugins are released simultaneously as part of KDE Gear.
Today they all get new bugfix source releases with updated translations, including:
- kcachegrind: Fix crash when opening history menu (Commit, fixes bug #483973)
- gwenview: No longer inhibit suspend when viewing an image (Commit, fixes bug #481481)
- elisa: Fix broken volume slider with Qt Multimedia backend (Commit, fixes bug #392501)
Distro and app store packagers should update their application packages.
- 24.02 release notes for information on tarballs and known issues.
- Package download wiki page
- 24.02.2 source info page
- 24.02.2 full changelog
The Sour Taste of Entitlement
Celebrating Creativity: Announcing the Winners of the Kubuntu Contests!
We are thrilled to announce the winners of the Kubuntu Brand Graphic Design contest and the Wallpaper Contest! These competitions brought out the best in creativity, innovation, and passion from the Kubuntu community, and we couldn’t be more pleased with the results.
Kubuntu Brand Graphic Design Contest Winners
The Kubuntu Council is excited to reveal that after much deliberation and awe at the sheer talent on display, the winner
of the Kubuntu Brand Graphic Design contest is Fabio Maricato! Fabio’s entry captivated us with its innovative
approach and deep understanding of the Kubuntu brand essence. Coming in a close second is Desodi, whose creative flair and original design impressed us all. In third place, we have John Tolorunlojo, whose submission showcased exceptional creativity and skill.
Wallpaper Contest Honours
For the Wallpaper Contest, we had the pleasure of selecting three outstanding entries that will grace the screens of Kubuntu 24.04 LTS users worldwide. Congratulations to Gregorio, Dilip, and Jack Sharp for their stunning wallpaper contributions. Each design brings a unique flavor to the Kubuntu desktop experience, embodying the spirit of our community.
A Heartfelt Thank You
We extend our deepest gratitude to every participant who shared their artistry and vision with us. The number and quality of the submissions were truly beyond our expectations, reflecting the vibrant and creative spirit of the Kubuntu community. It’s your passion and engagement that make Kubuntu not just a powerful operating system, but a canvas for creativity.
Looking Ahead
The Kubuntu Council is thrilled with the success of these contests, and we are already looking forward to future opportunities to showcase the talents within our community. We believe that these winning designs not only celebrate the individuals behind them but also symbolise the collective creativity and innovation that Kubuntu stands for.
Stay tuned for the official inclusion of the winning wallpaper designs in Kubuntu 24.04 LTS, and keep an eye on our website for future contests and community events.
Once again, congratulations to our winners and a massive thank you to all who participated. Your contributions continue to shape and enrich the Kubuntu experience for users around the globe.
Celebrate with Us!
Check out our special banner commemorating the announcement and join us in celebrating the creativity and dedication of our winners and participants alike. Your efforts have truly made this contest a memorable one.
Here’s to many more years of innovation, creativity, and community in the world of Kubuntu.
The results of our contest, our proudly displayed in our Github Repository
Cheers!
February/March in KDE Itinerary
It has been two exciting months since the last update on KDE Itinerary again, with new vehicle and train coach amenity information, DST changes in the timeline, progress on indoor routing and most notably the founding of the Transitous project.
New Features Train and coach amenity informationThe library we use for public transport data now has a much more elaborate data model for vehicle features. That’s general comfort feature like air conditioning or Wi-Fi but also things specifically relevant when traveling with small children, a bike or a wheelchair. These can also be qualified by availability (e.g. if those need a special reservation) and can be marked as disrupted.
Itinerary makes use of this in the train coach layout view, where it’s now possible to tap on a coach for a more detailed description.
Coach feature details in Itinerary's train coach layout view.Another place where this is used is anything showing results from journey or departure searches, such as when planning a new train trip. While all routing services provide some of this information, the level of detail can vary greatly though.
Vehicle features in journey search results.Since this is now available in a machine-readable form, it also becomes conceivable to allow configuring more detailed traveler profiles so Itinerary can show the information most relevant to you more prominently, or take this into consideration e.g. when automatically selecting transfer suggestions.
Daylight saving time informationSwitching to and from daylight saving time happens at different times in different locations (if at all), therefore Itinerary now also displays an information for upcoming daylight saving time changes in the timeline, similar as it already does for e.g. timezone changes.
Daylight saving time information in Itinerary's timeline. Infrastructure Work TransitousThe probably most significant development on the infrastructure side is the appearance of Transitous. That’s a project which started at FOSDEM 2024 barely two months ago with the aim of setting up a community-run free and open public transport routing service. It has been growing rapidly and is meanwhile a collaboration from people from many different FOSS and Open Data projects and communities.
Current Transitous coverage for long-distance travel in Europe.While not even having all the basic features completed yet, it nevertheless already provides value by covering a few countries where we didn’t have any public transport data at all before. Starting with 24.05 KPublicTransport will have support for Transitous enabled by default, and thus it will also become available in Itinerary and KTrip.
Unlike with vendor-operated or otherwise proprietary services it’s now possible to expand public transport data coverage ourselves, assuming publicly available GTFS feeds at least.
Indoor routingWork on indoor routing for our train station, airport or event venue maps also continued, with the focus on turning the previously shown demo that was able to find a path from A to B into something that does that reliably and matching human expectations, which is the bulk of the work here.
Examples of this include not taking “shortcuts” through paths you shouldn’t usually take (e.g. emergency exists, or walking through conference rooms/lecture halls as pictured below), but also ensuring robustness against imperfect or incomplete map data.
Shortest path (left), preferring corridors (right).Some of this also involves clarifying or extending the OSM data model, and onsite visits to inspect challenging locations.
Fixes & Improvements Travel document extractor- New or improved travel document extractors for AMSBus, ANA, Deutsche Bahn, Eckerö Line, Elron, European Sleeper, Eurostar, Eventim, Finnair, Flibco, Leo Express, LTG Link, Moongate, National Express, Pasažieru vilciens, Salzbergwerk, SNCF, Thalys, ti.to, Trenitalia and UK national railways.
- Added support for yet another variant of PDF raster images for barcode detection.
- Improved generic extractors for flight boarding passes as well as ERA FCB and VDV train tickets.
- Fixed the schema.org semantic annotations in the OSM event calendar.
- Consider GIF files as well when searching for barcodes.
All of this has been made possible thanks to your travel document donations!
Public transport data- Fixed Deutsche Bahn Hafas searches sometimes not including replacement trains.
- Fixed misdetected train coach types from UIC coach numbers.
- Updated coverage metadata from the Transport API Repository.
- Fixed caching of location queries and negative journey query results.
- Improved support for arrival query result paging.
- Updated support for ÖBB coach layout data.
- Fixed train coach layout queries using times in the wrong timezone.
- Fixed barcode scanning on Android, caused by a regression in Qt 6.6.2 (affects all KDE apps, not just Itinerary).
- Prevent overly large Apple Wallet pass footer images from messing up the layout.
- Fix editing of times in AM/PM format.
- Remember the last used folder in trip group export file dialogs.
- Suggest meaningful file names for exporting trip groups.
- Allow to copy the program membership number on reservation pages as well.
- Added enough space at the end of the journey details view so floating buttons don’t overlap relevant content.
- Added floating button to timeline page to navigate to the current element and for manually adding entries.
- Fixed current ticket selection for elements without known arrival times.
- Fixed retaining journey notes/vehicle layouts when getting partial trip updates.
- Fixed displaying of departure notes for train trips.
- Fixed displaying of public transport departure disruptions.
Feedback and travel document samples are very much welcome, as are all other forms of contributions. Feel free to join us in the KDE Itinerary Matrix channel.
This week in KDE: real modifier-only shortcuts and cropping in Spectacle
For years KWin has offered modifier-only shortcut handling via an obscure and undocumented method of editing the kwinrc file. Well, no more: in Plasma 6.1, KDE’s shortcut choosers will accept lone modifier keys natively! This makes it much easier to, for example, re-bind what the Meta key does: now you can easily make it open Overview, KRunner, or anything else simply by assigning it directly to that something else. This work required extensive re-plumbing throughout KDE’s software stack and was undertaken by Yifan Zhu, closing multiple Bugzilla tickets in the process—some fairly old. Thanks a lot, Yifan! (Link 1, link 2, link 3, link 4, link 5, and link 6)
But that’s not all! Though bug-fixing is eternal, we’ve largely gotten over the hump for Plasma 6.0, and I’ve noticed that features and UI improvement have occupied more of people’s attention recently. So let’s start with a much-requested one…
New FeaturesSpectacle regains a Crop tool, this time integrated internally rather than coming from a 3rd-party annotations library. This also happens to fix a related bug (Noah Davis, Spectacle 24.05. Link 1 and link 2):
For laptops with RGB-backlit keyboards, Plasma has gained the ability to keep the backlight color in sync with the active accent color! And support for custom colors is coming too (Natalie Clarius, Plasma 6.1. Link 1 and link 2):
https://i.imgur.com/zlsaJlX.mp4The new automatic crash reporter now gives you the option to let it always download debug symbols in the background to improve the crash reports it generates (Harald Sitter, Plasma 6.1. Link)
Going along with the theme of modifier-only shortcuts, you can now make an unused mouse button simulate pressing a modifier key alone (David Redondo, Plasma 6.1. Link)
Even though Snaps are supposed to auto-update, Discover has gained the ability to let you manually update them if desired (Kevin Ottens, Plasma 6.1. Link)
UI ImprovementsDolphin now shows a visible error message when you use a keyboard shortcut to trigger an action that can’t be performed in the current context, like cutting a file in a read-only folder (Jin Liu, Dolphin 24.05. Link):
In Elisa, you can now switch between list and grid views as you see fit (Jack Hill, Elisa 24.05. Link):
In Elisa, you can now search for albums on the Tracks page (Karl Hoffman, Elisa 24.05. Link)
You can now select multiple wallpapers in Plasma’s “add new wallpaper” dialog (Sahil Arora, Plasma 6.0.4. Link)
Changed Breeze-themed radio buttons and checkboxes to use the “Button” color role as most other interactive UI elements already do, which not only improves visual consistency, but also fixes a visual glitch in QtQuick-based software where these UI elements would have the wrong color some of the time (Akseli Lahtinen, Frameworks 6.1 and Plasma 6.1. Link 1, link 2, and link 3)
List headers in Kickoff now use the standard list header style seen in QtQuick-based KDE apps, which also necessitated creating a version of that component suitable for Plasma, so expect to see it showing up in more places too (me: Nate Graham, Plasma 6.1. Link 1 and link 2):
The Plasma Digital Clock widget’s holiday list picker no longer elides long text; instead it wraps the text, since there’s plenty of space to show it in the long already-scrollable list (Ivan Tkachenko, Plasma 6.1. Link)
Bug FixesOkular no longer asks you for a password to open encrypted PDF documents where the encryption isn’t actually applied to simply opening them (Nicolas Fella, sponsored by TU Dresden, Okular 24.02.2. Link)
Fixed a set of related crashes in Plasma that appear to have been a subtle side effect of the recent fix to make apps in Kickoff’s favorite grid disappear immediately when uninstalled (Fushan Wen, Plasma 6.0.4. Link)
Fixed another case where Plasma could crash when you plugged in a new screen (Fushan Wen, Plasma 6.0.4. Link 1 and link 2)
Fixed a rare Plasma crash that could happen when clicking on certain System Tray icons (Fushan Wen, Plasma 6.0.4. Link)
Fixed a case where Spectacle could crash after ending a screen recording when using certain GPU hardware (Fabian Vogt, Plasma 6.0.4. Link)
Fixed bug that had broken the ability to log out within 60 seconds of logging in when using Plasma’s systemd-enabled startup process (Harald Sitter, Plasma 6.0.4. Link)
Fixed an issue that caused two-finger touchpad taps on the Task Manager to not open a context menu with certain, shall we say, “less than premium” touchpad hardware (Fushan Wen, Plasma 6.0.4. Link)
Contributed code hardening for four additional crashes picked up by KDE’s automatic crash reporting system, which as you can tell is proving quite useful! (Fushan Wen again; he’s just that amazing! Plasma 6.0.4. Link 1, link 2, link 3, and link 4)
Fixed the date information in the tooltips of various clock widgets not being localized correctly (Albert Astals Cid, Plasma 6.0.4. Link 1 and link 2)
Fixed a variety of additional weird issues with mouse cursors in video games on Wayland (Xaver Hugl, Plasma 6.1. Link 1 and link 2)
Fixed some visual glitches that could happen on Wayland when you resize certain types of window that open in a maximized state (Ser Freeman, Plasma 6.1. Link)
Other bug information of note:
- 2 Very high priority Plasma bugs (down from 4 last week). Current list of bugs
- 34 15-minute Plasma bugs (down from 35 last week). Current list of bugs
- 145 KDE bugs of all kinds fixed over the last week! Full list of bugs
Spectacle now takes screenshots faster when used outside of Plasma and KWin on X11 (Konstantin Kharlamov, Spectacle 24.02.2. Link)
By default, Partition manager now mounts volumes (other than / and /home) with the nofail flag so they don’t block boot-up when not available for some reason (Thomas Bertels, Partition Manager 24.05. Link)
Fixed a memory leak in Plasma’s Networks widget (Fushan Wen, Plasma 6.0.4. Link)
Custom QML layouts for lock screens in Global Themes are no longer honored, as this is too security-sensitive (Marco Martin, Plasma 6.1. Link 1, link 2, link 3, and link 4)
The Dialog Parent effect (the thing that makes windows get dimmed when a child dialog window is open) now works on Wayland (Carlos Garnacho and David Redondo, Plasma 6.1 with Qt 6.8. Link)
Did a major code-quality overhaul of the Plasma Digital Clock and Calendar widgets, which fixed a bunch of fragility, warnings, and some minor glitches, with more to come soon (Ivan Tkachenko, Plasma 6.1. Link)
Automation & SystematizationWrote a tutorial on how to publish your Android-compatible KDE app on the Google Play store (Ingo Klöcker, link)
…And Everything ElseThis blog only covers the tip of the iceberg! If you’re hungry for more, check out https://planet.kde.org, where you can find more news from other KDE contributors.
How You Can HelpKDE has become important in the world, and your time and labor have helped to bring it there! But as we grow, it’s going to be equally important that this stream of labor be made sustainable, which primarily means paying for it. Right now the vast majority of KDE runs on labor that KDE e.V. didn’t pay for, and that’s a problem. We’ve taken steps to change this with paid technical contractors—but those steps are small due to limited financial resources. If you’d like to help change that, consider donating today!
Otherwise, visit https://community.kde.org/Get_Involved to discover other 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!
Qt Creator 13 - CMake Update
Here is a set of highlighted CMake features and fixes in Qt Creator 13. Have a look at the ChangeLog for all the CMake changes.
KDE: “Run a command” on notification trigger
KDE had a feature a lot of people didn’t know about. You could run a command when a notification triggered. The feature wasn’t very well documented and nobody really blogged about it.
However with the release of KDE Plasma 6, the feature was removed. I learned about it by accident, as it is tracked by Bug #481069. I really need the feature and I re-implemented it in KDE Plasma 6. I will be available in KDE Plasma 6.1 and KDE Frameworks 6.1.
KDE: Run a command Text-to-Speech for calendar eventsI’m using the “Run a command” feature for calendar events. Normally you get a popup notification. The popup notification is small and pop up where all of them are shown. When I’m concentrated and working on some code I simply miss them. If I play a game, I miss them.
The solution for me is to use a Text to Speech (TTS) Engine. I’ve setup speech-dispatcher with piper-tts on my system. When an a reminder triggers it says: “Andreas, you have an appointment in 10 minutes: Samba Meeting”.
You can find the python script I use here.
Endless possibilitiesThe opportunities endless. Here are some ideas what else you could do:
- Start your meeting/conferencing application prior to the meeting
- Change the desktop activity before a meeting
- Lock the screen if a specific WiFi gets disconnected
If you have some nice idea or already used it in the past, leave a comment to let me know what else you can do.
KStars 3.7.0 is Released
CI & CD Infrastructure
We say goodbye to KDE's binary factory as we transition to fully use Gitlab's CI/CD pipelines to build, test, and publish KStars. Over the last two months, Eric Dejouhanet worked with the KDE's Craft & System admin teams to transition KStars pipelines to the new framework.
Short status on pipelines:
- Merge requests run the custom build and the CI builds
- Master runs the CI build (though there could be other things we run, such as CVE scans)
- Craft recipes are run from the last commit of the master or release branch, they require "build" and "build-and-test-stable" to be run manually beforehand.
- Publishing to Microsoft store is available after the Windows Craft is run.
Donut Buster
Rejoice Newtonian, SCT, and RC owners! With KStars new Donut Buster feature, your donut focusing woes might be something of the past. John Evans implemented this experimental feature to help protect against outliers that might affect your autofocus routine. In addition to that, the Focus Advisor is now automatically applied when creating new profiles. Based on the type of equipment you have in your optical train, the Focus Advisor would try to guess the optimal focus settings for your setup. Both features are experimental and would benefit from your feedback.
Custom Views
Akarsh Simha introduced the ability to orient the sky map to match the view through any instrument.
A view is a collection of settings: the orientation of the sky map, how the orientation changes as the sky map is panned, whether it is mirrored or not, and optionally the field-of-view to set the map to.
If no views are defined, KStars introduces a set of standard / "demo" views by default. Existing views can be edited and new views can be added using the "Edit Views..." interface. They can also be re-ordered in the interface. The ordering of the views in the "Edit Views..." dialog defines the order in which views will be cycled through using the keyboard shortcuts Shift + Page Up and Shift + Page Down. Thus, you can set up the views for easily switching between naked eye / finder scope / telescope views for easy star-hopping.
Furthermore, there is a new option in the View menu that enables mirroring the sky map so as to be able to match the view through an erecting prism used for example on a Schmidt-Cassegrain or Refracting type telescope.
The rotation feature overlay now also marks East in addition to north and zenith, so as to know easily whether the display is mirrored or not.
Blinking
Hy Murveit added a very useful Blinking feature to the FITS Viewer tool. This adds several ways to blink; that is, compare multiple images.
In Analyze, one can now move from one session to the next (forward or backward).
Keyboard shortcuts are provided for that.
Another set of keyboard shortcuts both advance and show the next image in the same FITS Viewer.
Thus, for example, one can advance through all the captured images of the evening, showing all the captures on the FITS Viewer by repeating a keyboard shortcut.
A useful complement to this might be adding the ability to delete bad captures, but for now that will have to wait for a rainy day.
In the FITS Viewer, the Open File menu command (both in the main KStars top menu, and in the FITS Viewer menu) now allows multiple files to be selected. If they are then the files are opened in individual tabs.
Shift-selecting would select files from the first to the shift-clicked file. Clearly one wouldn't want to select 100 files resulting in 100 tabs, but this can be used to, e.g. compare 10 images.
Going along with the above, keyboard shortcuts have been added to move to the next or previous FITS Viewer tab, Also helpful to the above is a new command to zoom in/out all tabs (not just the current one).
There is a new Blink Directory menu command (in both menus, as above) which will open a single tab with a list of all the images below the directory selected (that is, both in that directory, and in directories below it). It initially displays the first image, but new commands work in that tab to switch to displaying the next (or previous) image file in the list. This could be used to blink hundreds of files.
Sky Flats
Dušan Poizl added an option to capturing sky flats. When shooting flats at sky it often end up in never-ending loop of adjusting exposure because intensity of light change and calculation of exposure break down. Adjust the tolerance to 2000 ADU to higher for a better chance at capturing sky flats.
Scheduler Refactor
Wolfgang Reissenberger continues with his work on Separating Business Logic from UI in Scheduler. Over the years the Scheduler has grown to one of the most complex classes. With this release we refactored the Scheduler class and separated the UI from the underlying state model and its business logic. This opens the door for future development of new scheduling features and a much modular approach towards more flexible sequencing approaches.
Standalone Editor
To add any job to the scheduler, you need at minimum the following:
- Target
- Sequence File
Hy Murveit developed the standalone sequence editor in the scheduler module where it relies on settings saved from your last astrophotography session. Now it's easier than ever to plan scheduler jobs without having Ekos or your equipment profile running!
Size Policy for Qt Quick Controls
When using Qt Quick Layouts, it is necessary for the user to specify the attached properties Layout.fillWidth or Layout.fillHeight to stretch a child component. This process can become cumbersome as more components require it. Inline components may serve as an alternative, but they may not be as effective when dealing with different component types. To tackle these challenges, the size policy feature has been introduced in Qt Quick Controls in version 6.7 (under tech preview), mirroring similar functionality found in widgets.
Web Review, Week 2024-14
Let’s go for my web review for the week 2024-14. I will be vacationing next week, so I might skip next week post. We’ll see.
German state moving 30,000 PCs to LibreOfficeTags: tech, foss
Well done LibreOffice! I’d love to see many more announcements like this one.
https://blog.documentfoundation.org/blog/2024/04/04/german-state-moving-30000-pcs-to-libreoffice/
Tags: tech, ssh, security, supply-chain
Good analysis of the backdoor recently discovered in xz. Really a bad situation. Luckily it was probably detected before it could do any real damage. What’s especially striking is the amount of patience it required, it’s really been put in place over a long stretch of time to reduce chances of detection.
https://www.openwall.com/lists/oss-security/2024/03/29/4
Tags: tech, foss, community, security
Excellent post showing unhealthy consumer/maintainer dynamics in FOSS projects. This particular example was instrumental in getting the xz backdoor in place.
Tags: tech, foss, security, burnout
You think the xz vulnerability was a one time event? Think again, this kind of bullying with ulterior motives happen regularly to critical projects.
Tags: tech, foss, sustainability, quality, security
Definitely a good idea, we’d need several such institutes across the world. Would governments be willing to try this?
https://www.tbray.org/ongoing/When/202x/2024/04/01/OSQI
Tags: tech, apple, privacy
Can we let the myth of Apple being a proper steward with data privacy to rest please? I don’t know why people took their claims for granted to start… with so much opacity, it’s not a claim you could trust.
https://www.aalto.fi/en/news/keeping-your-data-from-apple-is-harder-than-expected
Tags: tech, ai, machine-learning, gpt, scam
AI supercharged scam. I guess we’ll see more of those.
https://www.404media.co/a-law-firm-of-ai-generated-lawyers-is-sending-fake-threats-as-an-seo-scam/
Tags: tech, ai, machine-learning, copilot, gpt, security, supply-chain
You should be mindful of the dependencies you add. Even more so when the name of the dependency has been proposed by a coding assistant.
https://www.theregister.com/2024/03/28/ai_bots_hallucinate_software_packages/
Tags: tech, ai, machine-learning, power, energy
Smaller models with smarter architectures and low-bit quantized models are two venues for more efficient use. I’m really curious how far they’ll go. This article focuses on low-bit quantized models and the prospects are interesting.
https://mobiusml.github.io/1bit_blog/
Tags: tech, ai, machine-learning, gpt, llama, optimization, performance, cpu
Excellent work to improve Llama execution speed on CPU. It probably has all the tricks of the trade to accelerate this compute kernel.
Tags: tech, rss, social-media
More people turning to RSS as a substitute for social media. There’s hope.
https://tudorr.ro/blog/zoomer-tries-rss/
Tags: tech, processes, dbus, kde, security
Interesting article, shows quite well the complexities of D-Bus and Polkit. Unsurprisingly such complexity easily leads to mistakes which can compromise security. This then hints to interesting things to keep in mind when you have to deal with D-Bus and Polkit.
https://security.opensuse.org/2024/04/02/kde6-dbus-polkit.html
Tags: tech, ntp, dns, time
Fascinating article which explores the behavior of the NTP Pool. If you wondered how it gives you an NTP server to query, you’ll know the answer. It also covers the consequences of its restrictive approach. This even raises security concerns. Still even though it’s not perfect this keeps being an essential service mostly run by volunteers.
https://labs.ripe.net/author/giovane_moura/ntp-pool-the-internet-timekeeper/
Tags: tech, rust, performance, refactoring, type-systems, memory
Nice balanced view on some of Rust characteristics. This is much less naive than some of the “Rust is great” posts out there.
https://blog.sdf.com/p/fast-development-in-rust-part-one
Tags: tech, memory, system
This is indeed a more interesting way to perceive garbage collection. This also lead to proper questions to explore on the topic.
https://xorvoid.com/on_garbage_collection.html
Tags: tech, databases, sqlite, server, performance, complexity
With some tuning SQLite can go a long way, even for server type workloads. There are still a few caveats but in some case this can reduce complexity and cost quite a bit.
https://kerkour.com/sqlite-for-servers
Tags: tech, craftsmanship, developer-experience, django, python
Another example of enforcing conventions using automated checks. This time using Python and Django tricks.
https://lukeplant.me.uk/blog/posts/enforcing-conventions-in-django-projects-with-introspection/
Tags: tech, javascript, web, frontend
A proposal for data bindings as first class citizens in JavaScript? This could be a good thing indeed.
https://github.com/proposal-signals/proposal-signals
Tags: tech, git, version-control
Or why a clean commit history can help quite a lot to find how and why a bug was introduced. This shows a few nice tricks around git log to speed up the process.
https://lucasoshiro.github.io/posts-en/2023-02-13-git-debug/
Tags: tech, c, memory, static-analyzer, compiler
Improved static analysis for C straight from GCC. This is definitely welcome.
https://developers.redhat.com/articles/2024/04/03/improvements-static-analysis-gcc-14-compiler#
Tags: tech, programming, safety, logic, mathematics
On the importance of invariants and consistent requirements in our trade. Admittedly it’s a long demonstration but it show the point well.
https://www.hansdieterhiep.nl/blog/on-invariance-and-inconsistency/
Tags: tech, tests, tdd, design
This is indeed too often overlooked. Producing a test list and picking the tests in the right order is definitely a crucial skill to practice TDD. It goes hand in hand with software design skills.
https://tidyfirst.substack.com/p/tdds-missing-skill-behavioral-composition
Tags: tech, organization, community, craftsmanship
Lots of good advices of course. It goes a long way to improve the quality of the project and the ease to on-board people. This is quite some initial work though.
https://matklad.github.io/2024/03/22/basic-things.html
Tags: tech, teaching, learning, pairing
Funny experiment. This shows what you can achieve in terms of teaching and learning during pair programming setups. Shadowing someone is a powerful approach.
https://two-wrongs.com/programming-apprenticeships.html
Tags: management, coaching, mentoring
This is a nice way to frame the three activities. They help people progress but in different ways.
https://jacobian.org/2024/apr/1/mentorship-coaching-sponsorship/
Tags: tech, remote-working, asynchronous, communication
When you’re distributed, this is all about asynchronous communication. You can’t walk to a person desk (and you should probably avoid it anyway if colocated).
https://www.yegor256.com/2024/04/01/ping-me-please.html
Bye for now!
Embedding the Servo Web Engine in Qt
With the Qt WebEngine module, Qt makes it possible to embed a webview component inside an otherwise native application. Under the hood, Qt WebEngine uses the Chromium browser engine, currently the de facto standard engine for such use cases.
While the task of writing a brand new standard-compliant browser engine is infamous as being almost unachievable nowadays (and certainly so with Chromium coming in at 31 million lines of code), the Rust ecosystem has been brewing up a new web rendering engine called Servo. Initially created by Mozilla in 2012, Servo is still being developed today, now under the stewardship of the Linux Foundation.
With the browser inherently being exposed to the internet, it is usually the biggest attack vector on a system. Naturally this makes Servo very attractive as an alternative browser engine, given that it is written in a memory-safe language.
A Servo WebViewAt KDAB we managed to embed the Servo web engine inside Qt, by using our CXX-Qt library as a bridge between Rust and C++. This means that we can now use Servo as an alternative to Chromium for webviews in Qt applications.
From a QML perspective this component is similar to the Chromium WebView, such as providing canGoBack, canGoForward, loading, title, url properties and goBack, goForward methods. The QML item itself acts in the same way with the contents being rendered to match its size.
import QtQuick import QtQuick.Window import com.kdab.servo Window { height: 720 width: 1280 title: webView.title visible: true ServoWebView { id: webView anchors.fill: parent url: "https://servo.org/" } }The screenshot below shows a basic QML application with a toolbar containing back, forward, go buttons and an address bar. We use CXX-Qt to define Qt properties, invokables, and event handlers (e.g. touch events) in Rust and trigger events in the Servo engine. Then any update requests from Servo can trigger an update of the Qt side via the Qt event loop.
As we move towards stabilising CXX-Qt at KDAB, investigating real world use cases, such as exposing Servo to Qt, allows us to identify potential missing functionality and explore what is possible when joining the Rust and Qt ecosystems together.
Technical detailsUnder the hood most of the heavy lifting is done by our CXX-Qt bindings, which already bridges the obvious gap between the Rust and Qt/C++ worlds. However, some further glue is needed to connect the rendering contexts of Servo to being able to render the surfaces into the actual Qt application. Internally, Servo uses surfman, a Rust library to manage rendering surfaces. At the time of writing, surfman supports OpenGL and Metal, with support for Vulkan being planned.
We use surfman to create a new OpenGL context, that Servo then uses for rendering. To render the result into the QtQuick scene, we borrow the surface from Servo, create a new framebuffer object and blit the framebuffer into a QQuickFrameBufferObject on the Qt side.
Future possibilitiesServo development is active again after a period of less activity, therefore the API is evolving and there is work to improve the API for embedders. This could result in a simpler and documented process for integrating Servo into apps. Also as part of the Tauri and Servo collaboration, a backend for WRY could become available. All of these result in many possible changes for the bridge to Qt, as currently this demo directly constructs Servo components (similar to servoshell) but could instead use a shared library or WRY instead.
On the Qt side, there are areas that could be improved or investigated further. For example, currently we are using a framebuffer object which forces use of the OpenGL backend, but with RHI, developers might want to use other backends. A way to solve this for QML would be to change the implementation to instead use a custom Qt Scene Graph node, which can then have implementations for Vulkan, OpenGL etc and read from the Servo engine.
Alternatively Qt 6.7 has introduced a new QQuickRhiItem element, which is currently a technical preview, but can be used as a rendering API-agnostic alternative to QQuickFrameBufferObject.
If this sounds interesting to your use case or you would like to collaborate with us, the code for this tech demo is available on GitHub under KDABLabs/cxx-qt-servo-webview or contact KDAB directly. We also have a Zulip chat if you want to discuss any parts of bridging Servo or CXX-Qt with us.
Come and see us at Embedded World 2024 where we will have the Servo demo and others on display!
The post Embedding the Servo Web Engine in Qt appeared first on KDAB.
Explicit sync
Recently news went around about explicit sync being merged into Wayland protocols, and in the wake of that I saw a lot of people having questions about it, and why it was such a big deal… So here’s a short-ish explanation of what it is, why it’s needed and what the benefits are over the old model.
Why is synchronization needed?When applications “render” things, that rendering doesn’t happen immediately. Instead, they effectively record a list of commands with OpenGL or Vulkan for the GPU to execute, and that list then gets handed to the GPU to execute at its own pace.
This is needed for performance reasons: If the CPU had to wait for the GPU to execute each command one by one, both CPU and GPU would often sit around, doing nothing except waiting for the other one to finish its task. By executing commands on the GPU while the CPU does other things, like preparing new commands for the GPU, both can do a lot more work in the same time.
However, in practice, rendering commands don’t stand alone on their own. You might be running one task to render an image, and another one to process the result into something else, or to read it back to the CPU, so that it can be saved as a file on disk. If you do that without synchronization, you might be reading from the image in the middle of rendering, or even before the GPU has started to work on the buffer at all.
The “old” model: Implicit syncTraditionally with graphics APIs like OpenGL, the necessary synchronization has been done implicitly, without the application’s involvement. This means that the kernel and/or the userspace graphics driver look at the commands the application is sending to the GPU, check which images the commands are using, which previous tasks have to be completed before it, and potentially make the application wait until the dependencies of the commands it wants to execute are resolved.
The so-called dma buffer infrastructure that the Linux graphics stack uses for exchanging images between applications - like Wayland apps and the compositor - also uses the same model. When the render commands from the compositor try to read from an app’s buffer, the kernel will delay the command’s execution until the app has completed its rendering to the buffer.
This model makes it easy for application developers to write correctly working applications, but it can also cause issues. The most relevant of them for Wayland is that the application isn’t aware of which tasks it’s synchronizing to, and it can happen that you accidentally and unknowingly synchronize to GPU commands that don’t have any relevance to your task.
This has been a problem that Wayland compositors have been affected by for a long time: When presenting application images to the screen, compositors picked the latest image that the application has provided, which could still have GPU tasks running on it, instead of an earlier image that’s actually ready for presentation. This meant that sometimes presentation was delayed by the kernel, and you’d see a frame be dropped entirely, instead of just a slightly older image. This issue has been solved for most compositors in the last two years using what’s effectively explicit sync through a backdoor; I won’t explain the details of that here, but you can read Michel Dänzer’s blog post about it instead.
The “new” model: Explicit syncThe name already suggests exactly what it does: Instead of the driver or the kernel doing potentially unexpected things in the background, the application explicitly tells the relevant components (driver / kernel / compositor / other apps) when rendering is complete and what tasks to synchronize to in the first place, using various synchronization primitives.
On the application side, explicit sync is used in Vulkan, and the Wayland protocol specifically is used internally by OpenGL and Vulkan drivers to synchronize with the Wayland compositor.
This explicit way of synchronizing GPU commands doesn’t just help avoid accidental synchronizations, it also helps improve performance by reducing the work drivers have to do. Instead of having to figure out the dependencies of tasks from a relatively opaque list of commands, apps just tell them directly.
An important thing to mention here is that we already had a protocol for explicit sync, zwp_linux_explicit_synchronization_unstable_v1, but it shared a limitation with implicit sync: In order to get a synchronization primitive, it still required the GPU commands to be first submitted to the kernel. The new protocol in contrast allows to create and share synchronization primitives without submitting work to the GPU first, which - at least in theory - will allow applications to squeeze a little bit more performance out of your hardware in the future.
Do keep in mind though that these performance improvements are minor. While there may be some special cases where implicit sync between app and compositor was the bottleneck before, you’re unlikely to notice the individual difference between implicit and explicit sync at all.
Why the big fuzz then?If we already have “explicit sync through a backdoor”, and explicit sync doesn’t bring major performance improvements for everyone, why is it such big news then?
The answer is simple: The proprietary NVidia driver doesn’t support implicit sync at all, and neither commonly used compositors nor the NVidia driver support the first explicit sync protocol, which means on Wayland you get significant flickering and frame pacing issues. The driver also ships with some workarounds, but they don’t exactly fix the problem either:
- it delays Wayland commits until rendering is completed, but it goes against how graphics APIs work on Wayland and can cause serious issues, even crash apps in extreme cases
- it delays X11 presentation until rendering is completed, but as Xwayland copies window contents sometimes, that still often causes glitches if Xwayland is also using the NVidia GPU for those copies
There’s been a lot of discussions around the internet between people experiencing the issues constantly, and others not seeing any, and now you should know why it doesn’t seem to affect everyone: It’s not a deterministic “this doesn’t work” problem but a lack of synchronization, which means that a lot of factors - like the apps you use, the CPU and GPU you have, the driver version, the kernel, compositor and so on - decide whether or not you actually see the issue.
With the explicit sync protocol being implemented in compositors and very soon in Xwayland and the proprietary NVidia driver, all those problems will finally be a thing of the past, and the biggest remaining blocker for NVidia users to switch to Wayland will be gone.
Streamlining Strategies for Embedded Software Development
Developing embedded software is notoriously difficult – how can we simplify the process? Fortunately, there are lots of techniques you can use daily to help streamline your development.
Embracing AutomationThe specialized nature of embedded systems extends the ramp-up time for developers and necessitates a higher level of expertise. Automating hardware-specific tasks, such as deploying applications to boards, initializing debuggers, and resetting systems, can significantly reduce the time penalties that embedded developers face. Using automation to streamline setup for new engineers, everyday development routines, and testing workflows not only speeds up development but also ensures consistency.
Prototyping is VitalPrototyping is an indispensable part of embedded software development. Given the high cost and complexity associated with changes to software and hardware later in a project, early detection of potential issues is invaluable. Embedded prototypes need not be elaborate; rather, they should precisely address specific aspects such as hardware selection, software performance, integration strategies, and user interface design.
Prototyping serves multiple purposes, from assessing hardware performance metrics to conducting preliminary user-interface tests. Importantly, prototypes can also help pre-empt critical issues, form the basis of future test scaffolding, avoid the need to discard early code iterations, and even lay the groundwork for initial development.
Integrate Early and OftenIntegration represents a critical phase in development, one that brings together disparate pieces of the software puzzle. This includes various internal components developed by separate teams — like the middleware stack, user interface, and backend services — as well as third-party software. While the temptation might be to delay this challenging step, early and regular integration is the wiser approach. This proactive strategy facilitates the early identification and resolution of issues that are not evident in unit testing, helping to avoid last-minute crises.
Optimize, but CarefullyThe famous caution against premature optimization, coined by Donald Knuth in the 1960s, remains relevant today, especially where the interplay between hardware and software leads to complex performance issues in embedded systems. The key is not to avoid optimization but rather approach it with a thorough understanding of your application’s specific performance bottlenecks. Optimizing is both a time-consuming activity and a source of potential bugs, so optimize only when you need to and when you can show it can have a substantial impact. Use tools like perf, hotspot, and various other memory profilers to accurately diagnose performance problems. Once you have a clear understanding of the issues at hand, you can formulate an effective optimization strategy and establish benchmarks to maintain performance standards.
Byte-Wise, Megabyte-Foolish: A Cautionary TaleIt’s important not to lose sight of the forest for the trees. We learned this firsthand when helping a client who optimized their application’s search functionality to an impressive degree, only to overlook a major memory drain caused by an inefficient background image file format. This oversight led to unnecessary memory consumption that eclipsed the benefits gained by optimizing their search feature’s memory use – a reminder to consider the broader implications before optimizing.
Best PracticesFor those looking to delve deeper into the intricacies of embedded system design, our guides, Designing Your First Embedded Linux Device and Best Practices: Embedded Development provide insights and a wealth of detailed best practices to ensure your project begins and stays on a solid foundation.
If you want to learn more about embedded Linux, come talk to us at Embedded World 2024 (9th-11th April) in Nürnberg: KDAB at EW24.
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 Streamlining Strategies for Embedded Software Development appeared first on KDAB.
Implementing xdg-dialog-v1 in Qt and KWin
If you have used a moderately complex application there are chances that you have interacted with what is called a “modal” dialog. A modal dialog is a dialog that requires you to close/address it before you can continue interacting with the main application window. This can be implemented by the application in a straightforward manner but compositor didn’t know if a dialog was modal or not.
That is until now the new xdg-dialog-v1 protocol allows applications to mark their dialogs as modal or not modal. This allows the compositor to adapt its behavior according to this hint. For example when trying to activate the main window it can activate the modal dialog instead. It also enables KWin to use the darkening effect on the parent window on Wayland.
I implemented support for the protocol into KWin and Qt which will be part of the Plasma 6.1 and Qt 6.8 releases respectively. The protocol was created from functionality in GTK and Mutter by Carlos Garnacho and I am happy seeing the overall Wayland eco-system now being able to benefit from it.
Krita Monthly Update – Edition 14
Welcome to the latest development and community news curated for you by the Krita-promo team.
Development reportOfficial Recap of February’s Online Development Meeting
Last month we provided highlights of the video meeting led by Halla, Krita’s Maintainer. She has since published a post on Krita.org presenting the challenges and opportunities that came out of that meeting.
One of the largest projects this year is porting Krita from Qt5 to Qt6 (Qt is the framework upon which Krita is built). This is a major change and will require serious development time. We invite you to read more about the considerations of this project as well as other ideas the Krita team is currently discussing and changes that have taken place within Krita’s development team. You can access it here.
Highlights of this month-
YRH tackled a feature request to prevent the canvas from shifting position when toggling canvas-only mode. Deif_Lou assisted by also merging a fix addressing a jump in canvas position.
-
Grum999 identified an opportunity to improve grids and guides management such that settings are now saved in Krita documents. The grid offset on/off toggle was improved so that user settings are retained. Isometric grids may now be measured more accurately (Note: the original code was preserved and is now called “Isometric Legacy” to ensure compatibility with older documents).
-
The most recent text tool merge from Wolthera for 5.3 means Krita can now store units (relative units for letter spacing and font size). Wolthera reports that about half the properties are now implemented.
There should have been a video here but your browser does not seem to support it. (Video created by Wolthera)
-
Stable and unstable nightly builds are back following the migration to GitLab CI, with the exception of macOS which is being worked on. On Android, Krita will no longer be built for the 32-bit x86 architecture.
Krita-Artists members outdid themselves by creating 41 images for Mythmaker’s challenge: Marvellous Metal. The quality and calibre of the entries made it tough to choose only two when it was time to vote. Elixiah emerged the winner with these two images:
Vintage Forgotten Ford by elixiah Wildkat-Engine by elixiahElixiah asked MangooSalade and jimplex, who tied for second place, to choose the April challenge and they have come up with a good one! Our new topic is Animal Curiosity and this time there is an additional challenge. Read all about it here.
We’re Asking for Ideas
Mythmaker started a very positive conversation about improving the way images are selected for the featured artwork banner on krita-artists.org website. We have had nomination processes in place for some time which have been somewhat effective (and you’ll see the results of our first featured artwork poll in the next section) but we haven’t landed on a system that makes it easy to nominate artwork and is manageable administratively. Take a glance at some of the proposed ideas – something in there might trigger a new idea for you to share.
Featured artworkWe held our very first monthly poll for the Krita-Artists featured artwork banner. Five images were added to the banner so thank you for nominating and voting. Dragon Courier by desenhunos was the #1 pick.
The March/April nomination thread will be open until April 10, 2024. Here’s how you can participate.
Noteworthy pluginHCL Sliders by Lucifer “HCL Sliders is a color slider plugin with various hue/colorfulness/lightness models for use with the sRGB color profile and its linear counterpart.” More details about the plugin’s capabilities can be found in Lucifer’s post.
Tutorial of the month
Wrap Around Mode by David Revoy In just two minutes, you’ll learn what makes this feature so powerful.
Notable changes in codeThis section has been compiled by freyalupen. Mar 6 - Mar 31, 2024
Stable branch (5.2.2+):Bugfixes:
- File Formats: PNG - Fix lines in export of 32-bit CMYK images to PNG, by preventing multiple color conversions. (BUG:475737) (merge request, Rasyuqa A H (Kampidh))
- Usability - Fix a jump in canvas position when panning after going to Canvas-Only mode. (commit, Deif Lou)
- Linux: KDE Plasma - Fix Krita's menu not appearing in Plasma's global menu. (BUG:483170) (merge request, Halla Rempt)
- Text Tool - Fix a crash when pasting font family name into rich text editor and saving changes without hitting enter first. (BUG:484066) (merge request, Igor Danilets)
Features:
- General - Tweak the Welcome Page. New/Open File labels moved beside the icons. Recent file thumbnails have a tinted background. (merge request, Agata Cacko)
- General - Remove the development fund banner from the Welcome Page, as it was ineffective. (commit, Halla Rempt)
Features:
- Text - Allow keeping track of relative font units (em). (merge request, Wolthera van Hövell)
- Enclose and Fill Tool - Support gap closing in the Enclose and Fill tool. (commit, Deif Lou)
- Enclose and Fill Tool - Add "Include contour regions" option to the "All regions" method in the Enclose and Fill tool. (commit, Deif Lou)
- Vector Layers - Add an option to disable/enable anti-aliasing on Vector Layers. (merge request 1, merge request 2, Grum 999)
- Grids and Guides Docker - Various improvements to Grid and Guides. Grid and Guide properties are now saved into .kra files. New type of isometric grid that ensures the cell lengths match. (merge request, Grum 999)
- Animation Dockers - Add Lock Docker button to animation dockers. (merge request, reinold rojas)
- Scripting - Add various methods to Scratchpad API related to fill, zoom, and pan. (merge request, Grum 999)
Bugfixes:
- Layer Stack- Fix a crash when using color labeled layers as a reference for selection if color label includes a mask. (BUG:480601) (commit, Deif Lou)
- SVG - Fix saving 'paint-order' tag for non-text shapes. (commit, Dmitry Kazakov)
- Wide Gamut Color Selector- Fix Wide Gamut Color Selector shortcut popup closing immediately if the cursor is moving while triggering it. (merge request, reinold rojas)
- Usability - When switching to and from Canvas Only mode, keep the canvas in the same position. (merge request, Maciej Jesionowski)
These changes are made available for testing in the following builds:
- Stable "Krita Plus" (5.2.2+): Linux - Windows - Android (arm64-v8a / arm32-v7a / x86_64)
- Unstable "Krita Next" (5.3.0-prealpha): Linux - Windows - Android (arm64-v8a / arm32-v7a / x86_64)
(macOS builds will be available in the future.)
Like what we are doing? Help support usKrita is a free and open source project. Please consider supporting the project with donations or by buying training videos or the artbook! With your support, we can keep the core team working on Krita full-time.
Donate Buy something