call_end

    • chevron_right

      Engagement Team: GNOME ASIA 2025-Event Report

      news.movim.eu / PlanetGnome • 9 January 2026 • 1 minute

    GNOME ASIA 2025 took place in Tokyo, Japan, from 13–14 December 2025 , bringing together the GNOME community for the featured annual GNOME conference in Asia.
    The event was held in a hybrid format, welcoming both in-person and online speakers and attendees from across the world.

    GNOME ASIA 2025 was co-hosted with the LibreOffice Asia Conference community event , creating a shared space for collaboration and discussion between open-source communities.

    Photo by Tetsuji Koyama, licensed under CC BY 4.0

    About GNOME.Asia Summit

    The GNOME.Asia Summit focuses primarily on the GNOME desktop while also covering applications and platform development tools. It brings together users, developers, foundation leaders, governments, and businesses in Asia to discuss current technologies and future developments within the GNOME ecosystem.

    The event featured 25 speakers in total , delivering 17 full talks and 8 lightning talks across the two days. Speakers joined both on-site and remotely.

    Photo by Tetsuji Koyama, licensed under CC BY 4.0

    Around 100 participants attended in person in Tokyo, contributing to engaging discussions and community interaction. Session recordings were published on the GNOME Asia YouTube channel , where they have received 1,154 total views , extending the reach of the event beyond the conference dates.

    With strong in-person attendance, active online participation, and collaboration with the LibreOffice Asia community, GNOME ASIA 2025 once again demonstrated the importance of regional gatherings in strengthening the GNOME ecosystem and open-source collaboration in Asia.

    Photo by Tetsuji Koyama, licensed under CC BY 4.0

    • chevron_right

      Daiki Ueno: GNOME.Asia Summit 2025

      news.movim.eu / PlanetGnome • 7 January 2026 • 2 minutes

    Last month, I attended the GNOME.Asia Summit 2025 held at the IIJ office in Tokyo. This was my fourth time attending the summit, following previous events in Taipei (2010), Beijing (2015), and Delhi (2016).

    As I live near Tokyo, this year’s conference was a unique experience for me: an opportunity to welcome the international GNOME community to my home city rather than traveling abroad. Reconnecting with the community after several years provided a helpful perspective on how our ecosystem has evolved.

    Addressing the post-quantum transition

    During the summit, I delivered a keynote address regarding post-quantum cryptography (PQC) and desktop. The core of my presentation focused on the “Harvest Now, Decrypt Later” (HNDL) type of threats, where encrypted data is collected today with the intent of decrypting it once quantum computing matures. The talk was followed by the history and the current status of PQC support in crypto libraries including OpenSSL, GnuTLS, and NSS, and concluded with the next steps recommended for the users and developers.

    It is important to recognize that classical public key cryptography, which is vulnerable to quantum attacks, is integrated into nearly every aspect of the modern desktop: from secure web browsing and apps using libsoup (Maps, Weather, etc.) to the underlying verification of system updates. Given that major government timelines (such as NIST and the NSA’s CNSA 2.0 ) are pushing for a full migration to quantum-resistant algorithms between 2027 and 2035, the GNU/Linux desktop should prioritize “crypto-agility” to remain secure in the coming decade.

    From discussion to implementation: Crypto Usage Analyzer

    One of the tools I discussed during my talk was crypto-auditing , a project designed to help developers identify and update the legacy cryptography usage. At the time of the summit, the tool was limited to a command-line interface, which I noted was a barrier to wider adoption.

    Inspired by the energy of the summit, I spent part of the recent holiday break developing a GUI for crypto-auditing. By utilizing AI-assisted development tools, I was able to rapidly prototype an application, which I call “Crypto Usage Analyzer” , that makes the auditing data more accessible.

    Conclusion

    The summit in Tokyo had a relatively small audience, which resulted in a cozy and professional atmosphere. This smaller scale proved beneficial for technical exchange, as it allowed for focused discussions on desktop-related topics than is often possible at larger conferences.

    Attending GNOME.Asia 2025 was a reminder of the steady work required to keep the desktop secure and relevant. I appreciate the efforts of the organizing committee in bringing the summit to Tokyo, and I look forward to continuing my work on making security libraries and tools more accessible for our users and developers.

    • chevron_right

      Sebastian Wick: Improving the Flatpak Graphics Drivers Situation

      news.movim.eu / PlanetGnome • 5 January 2026 • 6 minutes

    Graphics drivers in Flatpak have been a bit of a pain point. The drivers have to be built against the runtime to work in the runtime. This usually isn’t much of an issue but it breaks down in two cases:

    1. If the driver depends on a specific kernel version
    2. If the runtime is end-of-life (EOL)

    The first issue is what the proprietary Nvidia drivers exhibit. A specific user space driver requires a specific kernel driver. For drivers in Mesa, this isn’t an issue. In the medium term, we might get lucky here and the Mesa-provided Nova driver might become competitive with the proprietary driver. Not all hardware will be supported though, and some people might need CUDA or other proprietary features, so this problem likely won’t go away completely.

    Currently we have runtime extensions for every Nvidia driver version which gets matched up with the kernel version, but this isn’t great.

    The second issue is even worse, because we don’t even have a somewhat working solution to it. A runtime which is EOL doesn’t receive updates, and neither does the runtime extension providing GL and Vulkan drivers. New GPU hardware just won’t be supported and the software rendering fallback will kick in.

    How we deal with this is rather primitive: keep updating apps, don’t depend on EOL runtimes. This is in general a good strategy. A EOL runtime also doesn’t receive security updates, so users should not use them. Users will be users though and if they have a goal which involves running an app which uses an EOL runtime, that’s what they will do. From a software archival perspective, it is also desirable to keep things working, even if they should be strongly discouraged.

    In all those cases, the user most likely still has a working graphics driver, just not in the flatpak runtime, but on the host system. So one naturally asks oneself: why not just use that driver?

    That’s a load-bearing “just”. Let’s explore our options.

    Exploration

    Attempt #1: Bind mount the drivers into the runtime.

    Cool, we got the driver’s shared libraries and ICDs from the host in the runtime. If we run a program, it might work. It might also not work. The shared libraries have dependencies and because we are in a completely different runtime than the host, they most likely will be mismatched. Yikes.

    Attempt #2: Bind mount the dependencies.

    We got all the dependencies of the driver in the runtime. They are satisfied and the driver will work. But your app most likely won’t. It has dependencies that we just changed under its nose. Yikes.

    Attempt #3: Linker magic.

    Until here everything is pretty obvious, but it turns out that linkers are actually quite capable and support what’s called linker namespaces . In a single process one can load two completely different sets of shared libraries which will not interfere with each other. We can bind mount the host shared libraries into the runtime, and dlmopen the driver into its own namespace. This is exactly what libcapsule does. It does have some issues though, one being that the libc can’t be loaded into multiple linker namespaces because it manages global resources. We can use the runtime’s libc, but the host driver might require a newer libc. We can use the host libc, but now we contaminate the apps linker namespace with a dependency from the host.

    Attempt #4: Virtualization.

    All of the previous attempts try to load the host shared objects into the app. Besides the issues mentioned above, this has a few more fundamental issues:

    1. The Flatpak runtimes support i386 apps; those would require a i386 driver on the host, but modern systems only ship amd64 code.
    2. We might want to support emulation of other architectures later
    3. It leaks an awful lot of the host system into the sandbox
    4. It breaks the strict separation of the host system and the runtime

    If we avoid getting code from the host into the runtime, all of those issues just go away, and GPU virtualization via Virtio-GPU with Venus allows us to do exactly that.

    The VM uses the Venus driver to record and serialize the Vulkan commands, sends them to the hypervisor via the virtio-gpu kernel driver. The host uses virglrenderer to deserializes and executes the commands.

    This makes sense for VMs, but we don’t have a VM, and we might not have the virtio-gpu kernel module, and we might not be able to load it without privileges. Not great.

    It turns out however that the developers of virglrenderer also don’t want to have to run a VM to run and test their project and thus added vtest, which uses a unix socket to transport the commands from the mesa Venus driver to virglrenderer.

    It also turns out that I’m not the first one who noticed this, and there is some glue code which allows Podman to make use of virgl .

    You can most likely test this approach right now on your system by running two commands:

    rendernodes=(/dev/dri/render*)
    virgl_test_server --venus --use-gles --socket-path /tmp/flatpak-virgl.sock --rendernode "${rendernodes[0]}" &
    flatpak run --nodevice=dri --filesystem=/tmp/flatpak-virgl.sock --env=VN_DEBUG=vtest --env=VTEST_SOCKET_NAME=/tmp/flatpak-virgl.sock org.gnome.clocks
    

    If we integrate this well, the existing driver selection will ensure that this virtualization path is only used if there isn’t a suitable driver in the runtime.

    Implementation

    Obviously the commands above are a hack. Flatpak should automatically do all of this, based on the availability of the dri permission.

    We actually already start a host program and stop it when the app exits: xdg-dbus-proxy . It’s a bit involved because we have to wait for the program (in our case virgl_test_server ) to provide the service before starting the app. We also have to shut it down when the app exits, but flatpak is not a supervisor. You won’t see it in the output of ps because it just execs bubblewrap ( bwrap ) and ceases to exist before the app even started. So instead we have to use the kernel’s automatic cleanup of kernel resources to signal to virgl_test_server that it is time to shut down.

    The way this is usually done is via a so called sync fd . If you have a pipe and poll the file descriptor of one end, it becomes readable as soon as the other end writes to it, or the file description is closed. Bubblewrap supports this kind of sync fd : you can hand in a one end of a pipe and it ensures the kernel will close the fd once the app exits.

    One small problem: only one of those sync fds is supported in bwrap at the moment, but we can add support for multiple in Bubblewrap and Flatpak .

    For waiting for the service to start, we can reuse the same pipe, but write to the other end in the service, and wait for the fd to become readable in Flatpak, before exec’ing bwrap with the same fd. Also not too much code .

    Finally, virglrenderer needs to learn how to use a sync fd . Also pretty trivial . There is an older MR which adds something similar for the Podman hook, but it misses the code which allows Flatpak to wait for the service to come up, and it never got merged.

    Overall, this is pretty straight forward.

    Conclusion

    The virtualization approach should be a robust fallback for all the cases where we don’t get a working GPU driver in the Flatpak runtime, but there are a bunch of issues and unknowns as well.

    It is not entirely clear how forwards and backwards compatible vtest is, if it even is supposed to be used in production, and if it provides a strong security boundary.

    None of that is a fundamental issue though and we could work out those issues.

    It’s also not optimal to start virgl_test_server for every Flatpak app instance.

    Given that we’re trying to move away from blanket dri access to a more granular and dynamic access to GPU hardware via a new daemon , it might make sense to use this new daemon to start the virgl_test_server on demand and only for allowed devices.

    • chevron_right

      Matthew Garrett: What is a PC compatible?

      news.movim.eu / PlanetGnome • 4 January 2026 • 12 minutes

    Wikipedia says “An IBM PC compatible is any personal computer that is hardware- and software-compatible with the IBM Personal Computer (IBM PC) and its subsequent models” . But what does this actually mean? The obvious literal interpretation is for a device to be PC compatible, all software originally written for the IBM 5150 must run on it. Is this a reasonable definition? Is it one that any modern hardware can meet?

    Before we dig into that, let’s go back to the early days of the x86 industry. IBM had launched the PC built almost entirely around off-the-shelf Intel components, and shipped full schematics in the IBM PC Technical Reference Manual . Anyone could buy the same parts from Intel and build a compatible board. They’d still need an operating system, but Microsoft was happy to sell MS-DOS to anyone who’d turn up with money. The only thing stopping people from cloning the entire board was the BIOS, the component that sat between the raw hardware and much of the software running on it. The concept of a BIOS originated in CP/M , an operating system originally written in the 70s for systems based on the Intel 8080. At that point in time there was no meaningful standardisation - systems might use the same CPU but otherwise have entirely different hardware, and any software that made assumptions about the underlying hardware wouldn’t run elsewhere. CP/M’s BIOS was effectively an abstraction layer, a set of code that could be modified to suit the specific underlying hardware without needing to modify the rest of the OS. As long as applications only called BIOS functions, they didn’t need to care about the underlying hardware and would run on all systems that had a working CP/M port.

    By 1979, boards based on the 8086, Intel’s successor to the 8080, were hitting the market. The 8086 wasn’t machine code compatible with the 8080, but 8080 assembly code could be assembled to 8086 instructions to simplify porting old code. Despite this, the 8086 version of CP/M was taking some time to appear, and a company called Seattle Computer Products started producing a new OS closely modelled on CP/M and using the same BIOS abstraction layer concept. When IBM started looking for an OS for their upcoming 8088 (an 8086 with an 8-bit data bus rather than a 16-bit one) based PC, a complicated chain of events resulted in Microsoft paying a one-off fee to Seattle Computer Products, porting their OS to IBM’s hardware, and the rest is history.

    But one key part of this was that despite what was now MS-DOS existing only to support IBM’s hardware, the BIOS abstraction remained, and the BIOS was owned by the hardware vendor - in this case, IBM. One key difference, though, was that while CP/M systems typically included the BIOS on boot media, IBM integrated it into ROM. This meant that MS-DOS floppies didn’t include all the code needed to run on a PC - you needed IBM’s BIOS. To begin with this wasn’t obviously a problem in the US market since, in a way that seems extremely odd from where we are now in history, it wasn’t clear that machine code was actually copyrightable. In 1982 Williams v. Artic determined that it could be even if fixed in ROM - this ended up having broader industry impact in Apple v. Franklin and it became clear that clone machines making use of the original vendor’s ROM code wasn’t going to fly. Anyone wanting to make hardware compatible with the PC was going to have to find another way.

    And here’s where things diverge somewhat. Compaq famously performed clean-room reverse engineering of the IBM BIOS to produce a functionally equivalent implementation without violating copyright. Other vendors, well, were less fastidious - they came up with BIOS implementations that either implemented a subset of IBM’s functionality, or didn’t implement all the same behavioural quirks, and compatibility was restricted. In this era several vendors shipped customised versions of MS-DOS that supported different hardware (which you’d think wouldn’t be necessary given that’s what the BIOS was for, but still), and the set of PC software that would run on their hardware varied wildly. This was the era where vendors even shipped systems based on the Intel 80186 , an improved 8086 that was both faster than the 8086 at the same clock speed and was also available at higher clock speeds. Clone vendors saw an opportunity to ship hardware that outperformed the PC, and some of them went for it.

    You’d think that IBM would have immediately jumped on this as well, but no - the 80186 integrated many components that were separate chips on 8086 (and 8088) based platforms, but crucially didn’t maintain compatibility. As long as everything went via the BIOS this shouldn’t have mattered, but there were many cases where going via the BIOS introduced performance overhead or simply didn’t offer the functionality that people wanted, and since this was the era of single-user operating systems with no memory protection, there was nothing stopping developers from just hitting the hardware directly to get what they wanted. Changing the underlying hardware would break them.

    And that’s what happened. IBM was the biggest player, so people targeted IBM’s platform. When BIOS interfaces weren’t sufficient they hit the hardware directly - and even if they weren’t doing that, they’d end up depending on behavioural quirks of IBM’s BIOS implementation. The market for DOS-compatible but not PC-compatible mostly vanished, although there were notable exceptions - in Japan the PC-98 platform achieved significant success, largely as a result of the Japanese market being pretty distinct from the rest of the world at that point in time, but also because it actually handled Japanese at a point where the PC platform was basically restricted to ASCII or minor variants thereof.

    So, things remained fairly stable for some time. Underlying hardware changed - the 80286 introduced the ability to access more than a megabyte of address space and would promptly have broken a bunch of things except IBM came up with an utterly terrifying hack that bit me back in 2009 , and which ended up sufficiently codified into Intel design that it was one mechanism for breaking the original XBox security . The first 286 PC even introduced a new keyboard controller that supported better keyboards but which remained backwards compatible with the original PC to avoid breaking software. Even when IBM launched the PS/2, the first significant rearchitecture of the PC platform with a brand new expansion bus and associated patents to prevent people cloning it without paying off IBM, they made sure that all the hardware was backwards compatible. For decades, PC compatibility meant not only supporting the officially supported interfaces, it meant supporting the underlying hardware. This is what made it possible to ship install media that was expected to work on any PC, even if you’d need some additional media for hardware-specific drivers. It’s something that still distinguishes the PC market from the ARM desktop market. But it’s not as true as it used to be, and it’s interesting to think about whether it ever was as true as people thought.

    Let’s take an extreme case. If I buy a modern laptop, can I run 1981-era DOS on it? The answer is clearly no. First, modern systems largely don’t implement the legacy BIOS. The entire abstraction layer that DOS relies on isn’t there, having been replaced with UEFI. When UEFI first appeared it generally shipped with a Compatibility Services Module, a layer that would translate BIOS interrupts into UEFI calls, allowing vendors to ship hardware with more modern firmware and drivers without having to duplicate them to support older operating systems 1 . Is this system PC compatible? By the strictest of definitions, no.

    Ok. But the hardware is broadly the same, right? There’s projects like CSMWrap that allow a CSM to be implemented on top of stock UEFI, so everything that hits BIOS should work just fine. And well yes, assuming they implement the BIOS interfaces fully, anything using the BIOS interfaces will be happy. But what about stuff that doesn’t? Old software is going to expect that my Sound Blaster is going to be on a limited set of IRQs and is going to assume that it’s going to be able to install its own interrupt handler and ACK those on the interrupt controller itself and that’s really not going to work when you have a PCI card that’s been mapped onto some APIC vector, and also if your keyboard is attached via USB or SPI then reading it via the CSM will work (because it’s calling into UEFI to get the actual data) but trying to read the keyboard controller directly won’t 2 , so you’re still actually relying on the firmware to do the right thing but it’s not, because the average person who wants to run DOS on a modern computer owns three fursuits and some knee length socks and while you are important and vital and I love you all you’re not enough to actually convince a transglobal megacorp to flip the bit in the chipset that makes all this old stuff work.

    But imagine you are, or imagine you’re the sort of person who (like me) thinks writing their own firmware for their weird Chinese Thinkpad knockoff motherboard is a good and sensible use of their time - can you make this work fully? Haha no of course not. Yes, you can probably make sure that the PCI Sound Blaster that’s plugged into a Thunderbolt dock has interrupt routing to something that is absolutely no longer an 8259 but is pretending to be so you can just handle IRQ 5 yourself, and you can probably still even write some SMM code that will make your keyboard work, but what about the corner cases? What if you’re trying to run something built with IBM Pascal 1.0 ? There’s a risk that it’ll assume that trying to access an address just over 1MB will give it the data stored just above 0, and now it’ll break. It’d work fine on an actual PC, and it won’t work here, so are we PC compatible?

    That’s a very interesting abstract question and I’m going to entirely ignore it. Let’s talk about PC graphics 3 . The original PC shipped with two different optional graphics cards - the Monochrome Display Adapter and the Color Graphics Adapter . If you wanted to run games you were doing it on CGA, because MDA had no mechanism to address individual pixels so you could only render full characters. So, even on the original PC, there was software that would run on some hardware but not on other hardware.

    Things got worse from there. CGA was, to put it mildly, shit. Even IBM knew this - in 1984 they launched the PCjr , intended to make the PC platform more attractive to home users. As well as maybe the worst keyboard ever to be associated with the IBM brand, IBM added some new video modes that allowed displaying more than 4 colours on screen at once 4 , and software that depended on that wouldn’t display correctly on an original PC. Of course, because the PCjr was a complete commercial failure, it wouldn’t display correctly on any future PCs either. This is going to become a theme.

    There’s never been a properly specified PC graphics platform. BIOS support for advanced graphics modes 5 ended up specified by VESA rather than IBM, and even then getting good performance involved hitting hardware directly. It wasn’t until Microsoft specced DirectX that anything was broadly usable even if you limited yourself to Microsoft platforms, and this was an OS-level API rather than a hardware one. If you stick to BIOS interfaces then CGA-era code will work fine on graphics hardware produced up until the 20-teens, but if you were trying to hit CGA hardware registers directly then you’re going to have a bad time. This isn’t even a new thing - even if we restrict ourselves to the authentic IBM PC range (and ignore the PCjr), by the time we get to the Enhanced Graphics Adapter we’re not entirely CGA compatible . Is an IBM PC/AT with EGA PC compatible? You’d likely say “yes”, but there’s software written for the original PC that won’t work there.

    And, well, let’s go even more basic. The original PC had a well defined CPU frequency and a well defined CPU that would take a well defined number of cycles to execute any given instruction. People could write software that depended on that. When CPUs got faster, some software broke. This resulted in systems with a Turbo Button - a button that would drop the clock rate to something approximating the original PC so stuff would stop breaking. It’s fine, we’d later end up with Windows crashing on fast machines because hardware details will absolutely bleed through.

    So, what’s a PC compatible? No modern PC will run the DOS that the original PC ran. If you try hard enough you can get it into a state where it’ll run most old software, as long as it doesn’t have assumptions about memory segmentation or your CPU or want to talk to your GPU directly. And even then it’ll potentially be unusable or crash because time is hard.

    The truth is that there’s no way we can technically describe a PC Compatible now - or, honestly, ever. If you sent a modern PC back to 1981 the media would be amazed and also point out that it didn’t run Flight Simulator. “PC Compatible” is a socially defined construct, just like “Woman”. We can get hung up on the details or we can just chill.


    1. Windows 7 is entirely happy to boot on UEFI systems except that it relies on being able to use a BIOS call to set the video mode during boot, which has resulted in things like UEFISeven to make that work on modern systems that don’t provide BIOS compatibility ↩︎

    2. Back in the 90s and early 2000s operating systems didn’t necessarily have native drivers for USB input devices, so there was hardware support for trapping OS accesses to the keyboard controller and redirecting that into System Management Mode where some software that was invisible to the OS would speak to the USB controller and then fake a response anyway that’s how I made a laptop that could boot unmodified MacOS X ↩︎

    3. (my name will not be Wolfwings Shadowflight ) ↩︎

    4. Yes yes ok 8088 MPH demonstrates that if you really want to you can do better than that on CGA ↩︎

    5. and by advanced we’re still talking about the 90s, don’t get excited ↩︎

    • chevron_right

      Christian Hergert: pgsql-glib

      news.movim.eu / PlanetGnome • 2 January 2026

    Much like the s3-glib library I put together recently , I had another itch to scratch. What would it look like to have a PostgreSQL driver that used futures and fibers with libdex? This was something I wondered about more than a decade ago when writing the libmongoc network driver for 10gen (later MongoDB).

    pgsql-glib is such a library which I made to wrap the venerable libpq PostgreSQL state-machine library. It does operations on fibers and awaits FD I/O to make something that feels synchronous even though it is not.

    It also allows for something more “RAII-like” using g_autoptr() which interacts very nicely with fibers.

    API Documentation can be found here.

    • chevron_right

      Felipe Borges: Looking for Mentors for Google Summer of Code 2026

      news.movim.eu / PlanetGnome • 2 January 2026

    It is once again that pre-GSoC time of year where I go around asking GNOME developers for project ideas they are willing to mentor during Google Summer of Code . GSoC is approaching fast, and we should aim to get a preliminary list of project ideas by the end of January.

    Internships offer an opportunity for new contributors to join our community and help us build the software we love.

    @Mentors , please submit new proposals in our Project Ideas GitLab repository .

    Proposals will be reviewed by the GNOME Internship Committee and posted at https://gsoc.gnome.org/2026 . If you have any questions, please don’t hesitate to contact us .

    • chevron_right

      Lennart Poettering: Mastodon Stories for systemd v259

      news.movim.eu / PlanetGnome • 30 December 2025 • 1 minute

    On Dec 17 we released systemd v259 into the wild .

    In the weeks leading up to that release (and since then) I have posted a series of serieses of posts to Mastodon about key new features in this release, under the #systemd259 hash tag. In case you aren't using Mastodon, but would like to read up, here's a list of all 25 posts:

    I intend to do a similar series of serieses of posts for the next systemd release (v260), hence if you haven't left tech Twitter for Mastodon yet, now is the opportunity.

    My series for v260 will begin in a few weeks most likely, under the #systemd260 hash tag.

    In case you are interested, here is the corresponding blog story for systemd v258 , here for v257 , and here for v256 .

    • chevron_right

      Sophie Herold: GNOME in 2025: Some Numbers

      news.movim.eu / PlanetGnome • 27 December 2025 • 3 minutes

    As some of you know, I like aggregating data. So here are some random numbers about GNOME in 2025. This post is not about making any point with the numbers I’m sharing. It’s just for fun.

    So, what is GNOME? In total, 6 692 516 lines of code. Of that, 1 611 526 are from apps. The remaining 5 080 990 are in libraries and other components, like the GNOME Shell. These numbers cover “the GNOME ecosystem,” that is, the combination of all Core, Development Tools, and Circle projects. This currently includes exactly 100 apps. We summarize everything that’s not an app under the name “components.”

    GNOME 48 was at least 90 % translated for 33 languages. In GNOME 49 this increased to 36 languages. That’s a record in the data that I have, going back to GNOME 3.36 in 2020. The languages besides American English are: Basque, Brazilian Portuguese, British English, Bulgarian, Catalan, Chinese (China), Czech, Danish, Dutch, Esperanto, French, Galician, Georgian, German, Greek, Hebrew, Hindi, Hungarian, Indonesian, Italian, Lithuanian, Persian, Polish, Portuguese, Romanian, Russian, Serbian, Serbian (Latin), Slovak, Slovenian, Spanish, Swedish, Turkish, Uighur, and Ukrainian. There are 19 additional languages that are translated 50 % or more. So maybe you can help with translating GNOME to Belarusian, Catalan (Valencian), Chinese (Taiwan), Croatian, Finnish, Friulian, Icelandic, Japanese, Kazakh, Korean, Latvian, Malay, Nepali, Norwegian Bokmål, Occitan, Punjabi, Thai, Uzbek (Latin), or Vietnamese in 2026?

    Talking about languages. What programming languages are used in GNOME? Let’s look at GNOME Core apps first. Almost half of all apps are written in C. Note that for these data, we are counting TypeScript under JavaScript.

    C: 44.8%, Vala: 20.7%, Rust: 10.3%, Python: 6.9%, JavaScript: 13.8%, C++ 3.45%. Share of GNOME Core apps by programming language.

    The language distribution for GNOME Circle apps looks quite different with Rust (41.7 %), and Python (29.2 %) being the most popular languages.

    C: 6%, Vala, 13%, Rust 42%, Python 29%, JavaScript 10%, Crystal 1% Share of GNOME Circle apps by programming language.

    Overall, we can see that with C, JavaScript/TypeScript, Python, Rust, and Vala, there are five programming languages that are commonly used for app development within the GNOME ecosystem.

    But what about components within GNOME? The default language for libraries is still C. More than three-quarters of the lines of code for components are written in it. The components with the largest codebase are GTK (820 000), GLib (560 000), and Mutter (390 000).

    Lines of code for components within the GNOME ecosystem.

    But what about the remaining quarter? Line of code are of course a questionable metric. For Rust, close to 400 000 lines of code are actually bindings for libraries. The majority of this code is automatically generated. Similarly, 100 000 lines of Vala code are in the Vala repository itself. But there are important components within GNOME that are not written in C: Orca, our screen reader, boasts 110 000 lines of Python code. Half of GNOME Shell is written in JavaScript, adding 65 000 lines of JavaScript code. Librsvg and glycin are libraries written in Rust, that also provide bindings to other languages.

    We are slowly approaching the end of the show. Let’s take a look at the GNOME Circle apps most popular on Flathub. I don’t trust the installation statistics on Flathub, since I have seen indications that for some apps, the number of installations is surprisingly high and cyclic. My guess is that some Linux distribution is installing these apps regularly as part of their test pipeline. Therefore, we instead check how many people have installed the latest update for the app. Not a perfect number either, but something that looks much more reliable. The top five apps are: Blanket, Eyedropper, Newsflash, Fragments, and Shortwave. Sometimes, it needs less than 2 000 lines of code to create popular software.

    And there are 862 people supporting the GNOME Foundation with a recurring donation. Will you join them for 2026 on donate.gnome.org ?

    • chevron_right

      Joan Torres López: Remote Login Design

      news.movim.eu / PlanetGnome • 23 December 2025 • 3 minutes

    GNOME 46 introduced remote login. This post explores the architecture primarily through diagrams and tables for a clearer understanding.

    Components overview


    There are 4 components involved: the remote client, the GRD dispatcher daemon, the GRD handover daemon and the GDM daemon:

    Component Type Responsibility
    Remote Client Remote User Connects remotely via RDP. Supports RDP Server Redirection method.
    Dispatcher GRD System-level daemon Handles initial connections, peeks routing token and orchestrates handovers.
    Handover GRD User-level daemon Runs inside sessions (Greeter or User). Provides remote access of the session to the remote client.
    GDM GDM System-level daemon Manages Displays and Sessions (Greeter or User).

    API Overview


    The components communicate with each other through dbus interfaces:

    Exposed by GDM

    org.gnome.DisplayManager.RemoteDisplayFactory

        • Method CreateRemoteDisplay
          Requests GDM to start a headless greeter. Accepts a RemoteId argument.

    org.gnome.DisplayManager.RemoteDisplay

      • Property RemoteId
        The unique ID generated by the Dispatcher.
      • Property SessionId
        The session ID of the created session wrapped by this display.

    Exposed by GRD Dispatcher

    org.gnome.RemoteDesktop.Dispatcher

      • Method RequestHandover
        Returns the object path of the Handover interface matching the caller’s session ID.

    org.gnome.RemoteDesktop.Handover

    Dynamically created. One for each remote session.

      • Method StartHandover
        Initiates the handover process. Receives one-time username/password, returns certificate and key used by dispatcher.
      • Method TakeClient
        Gives the file descriptor of the remote client’s connection to the caller.
      • Signal TakeClientReady
        Informs that a file descriptor is ready to be taken.
      • Signal RedirectClient
        Instructs the source session to redirect the remote client to the destination session.

    Flow Overview


    Flow phase 1: Initial connection to greeter session

    1. Connection:

      • Dispatcher receives a new connection from a Remote Client . Peeks the first bytes and doesn’t find a routing token. This means this is a new connection.

    2. Authentication:

      • Dispatcher authenticates the Remote Client using system level credentials.

    3. Session Request:

      • Dispatcher generates a unique remote_id (also known as routing token), and calls CreateRemoteDisplay() on GDM with this remote_id .

    4. Registration:

      • GDM starts a headless greeter session.
      • GDM exposes RemoteDisplay object with RemoteId and SessionId .
      • Dispatcher detects new object. Matches RemoteId . Creates Handover D-Bus interface for this SessionId .

    5. Handover Setup:

      • Handover is started in the headless greeter session.
      • Handover calls RequestHandover() to get its D-Bus object path with the Handover interface.
      • Handover calls StartHandover() with autogenerated one-time credentials. Gets from that call the certificate and key (to be used when Remote Client connects).

    6. Redirection (The “Handover”):

      • Dispatcher performs RDP Server Redirection sending the one-time credentials, routing token ( remote_id ) and certificate.
      • Remote Client disconnects and reconnects.
      • Dispatcher peeks bytes; finds valid routing token.
      • Dispatcher emits TakeClientReady on the Handover interface.

    7. Finalization:

      • Handover calls TakeClient() and gets the file descriptor of the Remote Client ‘s connection.
      • Remote Client is connected to the headless greeter session.

    Flow phase 2: Session transition (from greeter to user)

    1. Session Creation:

      • User authenticates.
      • GDM starts a headless user session.

    2. Registration:

      • GDM exposes a new RemoteDisplay with the same RemoteId and a new SessionId .
      • Dispatcher detects a RemoteId collision.
      • State Update: Dispatcher creates a new Handover D-Bus interface ( dst ) to be used by the New Handover in the headless user session.
      • The Existing Handover remains connected to its original Handover interface ( src ).

    3. Handover Setup:

      • New Handover is started in the headless user session.
      • New Handover calls RequestHandover() to obtain its D-Bus object path with the Handover interface.
      • New Handover calls StartHandover() with new one-time credentials and receives the certificate and key.

    4. Redirection Chain:

      • Dispatcher receives StartHandover() from dst .
      • Dispatcher emits RedirectClient on src (headless greeter session) with the new one-time credentials.
      • Existing Handover receives the signal and performs RDP Server Redirection.

    5. Reconnection:

      • Remote Client disconnects and reconnects.
      • Dispatcher peeks bytes and finds a valid routing token ( remote_id ).
      • Dispatcher resolves the remote_id to the destination Handover ( dst ).
      • Dispatcher emits TakeClientReady on dst .

    6. Finalization:

      • New Handover calls TakeClient() and receives the file descriptor of the Remote Client ‘s connection.
      • Remote Client is connected to the headless user session.

    Disclaimer

    Please note that while this post outlines the basic architectural structure and logic, it may not guarantee a 100% match with the actual implementation at any given time. The codebase is subject to ongoing refactoring and potential improvements.