call_end

    • chevron_right

      Sam Thursfield: Status update, 23rd February 2026

      news.movim.eu / PlanetGnome • 1 day ago • 4 minutes

    Its moments of change that remain striking in your memory when you look back. I feel like i’m in a long period of change, and if like me you participate in the tech industry and open source then you probably feel the same. It’s going to be a wild time to look back on.

    As humans we’re naturally drawn to exciting new changes. Its not just the tech industry. The Spanish transport minister recently announced ambicious plans to run trains at record speeds of 350km/h. Then two tragic accidents happened, apparently due to careless infrastructure maintenance. Its easy (and valid) to criticise the situation. But I can sympathise too. You don’t see many news reports saying “Infrastructure is being maintained really well at the moment and there haven’t been any accidents for years”. We all just take that shit for granted.

    This is a “middle aged man states obvious truths” post, so here’s another one we forget in the software world: Automating work doesn’t make it go away. Lets say you automate a 10 step release process which takes an hour to do manually. That’s pretty great, now at release time you just push a button and wait. Maybe you can get on with some other work meanwhile — except you still need to check the automation finished and the release published correctly. What if step 5 fails? Now you have drop your other work again, push that out of your brain and try to remember how the release process worked, which will be hazy enough if you’ve stopped ever doing release manually.

    Sometimes I’ll take an hour of manual work each month in preference to maintaining a complex, bespoke automation system.

    Over time we do build great tools and successfully automate bits of our jobs. Forty or fifty years ago, most computer programmers could write assembly code and do register allocation in their heads. I can’t remember the last time I needed that skill. The C compiler does it for me.

    The work of CPU register allocation hasn’t gone away, though. I’ve outsourced the cognitive load to researchers and compiler teams working at places like IBM / Red Hat, embecosm and Apple who maintain GCC and LLM.

    When I first got into computer programming, at the tail end of the “MOV AX, 10h; INT 13h” era, part of the fun was this idea you could have wild ideas and simply create yourself piece by piece, making your own tools, and pulling yourself up by your bootstraps. Look at this teenager who created his own 3D game engine! Look at this crazy dude who made an entire operating system! Now I’m gonna do something cool that will change the world, and then ideally retire.

    It took me the longest time to see that this “rock star” development model is all mythology. Just like actual rock stars, in fact. When a musician appears with stylish clothes and a bunch of great songs, the “origin story” is a carefully curated myth. The music world is a diverse community of artists, stylists, mentors, coaches, co-writers, producers, technicians, drivers, promotors, photographers, session musicians and social media experts, constantly trading our skills and ideas and collaborating to make them a reality. Nobody just walks out of their bedroom onto a stage and changes the world. But that doesn’t make for a good press release does it ?

    The AI bubble is built on this same myth of the individual creator. I think LLMs are a transformative tool, and computer programming will never be the same; the first time you input some vaguely worded English prompt and get back a working unit test, you see a shining road ahead paved with automation, where you can finally turn ideas into products within days or weeks instead of having to chisel away at them painfully for years.

    But here’s the reality: our monkey brains are still the same size, and you can’t If your new automation is flaky, then you’re going to spend as much time debugging and fixing things as you always did. Doing things the old way may take longer, but the limiting factor was never our typing speed, but our capacity to understand and communicate new ideas.
    “The future belongs to idea guys who can just do things”. No it doesnt mate, the past, present and future belongs to diverse groups of people whose skills and abilities complement each other and who have collectively agreed on some sort of common goal. But that idea doesn’t sell very well.

    If and when we do land on genuinely transformative new tool — something like a C compiler, or hypertext — then I promise you, everyone’s going to be on it in no time. How long did it take for ChatGPT to go from 0 to 1 billlion users wordwide?

    In all of this, I’ve had an intense few months in a new role at Codethink. It’s been an intense winter too — by some measures Galicia is literally the wettest place on earth right now — so I guess it was a good time to learn new things. Since I rejoined back in 2021 I’ve nearly always been outsourced on different client projects. What I’m learning now is how the company’s R&D division works.

    • chevron_right

      Federico Mena-Quintero: Librsvg got its first AI slop pull request

      news.movim.eu / PlanetGnome • 3 days ago • 1 minute

    You all know that librsvg is developed in gitlab.gnome.org , not in GitHub. The README prominently says , " PLEASE DO NOT SEND PULL REQUESTS TO GITHUB ".

    So, of course, today librsvg got its first AI slop pull request and later a second one , both in GitHub. Fortunately (?) they were closed by the same account that opened them, four minutes and one minute after opening them, respectively.

    I looked.

    There is compiled Python code (nope, that's how you get another xz attack).

    There are uncomfortably large Python scripts with jewels like subprocess.run("a single formatted string") (nope, learn to call commands correctly).

    There are two vast JSON files with "suggestions" for branches to make changes to the code, with jewels like:

    • Suggestions to call standard library functions that do not even exist. The proposed code does not even use the nonexistent standard library function.

    • Adding enum variants to SVG-specific constructs for things that are not in the SVG spec.

    • Adding incorrect "safety checks". assert!(!c_string.is_null()) to be replaced by if c_string.is_null() { return ""; } .

    • Fix a "floating-point overflow"... which is already handled correctly, and with a suggestion to use a function that does not exist.

    • Adding a cache for something that does not need caching (without an eviction policy (so it is a memory leak)).

    • Parallelizing the entire rendering process through a 4-line function. Of course this does not work.

    • Adding two "missing" filters from the SVG spec (they are already implemented), and the implementation is todo!() .

    It's all like that. I stopped looking, and reported both PRs for spam.

    • chevron_right

      This Week in GNOME: #237 Article Rendering

      news.movim.eu / PlanetGnome • 4 days ago • 5 minutes

    Update on what happened across the GNOME project in the week from February 13 to February 20.

    GNOME Circle Apps and Libraries

    NewsFlash feed reader

    Follow your favorite blogs & news sites.

    Jan Lukas announces

    I released Newsflash 5.0-beta1 to the beta channel of flathub. The headlining feature is a new native article view rendering everything with the help of Gtk. This also made it possible to overhaul everything media related (images, videos and audio). It should now closer resemble what can be found in fractal or tuba.

    Newsflash_5_beta1.DTC8doOG_Z1oPttP.webp

    Jan Lukas reports

    In related news: Newsflash now has a brother. The core newsflash library was used to create a TUI application by Christopher Auer. So if you like what Newsflash has to offer but prefer to stay in the terminal, check out eilmeldung: https://github.com/christo-auer/eilmeldung

    Third Party Projects

    Diego Povliuk announces

    Cine, the video player, got some quality of life updates on version 1.0.9:

    • The volume is now always restored on startup
    • Icon indicators for mute and subtitles on/off
    • Toggle elapsed/remaining time
    • Option to add folder to playlist
    • Unmute when changing volume
    • Hold click to double playback speed

    Install via Flathub

    cine_video_player_screenshot_main_window.Dwdf6ZP5_Z1OhyhS.webp

    ranfdev announces

    Lobjur has just received a big update!

    • It now works as a client for multiple link aggregators: Lobsters and Hacker News.
    • An integrated WebView has been added
    • The UI has been improved, with a new split layout
    • The comments are now displayed with complex formatting, converting HTML tags to GTK widgets

    Check it out on Flathub

    Anton Isaiev announces

    I’ve released RustConn 0.8.9, a major update driven largely by user feedback and feature requests. This version expands protocol support, security and refines the user experience.

    Key highlights:

    • New Protocols: Added full Kubernetes support (shell access/exec), Serial Console (via picocom), and SFTP integration (via URI or Midnight Commander).
    • Virtualization: Added support for importing Virt-Viewer (.vv) files (Proxmox/oVirt) and SPICE proxy tunneling.
    • Connectivity & Security: Added FIDO2/Security Key support for SSH, Wake on LAN (WoL) GUI, and improved RDP rendering on HiDPI displays.
    • UX & i18n: Added Regex-capable terminal search and translations for 14 languages (including UK, DE, FR, IT, PL).

    https://github.com/totoshko88/RustConn https://flathub.org/apps/io.github.totoshko88.RustConn

    rustconn1.yfK6Bh1g_Z2kS8n6.webp

    rustconn2.DGEF5Tj1_1Dj2Tm.webp

    rustconn3.CnAjgKUc_1Stezy.webp

    Phosh

    A pure wayland shell for mobile devices.

    Guido says

    Phosh 0.53 is out:

    Phosh’s overview now shows a splash for launching apps and the Polkit dialog has more user details. The on-screen keyboard scales better in landscape and adds new completion dictionaries. The Wayland compositor phoc got initial support for the xx-cutout-v1 Wayland protocol to inform clients about notches and display cutouts.

    There’s more — see the full details here .

    phosh-bg-completion-ujpscaled-keys.BFzBhFMf_Z1kH4WX.webp

    phosh-landscape.CvTpVZac_Z8zfoT.webp

    Parabolic

    Download web video and audio.

    Nick reports

    Parabolic is at V2026.2.4 this week with new features and many bug fixes!

    Here’s the full changelog:

    • Added a search bar for subtitles in the add download dialog
    • Added the ability to specify extra yt-dlp arguments for the discovery process
    • Added the ability to specify extra yt-dlp arguments for the download process
    • Fixed an issue where pausing and resuming downloads did not work correctly
    • Fixed an issue where video passwords were not working when specified
    • Fixed an issue where yt-dlp progress was not always displayed correctly
    • Fixed an issue where instagram stories did not download correctly
    • Fixed an issue where the encoder field was not properly cleared on FLAC files when remove source data was enabled
    • Fixed an issue where Parabolic would not detect translation languages correctly
    • Fixed an issue where Parabolic would use a previous save folder even if it no longer existed
    • Fixed an issue where downloaded yt-dlp version were not getting executable permissions on Linux
    • Fixed an issue where Parabolic wouldn’t open on Linux
    • Fixed an issue where playlist video downloads may not have had sound on Windows

    Parabolic_V2026.2.0.BBxr5_C5_Z1jVJEy.webp

    Crosswords

    A crossword puzzle game and creator.

    jrb says

    I’ve released GNOME Crosswords 0.3.17. This is a strong release, featuring both a new interface for the game and multiple features for the editor. Read the announcement here .

    Crosswords

    The game got a full UI refresh in preparation for GNOME Circle.

    • The game sports a new layout and design, including a sidebar for easier navigation
    • The welcome screen was cleaned up
    • A hints dialog was added to help players learn game controls
    • Fullscreen support was redone
    • Sorting and filtering was added to puzzle pickers
    • We improved the adaptive functionality and accent color support
    • Many polishing touches and bug fixes

    Crosswords Editor

    The editor also got some quality of life improvements as a result of user testing.

    • The new puzzle dialog got a complete overhaul, including the addition of almost a thousand additional templates
      • This dialog also gained a theme word editor to preset crossword themes before grid creation.
    • A new wordplay indicator dialog was added to help write cryptic clues
    • Printing support was added, so the final product can be printed.
    • Many polishing touches and bug fixes

    Finally, a request for TWIG readers. GNOME Crosswords could really benefit from improved artwork, and we’ve reached the limits of my Inkscape skills. If you’d like to get involved with artwork for GNOME, this could be a great place to begin. Drop me a line if you’re interested!

    Shell Extensions

    Miklós Zsitva says

    Matrix Status Monitor v5

    Matrix Status Monitor v5 has been released, focusing on deeper desktop integration and security awareness.

    New features include:

    • End-to-End Encryption Indicators: Encrypted rooms now feature a lock icon in the room list for immediate security verification.
    • Selectable Matrix Clients: Users can now toggle between Element and Fractal in the preferences. The extension handles URI dispatching to ensure the correct application is launched.
    • Settings UI Update: A refined preference window for easier API configuration and client selection.
    • Performance: Optimized asynchronous /sync calls using Libsoup3 to minimize impact on Shell performance.

    Extension Link: https://extensions.gnome.org/extension/9328/matrix-status-monitor/ Source Code: https://github.com/nurefexc/matrix-status

    matrix_status.Db7XJS2Z_ZhCalY.webp

    Just Perfection says

    The extensions porting guide for GNOME Shell 50 has been released and we are now accepting version 50 packages on EGO .

    Miscellaneous

    GNOME OS

    The GNOME operating system, development and testing platform

    Ada Magicat ❤️🧡🤍🩷💜 reports

    For a few months now, the gnome-build-meta repository - home of GNOME OS and the GNOME flatpak runtime - has been generating and publishing debug tarballs to our new debuginfod server . This week, Jordan added the final bits of configuration needed to use this infrastructure.

    As a result, debugging tools (like gdb) running in GNOME OS and the upcoming version 50 release of the GNOME flatpak SDK can dynamically fetch the debug symbols they need at that moment, no longer requiring developers to download and update large debug extensions on their system for debugging.

    GNOME Foundation

    Allan Day announces

    A new GNOME Foundation update post is available this week, covering highlights from the past two weeks. Notable items include the LAS 2026 announcement and a report from the latest Board of Directors meeting.

    That’s all for this week!

    See you next week, and be sure to stop by #thisweek:gnome.org with updates on your own projects!

    • chevron_right

      Allan Day: GNOME Foundation Update, 2026-02-19

      news.movim.eu / PlanetGnome • 4 days ago • 3 minutes

    Welcome to another GNOME Foundation update post, covering highlights from the past two weeks (this week and last week). It’s been a busy time, particularly due to conference planning and our upcoming audit – read on to find out more!

    Linux App Summit 2026

    We were thrilled to be able to announce the location and dates of this year’s Linux App Summit this week . The conference will happen in Berlin on the 16th and 17th of May, at Betahaus Berlin. More information is available on the LAS website .

    As usual, we are very pleased to be collaborating with KDE on this year’s LAS. Our partnership on LAS has been a real success that we hope to continue.

    Travel sponsorship for LAS 2026 is available for Foundation members through the Travel Committee, so head over to the travel page if you would like to attend and need financial support.

    February’s Board meeting

    The Board of Directors it’s regular monthly meeting last week, on 9th February. Highlights from the meeting included:

    • We finally caught up on our minutes, approving the minutes from a total of nine meetings . This was a big relief, and hopefully we will be able to stay on top of the minutes now that we’re caught up.
    • The Board was thrilled to formally add Nirbheek Chauhan as a member of the Travel Committee. Many contributors will know Nirbheek as a longstanding GStreamer hacker, and he’s already been doing some great work to help with travel. Thanks Nirbheek!
    • The Board approved a new document retention and destruction policy , which is something that we are encouraged to have by regulators.
    • I gave an update on the operational highlights from the last month, including fundraising, conference planning, and audit preparation.
    • The Board considered a proposal for an exciting new program that we’re hoping to launch very soon. More details to follow soon.

    The next Board meeting is scheduled for March 9th.

    Audit submissions

    As I’ve mentioned in previous updates, the GNOME Foundation is due to be audited very soon. This is a routine occurrence for non-profits like us, but this is our first formal audit, so there’s a good deal of learning and setup to be done.

    Last week was the deadline to submit all the documentation for the audit, which meant that many of us were extremely busy finalising numbers, filling in spreadsheets, and tidying up other documentation ready to send it all to the auditors.

    Our finance team *really* went the extra mile for us to get everything ready on time, so I’d like to give them a huge thank you for helping us out.

    The audit inspection itself will happen in the first week of March, so preparations continue, as we assemble and organise our records, update our policies, and so on.

    GUADEC 2026

    Planning for this summer’s conference has continued over the past two weeks. In case you missed it, the location and dates have been announced, and accommodation bookings are open at a reduced rate. In the background we are gearing up to open the call for papers, and the sponsorship effort is on its way. Now is a good time to start thinking about any talk proposals that you’d like to submit.

    Membership certificates

    A cool community effort is currently underway to provide certificates for GNOME Foundation members. This is a great idea in my opinion, as it will allow contributors to get official recognition which can be used for job applications and so on. More volunteers to help out would definitely be welcome.

    That’s it for this week. Thanks for reading, and feel free to ask questions in the comments.

    • chevron_right

      Andy Wingo: free trade and the left, bis: from cobden to lenin

      news.movim.eu / PlanetGnome • 5 days ago • 8 minutes

    A week ago we discussed free trade , and specifically took a look at the classical mechanism by which free trade is supposed to improve overall outcomes, as measured by GDP.

    As I described it, the value proposition of free trade is ambiguous at best: there is an intangible sense that a country might have a higher GDP with lower trade barriers, but with a side serving of misery as international competition forces some local industries to close, and without any guarantee about how that trade advantage would be distributed among the population. Why bother? And why is my news feed full of EU commissioners signing new trade agreements? Where are these ideas coming from?

    stave 2

    logo of the cobden club, with motto 'free trade, peace, goodwill among nations'

    I asked around, placed some orders, and a week later a copy of Marc-William Palen’s Pax Economica came in the mail. I was hoping for a definitive, reasoned argument for or against free trade, from a leftist’s perspective (whatever that means). The book was both more and less than that. Less, in the sense that its narrative is most tightly woven in the century before the end of the second World War, becoming loose and frayed as it breezes through decolonization, the rise of neoliberalism, the end of history, and what it describes as our current neomercantilist moment. Less, also, in that Palen felt no need to summarize the classic economic arguments for free trade, leaving me to clumsily do so in the previous stave . And yet, the story it tells fills in gaps in my understanding that I didn’t even know I had.

    To pick up one thread from the book, let’s go back to 1815. British parliament passes the Corn Laws , establishing a price floor for imported grain. This trade barrier essentially imposes a significant tax on all people who eat, to the profit of a small number of landowners. A movement to oppose these laws develops over the next 30 years, with Richard Cobden as its leading advocate. One of the arguments of the Anti-Corn Law League , which was actually a thing, is that cheaper food is good for workers; though wages might decline as bosses realize they don’t need to pay so much to keep their workers alive, relatively speaking workers will do better. More money left over at the end of the month also means more demand for other manufactured products, which is good for growing industry.

    In the end, bad harvests in 1845 led to shortages and famine ( yes, that one ) and eventually a full repeal of the laws in 1846. Perhaps the Anti-Corn Law League’s success was inevitable: a bad harvest year is a stochastic certainty, and not having enough food is the kind of problem no government can ignore. In any case, the episode does prove the Corn Laws to be a front in a class war, and their repeal was a victory for the left, even if it occured under a Conservative government, and even if the campaign was essentially middle-class Liberal in character.

    The repeal campaign was not just about domestic cost of living, however. Its exponents argued that free trade among nations was an essential step to a world of peaceful international cooperation. Palen’s book puts Cobden in context by comparison to Friedrich List, who, inspired by a stint in America in the 1820s, starts from the premise that for a nation to be great, it needs an empire of colonies to exploit, and to conquer and defend colonies, it needs a developed domestic industry and navy; and for a nation to develop its own industry, it needs protectionism. The natural state of empire is not exactly one of free trade with its neighbors.

    The “commercial peace” movement that Palen describes cuts List’s argument short at “empire”: because there is no empire without war, a peace movement should scratch away at the causes of war, and the causes of the causes; a world living in pax economica would avoid imperial conflict by tying nations together through trade. It sounds idealistic, and it is, but it’s easy to forget that today we wage war through trade also: blockades and sanctions are often followed by bombs. Palen’s book draws clear lines from Cobdenism through such disparate groups as women’s peace societies, Christian internationalists, pre-war German socialists, and Lenin himself.

    Marx understood history as a process of development, consisting of stages through which a society must necessarily pass on its way to socialism. This allies him with capitalism in many ways; he viewed free trade as a step towards a higher form of capitalism, which would necessarily lead to socialism. This, to me, is not a convincing argument in 2026: not only has the mechanistic vision of history failed to fruit, but its mechanism of plant closures and capital flight can be cruel and hard to campaign for politically. And yet, I think we do need a healthy dose of internationalism to remedy the ills of the present day: a jolt of ideals and even idealism to remind us that we are all travelling together on this spaceship Earth, and that those on the other side of a political line are just as much our brothers and sisters those on “our” side.

    i went seeking clarity

    When you tend Marxist, you know in your bones that although the road to socialism is rough and winding, the winds of history are always at your back; there is an in-baked inevitability of success that softens defeat. There is something similar in the Christian and feminist narrative strands that Palen weaves: a sense not that victory is inevitable, at least in this lifetime, but that fighting for it is a moral imperative, and that God is on your side. The campaign for free trade was a means to a moral end, one of international peace and shared prosperity. And this, in 2026, sounds... good, actually?

    Again from our 2026 perspective, I cannot help but agree that a trade barrier is often an act of war; preliminary, yes, but on the spectrum. I have had enough freedom fries in my life to have developed an allergy to anything that tastes of my-side-of-the-line-is-better-than-yours. Though I have not yet read Klein and Pettis’s deliciously titled Trade Wars are Class Wars , I do know that among the 1.5 million people who died as a result of the sanctions on Iraq in the 1990s , Saddam Hussein was not on the list. Sometimes I feel like we learned the lessons of Cobdenism backwards: in order to keep the people starving, we must impose anew the Corn Laws.

    Palen’s book leaves me with one doubt, and one big question. The doubt is, to what extent do the lessons of the early 1800s apply today? Ricardo’s contemporary comparative advantage theories presupposed that capital was relatively fixed in space; nowadays this is much less the case. The threat of moving the plant elsewhere is always present in all union drives everywhere. Though history rhymes, it does not repeat; it will take some creativity to transplant pax economica to the soils of the 21st century.

    The bigger question, though, is as regards the morality of protectionism as practiced by more and less developed economies: when is it morally right for a country to erect trade barriers? Palen’s book does not pretend to answer this question. And yet, this issue was foremost in our minds, as we shut down Seattle in 1999, as we died in Genoa in 2001. (Forgive the collectivism, if you aren’t of this tribe (yet?), but it was a lived experience.) Free trade was a moral cause in 1835; how did it become immoral in 1995, at least to us?

    world without end

    Well. To answer that question, we need a history that picks up where Palen leaves off, and we have something like it in Quinn Slobodian’s Globalists , which we will look at next time. But before we go, two reflections.

    One, in Europe we have kept the Corn Laws on the books, in a way, in the form of the EU Common Agricultural Policy (CAP). In France the dominant discourse is very much in opposition to the free trade agreement with Mercosur, and the main reason is the threat to French farmers. The tradeoff to get the Mercosur agreement over the line were additional subsidies under the CAP, which are a form of trade barrier. And yet, the way the CAP is structured allocates most of the money in proportion to the surface area of a farm, which is to say, to the largest agribusinesses and to the largest landowners. Greenpeace just put out an excellent briefing arguing that the CAP is just a subsidy to the heirs of the Duchess of Alba and their ilk . Again, are we running the 19th century in reverse?

    Secondly, and harder to explain... in the 2000s I listened a lot to an anarchist radio show hosted by Lyn Gerry, Unwelcome Guests . (Have you heard the eponymous tune? It makes me shiver every time.) Anyway I remember one episode which discussed the gift economy and hunter-gather economics, in which a researcher asked a member of that community what he would do if he came into a lot of food at one time: the response, as I recall, was that he would store it “in his brother”. He would give it to others. One day, if he needed it, they would give to him.

    I know that our world does not work this way, but there is an element of truth here, in that it’s not reasonable for France to grow everything that it eats, to never trade what it grows, to make all its own solar panels, to write all software used within its borders. We live richer lives when we share and learn from each other, without regards to which side of the line our home is.

    next

    Still here? Gosh me too. Next time we will look at what the kids call the “1900s” and perhaps approach present day. Until then, commercial peace be with you!

    • chevron_right

      Adrian Vovk: GNOME OS Hackfest @ FOSDEM 2026

      news.movim.eu / PlanetGnome • 5 days ago • 4 minutes

    For a few days leading up to FOSDEM 2026, the GNOME OS developers met for a GNOME OS hackfest. Here are some of the things we talked about!

    Stable

    The first big topic on our to-do list was GNOME OS stable. We started by defining the milestone: we can call GNOME OS “stable” when we settle on a configuration that we’re willing to support long-term. The most important blocker here is systemd-homed : we know that we want the stable release of GNOME OS to use systemd-homed , and we don’t want to have to support pre-homed GNOME OS installations forever. We discussed the possiblity of building a migration script to move people onto systemd-homed once it’s ready, but it’s simply too difficult and dangerous to deploy this in practice.

    We did, however, agree that we can already start promoting GNOME OS a bit more heavily, provided that we make very clear that this is an unstsable product for very early adopters, who would be willing to occasionally reinstall their system (or manually migrate it).

    We also discussed the importance of project documentation. GNOME OS’s documentation isn’t in a great state at the moment, and this makes it especially difficult to start contributing. BuildStream , which is GNOME OS’s build system, has a workflow that is unfamiliar to most people that may want to contribute. Despite its comprehensive documentation, there’s no easy “quick start” reference for the most common tasks and so it is ultimately a source of friction for potential contributors. This is especially unfourtunate given the current excitement around building next-gen “distroless” operating systems. Our user documentation is also pretty sparse. Finally, the little documentation we do have is spread across different places (markdown comitted to git, GitLab Wiki pages, the GNOME OS website, etc) and this makes it very difficult for people to find it.

    Fixing /etc

    Next we talked about the situation with /etc on GNOME OS. /etc has been a bit of an unsolved problem in the UAPI group’s model of immutability : ideally all default configuration can be loaded from /usr , and so /etc would remain entirely for overrides by the system administrator. Unfourtunately, this isn’t currently the case , so we must have some solution to keep track of both upstream defaults and local changes in /etc .

    So far, GNOME OS had a complicated set-up where parts of /usr would be symlinked into /etc . To change any of these files, the user would have to break the symlinks and replace them with normal files, potentially requiring copies of entire directories. This would then cause loads of issues, where the broken symlinks cause /etc to slowly drift away from the changing defaults in /usr .

    For years, we’ve known that the solution would be overlayfs . This kernel filesystem allows us to mount the OS’s defaults underneath a writable layer for administrator overrides. For various reasons, however, we’ve struggled to deploy this in practice.

    Modern systemd has native support for this arrangement via systemd-confext , and we decided to just give it a try at the hackfest. A few hours later, Valentin had a merge request to transition us to the new scheme. We’ve now fully rolled this out, and so the issue is solved in the latest GNOME OS nightlies.

    FEX and Flatpak

    Next, we discussed integrating FEX with Flatpak so that we can run x86 apps on ARM64 devices.

    Abderrahim kicked off the topic by telling us about fexwrap , a script that grafts two different Flatpak runtimes together to successfully run apps via FEX. After studying this implementation, we discussed what proper upstream support might look like.

    Ultimately, we decided that the first step will be a new Flatpak runtime extension that bundles FEX, the required extra libraries, and the “thunks” (glue libraries that let x86 apps call into native ARM GPU drivers). From there, we’ll have to experiment and see what integrations Flatpak itself needs to make everything work seamlessly.

    Abderrahim has already started hacking on this upstream.

    Amutable

    The Amutable crew were in Brussels for FOSDEM, and a few of them stopped in to attend our hackfest. We had some very interesting conversations! From a GNOME OS perspective, we’re quite excited about the potential overlap between our work and theirs.

    We also used the opportunity to discuss GNOME OS, of course! For instance, we were able to resolve some kernel VFS blockers for GNOME OS delta updates and Flatpak v2.

    mkosi

    For a few years, we’ve been exploring ways to factor out GNOME OS’s image build scripts into a reusable component. This would make it trivial for other BuildStream-based projects to distribute themselves as UAPI.3 DDIs . It would also allow us to ship device-specific builds of GNOME OS, which are necessary to target mobile devices like the Fairphone 5.

    At Boiling the Ocean 7 , we decided to try an alternative approach. What if we could drop our bespoke image build steps, and just use mkosi ? There, we threw together a prototype and successfully booted to login . With the concept proven, I put together a better prototype in the intervening months. This prompted a discussion with Daan, the maintainer of mkosi, and we ultimately decided that mkosi should just have native BuildStream support upstream.

    At the hackfest, Daan put together a prototype for this native support. We were able to use his modified build of mkosi to build a freedesktop-sdk BuildStream image, package it up as a DDI, boot it in a virtual machine, set the machine up via systemd-firstboot , and log into a shell. Daan has since opened a pull request , and we’ll continue iterating on this approach in the coming months.


    Overall, this hackfest was extremely productive! I think it’s pretty likely that we’ll organize something like this again next year!

    • chevron_right

      Andy Wingo: two mechanisms for dynamic type checks

      news.movim.eu / PlanetGnome • 5 days ago • 3 minutes

    Today, a very quick note on dynamic instance type checks in virtual machines with single inheritance.

    The problem is that given an object o whose type is t , you want to check if o actually is of some more specific type u . To my knowledge, there are two sensible ways to implement these type checks.

    if the set of types is fixed: dfs numbering

    Consider a set of types T := { t , u , ...} and a set of edges S := {< t |ε, u >, ...} indicating that t is the direct supertype of u , or ε if u is a top type. S should not contain cycles and is thus a direct acyclic graph rooted at ε.

    First, compute a pre-order and post-order numbering for each t in the graph by doing a depth-first search over S from ε. Something like this:

    def visit(t, counter):
        t.pre_order = counter
        counter = counter + 1
        for u in S[t]:
            counter = visit(u, counter)
        t.post_order = counter
        return counter
    

    Then at run-time, when making an object of type t , you arrange to store the type’s pre-order number (its tag ) in the object itself. To test if the object is of type u , you extract the tag from the object and check if tag u .pre_order mod 2 n < u .post_order– u .pre_order.

    Two notes, probably obvious but anyway: one, you know the numbering for u at compile-time and so can embed those variables as immediates. Also, if the type has no subtypes, it can be a simple equality check.

    Note that this approach applies only if the set of types T is fixed. This is the case when statically compiling a WebAssembly module in a system that doesn’t allow modules to be instantiated at run-time, like Wastrel . Interestingly, it can also be the case in JIT compilers, when modeling types inside the optimizer .

    if the set of types is unbounded: the display hack

    If types may be added to a system at run-time, maintaining a sorted set of type tags may be too much to ask. In that case, the standard solution is something I learned of as the display hack , but whose name is apparently ungooglable. It is described in a 4-page technical note by Norman H. Cohen, from 1991: Type-Extension Type Tests Can Be Performed In Constant Time .

    The basic idea is that each type t should have an associated sorted array of supertypes, starting with its top type and ending with t itself. Each t also has a depth , indicating the number of edges between it and its top type. A type u is a subtype of t if u [ t .depth]= t , if u .depth <= t .depth.

    There are some tricks one can do to optimize out the depth check, but it’s probably a wash given the check performs a memory access or two on the way. But the essence of the whole thing is in Cohen’s paper; go take a look!

    Jan Vitek notes in a followup paper ( Efficient Type Inclusion Tests ) that Christian Queinnec discovered the technique around the same time. Vitek also mentions the DFS technique, but as prior art, apparently already deployed in DEC Modula-3 systems. The term “display” was bouncing around in the 80s to describe some uses of arrays; I learned it from Dybvig’s implementation of flat closures, who learned it from Cardelli. I don’t know though where “display hack” comes from.

    That’s it! If you know of any other standard techniques for type checks with single-inheritance subtyping, do let me know in the comments. Until next time, happy hacking!

    • chevron_right

      Jonathan Blandford: Crosswords 0.3.17: Circle Bound

      news.movim.eu / PlanetGnome • 16 February 2026 • 5 minutes

    It’s time for another Crosswords release. This is relatively soon after the last one, but I have an unofficial rule that Crosswords is released after three bloggable features. We’ve been productive and blown way past that bar in only a few months, so it’s time for an update.

    This round, we redid the game interface (for GNOME Circle) and added content to the editor. The editor also gained printing support, and we expanded support for Adwaita accent colors. In details:

    New Layout

    GNOME Crosswords' new look — using the accent color GNOME Crosswords’ new look — now using the accent color

    I applied for GNOME Circle a couple years ago, but it wasn’t until this past GUADEC that I was able to sit down together with Tobias to take a closer look at the game. We sketched out a proposed redesign, and I’ve been implementing it for the last four months. The result: a much cleaner look and workflow. I really like the way it has grown.

    Initial redesign

    Overall, I’m really happy with the way it looks and feels so far. The process has been relatively smooth ( details ), though it’s clear that the design team has limited resources to spend on these efforts. They need more help, and I hope that team can grow. Here’s how the game looks now:

    I really could use help with the artwork for this project! Jakub made some sketches and I tried to convert them to svg, but have reached the limits of my inkscape skills. If you’re interested in helping and want to get involved in GNOME Design artwork, this could be a great place to start. Let me know!

    Indicator Hints

    Time for some crossword nerdery:

    Indicator Hints Dialog Main Screen

    One thing that characterizes cryptic crosswords is that its clues feature wordplay. A key part of the wordplay is called an “indicator hint” . These hints are a word — or words — that tell you to transform neighboring words into parts of the solutions. These transformations could be things like rearranging the letters (anagrams) or reversing them. The example in the dialog screenshot below might give a better sense of how these work. There’s a whole universe built around this.

    Indicator Hint Dialog with an example

    Good clues always use evocative indicator hints to entertain or mislead the solver. To help authors, I install a database of common indicator hints compiled by George Ho and show a random subset. His list also includes how frequently they’re used, which can be used to make a clue harder or easier to solve.

    Indicator Hints Dialog with full list of indicators

    Templates and Settability

    I’ve always been a bit embarrassed about the New Puzzle dialog. The dialog should be simple enough: select a puzzle type, puzzle size, and maybe a preset grid template . Unfortunately, it historically had a few weird bugs and the template thumbnailing code was really slow.  It could only render twenty or so templates before the startup time became unbearable. As a result, I only had a pitiful four or five templates per type of puzzle.

    When Toluwaleke rewrote the thumbnail rendering to be blazing fast over the summer, it became possible to give this section a closer look. The result:

    Note: The rendering issues with the theme words dialog is GTK Bug #7400

    The new dialog now has almost a thousand curated blank grids to pick from, sorted by how difficult they are to fill. In addition, I added initial support to add Theme Words to the puzzle. Setting theme words will also filter the templates to only show those that fit. Some cool technical details:

    • The old dialog would load the ipuz files, convert them to svg, then render them to Pixbuf. That had both json + xml parse trees to navigate, plus a pixbuf transition. It was all inherently slow. I’ve thrown all that out.
    • The new code takes advantage of the fact that crossword grids are effectively bitfields: at build time I convert each row in a grid template into a u32 with each bit representing a block. That means that each crossword grid can be stored as an array of these u32s . We use GResource and GVariant to load this file, so it’s mmapped and effectively instant to parse. At this point, the limiting factor in adding additional blank templates is curation/generation.
    • As part of this, I developed a concept called “ settability” ( documentation ) to capture how easy or hard it is to fill in a grid. We use this to sort the grids, and to warn the user should they choose a harder grid. It’s a heuristic, but it feels pretty good to me. You can see it in the video in the sort order of the grids.

    User Testing

    I had the good fortune to be able to sit with one of my coworkers and watch her use the editor. She’s a much more accomplished setter than I, and publishes her crosswords in newspapers. Watching her use the tool was really helpful as she highlighted a lot of issues with the application ( list ). It was also great to validate a few of my big design decisions, notably splitting grid creation from clue writing.

    I’ve fixed most of the  easy issues she found, but she confirmed something I suspected: The big missing feature for the editor is an overlay indicating tricky cells and dead ends ( bug ). Victor proposed a solution ( link ) for this over the summer. This is now the top priority for the next release.

    Thanks

    • George for his fabulous database of indicator words
    • Tobias for tremendous design work
    • Jakub for artwork sketches and ideas
    • Sophia for user feedback with the editor
    • Federico for a lot of useful advice, CI fixes, and cleanups
    • Vinson for build fixes and sanitation
    • Nicole for some game papercut fixes
    • Toluwaleke for printing advice and fixes
    • Rosanna for text help and encouragement/advice
    • Victor for cleaning up the docs

    Until next time!

    • chevron_right

      Jussi Pakkanen: What's cooking with Pystd, the experimental C++ standard library?

      news.movim.eu / PlanetGnome • 14 February 2026 • 2 minutes

    Pystd is an experiment on what a C++ standard library without any backwards compatibility requirements would look like. It's design goals are in order of decreasing priority:

    • Fast build times
    • Simplicity of implementation
    • Good performance
    It also has some design-antigoals:

    • Not compatible with the ISO C++ standard library
    • No support for weird corner cases like linked lists or types that can't be noexcept-moved
    • Do not reinvent things that are already in the C standard library (though you might provide a nicer UI to them)

    Current status

    There is a bunch of stuff implemented, like vector, several string types, hashmap, a B-tree based ordered map, regular expressions, unix path manipulation operations and so on. The latest addition has been sort algorithms, which include merge sort, heap sort and introsort.

    None of these is "production quality". They will almost certainly have bugs. Don't rely on them for "real work".

    The actual library consists of approximately 4800 lines of headers and 4700 lines of source. Building the library and all test code on a Raspberry Pi using a single core takes 13 seconds. With 30 process invocations this means approximately 0.4 seconds per compilation.

    For real world testing we have really only one data point , but in it build time was reduced by three quarters, the binary became smaller and the end result ran faster.

    Portability

    The code has been tested on Linux x86_64 and aarch64 as well as on macOS. It currently does not work with Visual Studio which has not implemented support for pack indexing yet.

    Why should you consider using it?

    Back in the 90s and 00s (I think) it was fashionable to write your own C++ standard library implementation. Eventually they have all died and people have moved to the one that comes with their compiler. Which is totally reasonable. So why would you now switch to something else?

    For existing C++ applications you probably don't want to. The amount of work needed for a port is too much to be justified in most cases.

    For green field projects things are more interesting. Maybe you just want to try something new just for the fun of it? That is the main reason why Pystd even exists, I wanted to try implementing the core building blocks of a standard library from scratch.

    Maybe you want to provide "Go style" binaries that build fast and have no external deps? The size overhead of Pystd is only a few hundred k and they only depend on libc (unless you use regexes, in which case they depend on libpcre, but you can static link it if you prefer).

    Resource constrained or embedded systems might also be an option. Libstdc++ takes a few megabytes. Pystd does require malloc, though (more specifically it requires aligned alloc) so for the smallest embedded targets you'd need to use something like the freestanding library. As an additional feature Pystd permits you to disable parts of the library that are not used (currently only regexes, but could be extended to things like threading and file system).

    Compiler implementers might choose to test their performance with an unusual code base. For example GCC compiles most Pystd files in a flash but for some reason the B-tree implementation takes several seconds to build. I don't really know why because it does not do any heavy duty metaprogramming or such.

    It might also be usable in teaching as a fairly small implementation of the core algorithms used today. Assuming anyone does education any more as opposed to relying on LLMs for everything.