close

Normal view

Thibault Martin: TIL that Minikube mounts volumes as root

21 April 2026 at 07:00

When I have to play with a container image I have never met before, I like to deploy it on a test cluster to poke and prod it. I usually did that on a k3s cluster, but recently I've moved to Minikube to bring my test cluster with me when I'm on the go.

Minikube is a tiny one-node Kubernetes cluster meant to run on development machines. It's useful to test Deployments or StatefulSets with images you are not familiar with and build proper helm charts from them.

It provides volumes of the hostPath type by default. The major caveat of hostPath volumes is that they're mounted as root by default.

I usually handle mismatched ownership with a securityContext like the following to instruct the container to run with a specific UID and GID, and to make the volume owned by a specific group.

Typically in a StatefulSet it looks like this:

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: myapp
# [...]
spec:
# [...]
  template:
# [...]
    spec:
      securityContext:
        runAsUser: 10001
        runAsGroup: 10001
        fsGroup: 10001
      containers:
        - name: myapp
          volumeMounts:
            - name: data
              mountPath: /data
  volumeClaimTemplates:
    - metadata:
        name: data
      spec:
# [...]

In this configuration:

  • Processes in the Pod myapp will run with UID 10001 and GID 10001.
  • The /data directory mounted from the data volume will belong to group 10001 as well.

The securityContext usually solves the problem, but that's not how hostPath works. For hostPath volumes, the securityContext.fsGroup property is silently ignored.

[!success] Init Container to the Rescue!

The solution in this specific case is to use an initContainer as root to chown the volume mounts to the unprivileged user.

In practice it will look like this.

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: myapp
# [...]
spec:
# [...]
  template:
# [...]
    spec:
      securityContext:
        runAsUser: 10001
        runAsGroup: 10001
        fsGroup: 10001
      initContainers:
        - name: fix-perms
          image: busybox
          command:
            ["sh", "-c", "chown -R 10001:10001 /data"]
          securityContext:
            runAsUser: 0
          volumeMounts:
            - name: data
              mountPath: /data
      containers:
        - name: myapp
          volumeMounts:
            - name: data
              mountPath: /data
  volumeClaimTemplates:
    - metadata:
        name: data
      spec:
# [...]

It took me a little while to figure it out, because I was used to testing my StatefulSets on k3s. K3s uses a local path provisioner, which gives me local volumes, not hostPath ones like Minikube.

In production I don't need the initContainer to fix permissions since I'm deploying this on an EKS cluster.

Andy Wingo: on hayek's bastards

20 April 2026 at 21:35

After wrapping up a four-part series on free trade and the left, I thought I was done with neoliberalism. I had come to the conclusion that neoliberals were simply not serious people: instead of placing value in literally any human concern, they value only a network of trade, and as such, cannot say anything of value. They should be ignored in public debate; we can find economists elsewhere.

I based this conclusion partly on Quinn Slobodian’s Globalists (2020), which describes Friedrich Hayek’s fascination with cybernetics in the latter part of his life. But Hayek himself died before the birth of the WTO, NAFTA, all the institutions “we” fought in Seattle; we fought his ghost, living on past its time.

Well, like I say, I thought I was done, but then a copy of Slobodian’s Hayek’s Bastards (2025) arrived in the post. The book contests the narrative that the right-wing “populism” that we have seen in the last couple decades is an exogenous reaction to elite technocratic management under high neoliberalism, and that actually it proceeds from a faction of the neoliberal project. It’s easy to infer a connection when we look at, say, Javier Milei‘s background and cohort, but Slobodian delicately unpicks the weft to expose the tensile fibers linking the core neoliberal institutions to the alt-right. Tonight’s note is a book review of sorts.

after hayek

Let’s back up a bit. Slobodian’s argument in Globalists was that neoliberalism is not really about laissez-faire as such: it is a project to design institutions of international law to encase the world economy, to protect it from state power (democratic or otherwise) in any given country. It is paradoxical, because such an encasement requires state power, but it is what it is.

Hayek’s Bastards is also about encasement, but instead of protection from the state, the economy was to be protected from debasement by the unworthy. (Also there is a chapter on goldbugs, but that’s not what I want to talk about.)

The book identifies two major crises that push a faction of neoliberals to ally themselves with a culturally reactionary political program. The first is the civil rights movement of the 1960s and 1970s, together with decolonization. To put it crudely, whereas before, neoliberal economists could see themselves as acting in everyone’s best interest, having more black people in the polity made some of these white economists feel like their project was being perverted.

Faced with this “crisis”, at first the reactionary neoliberals reached out to race: the infant post-colonial nations were unfit to participate in the market because their peoples lacked the cultural advancement of the West. Already Globalists traced a line through Wilhelm Röpke‘s full-throated defense of apartheid, but the subjects of Hayek’s Bastards (Lew Rockwell, Charles Murray, Murray Rothbard, et al) were more subtle: instead of directly stating that black people were unfit to govern, Murray et al argued that intelligence was the most important quality in a country’s elite. It just so happened that they also argued, clothed in the language of evolutionary psychology and genetics, that black people are less intelligent than white people, and so it is natural that they not occupy these elite roles, that they be marginalized.

Before proceeding, three parentheses:

  1. Some words have a taste. Miscegenation tastes like the juice at the bottom of a garbage bag left out in the sun: to racists, because of the visceral horror they feel at the touch of the other, and to the rest of us, because of the revulsion the very idea provokes.

  2. I harbor an enmity to Silvia Plath because of The Bell Curve. She bears no responsibility; her book was The Bell Jar. I know this in my head but my heart will not listen.

  3. I do not remember the context, but I remember a professor in university telling me that the notion of “race” is a social construction without biological basis; it was an offhand remark that was new to me then, and one that I still believe now. Let’s make sure the kids now hear the good word now too; stories don’t tell themselves.

The second crisis of neoliberalism was the fall of the Berlin Wall: some wondered if the negative program of deregulation and removal of state intervention was missing a positive putty with which to re-encase the market. It’s easy to stand up on a stage with a chainsaw, but without a constructive program, neoliberal wins in one administration are fragile in the next.

The reactionary faction of neoliberalism’s turn to “family values” responds to this objective need, and dovetails with the reaction to the civil rights movement: to protect the market from the unworthy, neo-reactionaries worked to re-orient the discourse, and then state policy, away from “equality” and the idea that idea that We Should Improve Society, Somewhat. Moldbug’s neofeudalism is an excessive rhetorical joust, but one that has successfully moved the window of acceptable opinions. The “populism” of the AfD or the recent Alex Karp drivel is not a reaction, then, to neoliberalism, but a reaction by a faction of neoliberals to the void left after communism. (And when you get down to it, what is the difference between Moldbug nihilistically rehashing Murray’s “black people are low-IQ” and Larry Summers’ “countries in Africa are vastly UNDER-polluted”?)

thots

Slobodian shows remarkable stomach: his object of study is revolting. He has truly done the work.

For all that, Hayek’s Bastards left me with a feeling of indigestion: why bother with the racism? Hayek himself had a thesis of sorts, woven through his long career, that there is none of us that is smarter than the market, and that in many (most?) cases, the state should curb its hubris, step back, and let the spice flow. Prices are a signal, axons firing in an ineffable network of value, sort of thing. This is a good thesis! I’m not saying it’s right, but it’s interesting, and I’m happy to engage with it and its partisans.

So why do Hayek’s bastards reach to racism? My first thought is that they are simply not worthy: Charles Murray et al are intellectually lazy and moreover base. My lip curls to think about them in any serious way. I can’t help but recall the DARVO tactic of abusers; neo-reactionaries blame “diversity” for “debasing the West”, but it is their ignorant appeals to “race science” that is without basis.

Then I wonder: to what extent is this all an overworked intellectual retro-justification for something they wanted all along? When Mises rejoiced in the violent defeat of the 1927 strike, he was certainly not against state power per se; but was he for the market, or was he just against a notion of equality?

I can only conclude that things are confusing. “Mathematical” neoliberals exist, and don’t need to lean on racism to support their arguments. There are also the alt-right/neo-reactionaries, who grew out from neoliberalism, not in opposition to it: no seasteader is a partisan of autarky. They go to the same conferences. It is a baffling situation.

While it is all more the more reason to ignore them both, intellectually, Slobodian’s book shows that politically we on the left have our work set out for us both in deconstructing the new racism of the alt-right, and in advocating for a positive program of equality to take its place.

Khrys’presso du lundi 20 avril 2026

20 April 2026 at 05:42

Comme chaque lundi, un coup d’œil dans le rétroviseur pour découvrir les informations que vous avez peut-être ratées la semaine dernière.


Tous les liens listés ci-dessous sont a priori accessibles librement. Si ce n’est pas le cas, pensez à activer votre bloqueur de javascript favori ou à passer en “mode lecture” (Firefox) ;-)

Brave New World

Spécial IA

Spécial clashs / logiciels plus ou moins libres

Spécial guerre(s) au Moyen-Orient

Spécial femmes dans le monde

Spécial France

Spécial femmes en France

RIP

Spécial médias et pouvoir

Spécial emmerdeurs irresponsables gérant comme des pieds (et à la néolibérale)

Spécial recul des droits et libertés, violences policières, montée de l’extrême-droite…

Spécial résistances

Spécial outils de résistance

Soutenir

Spécial MAGAM et cie

Les autres lectures de la semaine

Les BDs/graphiques/photos de la semaine

Les vidéos/podcasts de la semaine

Les trucs chouettes de la semaine

Image

Retrouvez les revues de web précédentes dans la catégorie Libre Veille du Framablog.

Les articles, commentaires et autres images qui composent ces « Khrys’presso » n’engagent que moi (Khrys).

Juan Pablo Ugarte: Casilda 1.2.4 Released!

19 April 2026 at 20:07

I am very happy to announce a new version of Casilda!

A simple Wayland compositor widget for Gtk 4.

This release comes with several new features, bug fixes and extra polish that it is making it start to feel like a proper compositor.

It all started with a quick 1.2 release to port it to wlroots 0.19 because 0.18 was removed from Debian, while doing this on my new laptop I was able to reproduce a texture leak crash which lead to 1.2.1 and a fix in Gtk by Benjamin to support Vulkan drivers that return dmabufs with less fd than planes.

At this point I was invested to I decided to fix the rest of issues in the backlog…

Fractional scale

Casilda only supported integer scales not fractional scale so you could set your display scale to 200% but not 125%.

For reference this is how gtk4-demo looks like at 100% or scale 1 where 1 application/logical pixel corresponds to one device/display pixel.

*** Keep in mind its preferable to see all the following images without fractional scale itself and at full size ***

Image

Clients would render at the next round scale if the application was started with a fractional scale set…

Image

Or the client would render at scale 1 and look blurry if you switched from 1 to a fractional scale.

Image

In both cases the input did not matched with the renderer window making the application really broken.

So if the client application draws a 4 logical pixel border, it will be 5 pixels in the backing texture this means that 1 logical pixel correspond to 1.25 device pixels. So in order for things to look sharp CasildaCompositor needs to make sure the coordinates it uses for position the client window will match to the device pixel grid.

My first attempt was to do

((int)x * scale) / scale

but that still looked blurry, and that is because I assumed window coordinate 0,0 was the same as its backing surface coordinates 0,0 but that is not the case because I forgot about the window shadow. Luckily there is API to get the offset, then all you have to do is add the logical position of the compositor widget and you get the surface origin coordinates

gtk_native_get_surface_transform (GTK_NATIVE (root), &surface_origin_x, &surface_origin_y);

/* Add widget offset */
if (gtk_widget_compute_point (self, GTK_WIDGET (root), &GRAPHENE_POINT_INIT (0, 0), &out_point))
  {
    surface_origin_x += out_point.x;
    surface_origin_y += out_point.y;
  }

Once I had that I could finally calculate the right position

/* Snap logical coordinates to device pixel grid */
if (scale > 1.0)
  {
    x = floorf ((x + surface_origin_x) * scale) / scale - surface_origin_x;
    y = floorf ((y + surface_origin_y) * scale) / scale - surface_origin_y;
  }

And this is how it looks now with 1.25 fractional scale.

Image

Keyboard layouts

Another missing feature was support for different keyboard layouts so switching layouts would work on clients too. Not really important for Cambalache but definitely necessary for a generic compositor.

Image

Popups positioners

Casilda now send clients all the necessary information for positioning popups in a place where they do not get cut out of the display area which is a nice thing to have.

Image

Cursor shape protocol

Current versions of Gtk 4 requires cursor shape protocol on wayland otherwise it fallback to 32×32 pixel size cursors which might not be the same size of your system cursors and look blurry with fractional scales.

In this case the client send an cursor id instead of a pixel buffer when it wants to change the cursor.

This was really easy to implement as all I had to do is call

gtk_widget_set_cursor_from_name (compositor, wlr_cursor_shape_v1_name (event->shape));

Greetings

As usual this would not be possible without the help of the community, special thanks to emersion, Matthias and Benjamin for their help and support.

Release Notes

    • Add fractional scale support
    • Add viewporter support
    • Add support for cursor shape
    • Forward keyboard layout changes to clients.
    • Improve virtual size calculation
    • Fix maximized/fullscreen auto resize on compositor size allocation
    • Add support for popups reposition
    • Fix GdkTexture leak

Fixed Issues

    • #5 “Track keymap layout changes”
    • #12 “Support for wlroots-0.19”
    • #13 “Wrong cursor size on client windows”
    • #14 “Support for fractional scaling snap to device grid”
    • #19 Add support for popups reposition
    • #16 Firefox GTK backdrop/shadow not scaled correctly

Where to get it?

Source code lives on GNOME gitlab here

git clone https://gitlab.gnome.org/jpu/casilda.git

Matrix channel

Have any question? come chat with us at #cambalache:gnome.org

Mastodon

Follow me in Mastodon @xjuan to get news related to Casilda and Cambalache development.

Happy coding!

Matthias Klumpp: Hello old new “Projects” directory!

18 April 2026 at 08:06

If you have recently installed a very up-to-date Linux distribution with a desktop environment, or upgraded your system on a rolling-release distribution, you might have noticed that your home directory has a new folder: “Projects”

Why?

With the recent 0.20 release of xdg-user-dirs we enabled the “Projects” directory by default. Support for this has already existed since 2007, but was never formally enabled. This closes a more than 11 year old bug report that asked for this feature.

The purpose of the Projects directory is to give applications a default location to place project files that do not cleanly belong into one of the existing categories (Documents, Music, Pictures, Videos). Examples of this are software engineering projects, scientific projects, 3D printing projects, CAD design or even things like video editing projects, where project files would end up in the “Projects” directory, with output video being more at home in “Videos”.

By enabling this by default, and subsequently in the coming months adding support to GLib, Flatpak, desktops and applications that want to make use of it, we hope to give applications that do operate in a “project-centric” manner with mixed media a better default storage location. As of now, those tools either default to the home directory, or will clutter the “Documents” folder, both of which is not ideal. It also gives users a default organization structure, hopefully leading to less clutter overall and better storage layouts.

This sucks, I don’t like it!

Image

As usual, you are in control and can modify your system’s behavior. If you do not like the “Projects” folder, simply delete it! The xdg-user-dirs utility will not try to create it again, and instead adjust the default location for this directory to your home directory. If you want more control, you can influence exactly what goes where by editing your ~/.config/user-dirs.dirs configuration file.

If you are a system administrator or distribution vendor and want to set default locations for the default XDG directories, you can edit the /etc/xdg/user-dirs.defaults file to set global defaults that affect all users on the system (users can still adjust the settings however they like though).

What else is new?

Besides this change, the 0.20 release of xdg-user-dirs brings full support for the Meson build system (dropping Automake), translation updates, and some robustness improvements to its code. We also fixed the “arbitrary code execution from unsanitized input” bug that the Arch Linux Wiki mentions here for the xdg-user-dirs utility, by replacing the shell script with a C binary.

Thanks to everyone who contributed to this release!

Allan Day: GNOME Foundation Update, 2026-04-17

17 April 2026 at 15:22

Welcome to another update about everything that’s been happening at the GNOME Foundation. It’s been four weeks since my last post, due to a vacation and public holidays, so there’s lots to cover. This period included a major announcement, but there’s also been a lot of other notable work behind the scenes.

Fellowship & Fundraising

The really big news from the last four weeks was the launch of our new Fellowship program. This is something that the Board has been discussing for quite some time, so we were thrilled to be able to make the program a reality. We are optimistic that it will make a significant difference to the GNOME project.

If you didn’t see it already, check out the announcement for details. Also, if you want to apply to be our first Fellow, you have just three days until the application deadline on 20th April!

donate.gnome.org has been a great success for the GNOME Foundation, and it is only through the support of our existing donors that the Fellowship was possible. Despite these amazing contributions, the GNOME Foundation needs to grow our donations if we are going to be able to support future Fellowship rounds while simultaneously sustaining the organisation.

To this end, there’s an effort happening to build our marketing and fundraising effort. This is primarily taking place in the GNOME Engagement Team, and we would love help from the community to help boost our outbound comms. If you are interested, please join the Engagement space and look out for announcements.

Also, if you haven’t already, and are able to do so: please donate!

Conferences

We have two major events coming up, with Linux App Summit in May and GUADEC in July, so right now is a busy time for conferences.

The schedules for both of these upcoming events are currently being worked on, and arrangements for catering, photographers, and audio visual services are all in the process of being finalized.

The Travel Committee has also been busy handling GUADEC travel requests, and has sent out the first batch of approvals. There are some budget pressures right now due to rising flight prices, but budget has been put aside for more GUADEC travel, so please apply if you want to attend and need support.

April 2026 Board Meeting

This week was the Board’s regular monthly meeting for April. Highlights from the meeting included:

  • I gave a general report on the Foundation’s activities, and we discussed progress on programs and initiatives, including the new Fellowship program and fundraising.
  • Deepa gave a finance report for October to December 2025.
  • Andrea Veri joined us to give an update on the Membership & Elections Committee, as well as the Infrastructure team. Andrea has been doing this work for a long time and has been instrumental in helping to keep the Foundation running, so this was a great opportunity to thank him for his work.
  • One key takeaway from this month’s discussion was the very high level of support that GNOME receives from our infrastructure partners, particularly AWS and also Fastly. We are hugely appreciative of this support, which represents a major financial contribution to GNOME, and want to make sure that these partners get positive exposure from us and feel appreciated.
  • We reviewed the timeline for the upcoming 2026 board elections, which we are tweaking a little this year, in order to ensure that there is opportunity to discuss every candidacy, and reduce some unnecessary delay in final result.

Infrastructure

As usual, plenty has been happening on the infrastructure side over the past month. This has included:

  • Ongoing work to tune our Fastly configuration and managing the resource usage of GNOME’s infra.
  • Deployment of a LiberaForms instance on GNOME infrastructure. This is hooked up to GNOME’s SSO, so is available to anyone with an account who wants to use it – just head over to forms.gnome.org to give it a try.
  • Changes to the Foundation’s internal email setup, to allow easier management of the generic contact email addresses, as well as better organisation of the role-based email addresses that we have.
  • New translation support for donate.gnome.org.
  • Ongoing work in Flathub, around OAuth and flat-manager.

Admin & Finance

On the accounting side, the team has been busy catching up on regular work that got put to one side during last month’s audit. There were some significant delays to our account process as a result of this, but we are now almost up to date.

Reorganisation of many of our finance processes has also continued over the past four weeks. Progress has included a new structure and cadence for our internal accounting calls, continued configuration of our new payments platform, and new forms for handling reimbursement requests.

Finally, we have officially kicked off the process of migrating to our new physical mail service. Work on this is ongoing and will take some time to complete. Our new address is on the website, if anyone needs it.

That’s it for this report! Thanks for reading, and feel free to use the comments if you have questions!

Andrea Veri: GNOME GitLab Git traffic caching

17 April 2026 at 14:00

Table of Contents

Introduction

One of the most visible signs that GNOME’s infrastructure has grown over the years is the amount of CI traffic that flows through gitlab.gnome.org on any given day. Hundreds of pipelines run in parallel, most of them starting with a git clone or git fetch of the same repository, often at the same commit. All that traffic was landing directly on GitLab’s webservice pods, generating redundant load for work that was essentially identical.

GNOME’s infrastructure runs on AWS, which generously provides credits to the project. Even so, data transfer is one of the largest cost drivers we face, and we have to operate within a defined budget regardless of those credits. The bandwidth costs associated with this Git traffic grew significant enough that for a period of time we redirected unauthenticated HTTPS Git pulls to our GitHub mirrors as a short-term cost mitigation. That measure bought us some breathing room, but it was never meant to be permanent: sending users to a third-party platform for what is essentially a core infrastructure operation is not a position we wanted to stay in. The goal was always to find a proper solution on our own infrastructure.

This post documents the caching layer we built to address that problem. The solution sits between the client and GitLab, intercepts Git fetch traffic, and routes it through Fastly’s CDN so that repeated fetches of the same content are served from cache rather than generating a fresh pack every time.

The problem

The Git smart HTTP protocol uses two endpoints: info/refs for capability advertisement and ref discovery, and git-upload-pack for the actual pack generation. The second one is the expensive one. When a CI job runs git fetch origin main, GitLab has to compute and send the entire pack for that fetch negotiation. If ten jobs run the same fetch within a short window, GitLab does that work ten times.

The tricky part is that git-upload-pack is a POST request with a binary body that encodes what the client already has (have lines) and what it wants (want lines). Traditional HTTP caches ignore POST bodies entirely. Building a cache that actually understands those bodies and deduplicates identical fetches requires some work at the edge.

For a fresh clone the body contains only want lines — one per ref the client is requesting:

0032want 7d20e995c3c98644eb1c58a136628b12e9f00a78
0032want 93e944c9f728a4b9da506e622592e4e3688a805c
0032want ef2cbad5843a607236b45e5f50fa4318e0580e04
...

For an incremental fetch the body is a mix of want lines (what the client needs) and have lines (commits the client already has locally), which the server uses to compute the smallest possible packfile delta:

00a4want 51a117587524cbdd59e43567e6cbd5a76e6a39ff
0000
0032have 8282cff4b31dce12e100d4d6c78d30b1f4689dd3
0032have be83e3dae8265fdc4c91f11d5778b20ceb4e2479
0032have 7d46abdf9c5a3f119f645c8de6d87efffe3889b8
...

The leading four hex characters on each line are the pkt-line length prefix. The server walks back through history from the wanted commits until it finds a common ancestor with the have set, then packages everything in between into a packfile. Two CI jobs running the same pipeline at the same commit will produce byte-for-byte identical request bodies and therefore identical responses — exactly the property a cache can help with.

Architecture overview

The overall setup involves four components:

  • OpenResty (Nginx + LuaJIT) running as a reverse proxy in front of GitLab’s webservice
  • Fastly acting as the CDN, with custom VCL to handle the non-standard caching behaviour
  • Valkey (a Redis-compatible store) holding the denylist of private repositories
  • gitlab-git-cache-webhook, a small Python/FastAPI service that keeps the denylist in sync with GitLab
flowchart TD
client["Git client / CI runner"]
gitlab_gnome["gitlab.gnome.org (Nginx reverse proxy)"]
nginx["OpenResty Nginx"]
lua["Lua: git_upload_pack.lua"]
cdn_origin["/cdn-origin internal location"]
fastly_cdn["Fastly CDN"]
origin["gitlab.gnome.org via its origin (second pass)"]
gitlab["GitLab webservice"]
valkey["Valkey denylist"]
webhook["gitlab-git-cache-webhook"]
gitlab_events["GitLab project events"]
client --> gitlab_gnome
gitlab_gnome --> nginx
nginx --> lua
lua -- "check denylist" --> valkey
lua -- "private repo: BYPASS" --> gitlab
lua -- "public/internal: internal redirect" --> cdn_origin
cdn_origin --> fastly_cdn
fastly_cdn -- "HIT" --> cdn_origin
fastly_cdn -- "MISS: origin fetch" --> origin
origin --> gitlab
gitlab_events --> webhook
webhook -- "SET/DEL git:deny:" --> valkey

The request path for a public or internal repository looks like this:

  1. The Git client runs git fetch or git clone. Git’s smart HTTP protocol translates this into two HTTP requests: a GET /Namespace/Project.git/info/refs?service=git-upload-pack for ref discovery, followed by a POST /Namespace/Project.git/git-upload-pack carrying the negotiation body. It is that second request — the expensive pack-generating one — that the cache targets.
  2. It arrives at gitlab.gnome.org’s Nginx server, which acts as the reverse proxy in front of GitLab’s webservice.
  3. The git-upload-pack location runs a Lua script that parses the repo path, reads the request body, and SHA256-hashes it. The hash is the foundation of the cache key: because the body encodes the exact set of want and have SHAs the client is negotiating, two jobs fetching the same commit from the same repository will produce byte-for-byte identical bodies and therefore the same hash — making the cached packfile safe to reuse.
  4. Lua checks Valkey: is this repo in the denylist? If yes, the request is proxied directly to GitLab with no caching.
  5. For public/internal repos, Lua strips the Authorization header, builds a cache key, converts the POST to a GET, and does an internal redirect to /cdn-origin. The POST-to-GET conversion is necessary because Fastly does not apply consistent hashing to POST requests — each of the hundreds of nodes within a POP maintains its own independent cache storage, so the same POST request hitting different nodes will always be a miss. By converting to a GET, Fastly’s consistent hashing kicks in and routes requests with the same cache key to the same node, which means the cache is actually shared across all concurrent jobs hitting that POP.
  6. The /cdn-origin location proxies to the Fastly git cache CDN with the X-Git-Cache-Key header set.
  7. Fastly’s VCL sees the key and does a cache lookup. On a HIT it returns the cached pack. On a MISS it fetches from gitlab.gnome.org directly via its origin (bypassing the CDN to avoid a loop) — the same Nginx instance — and caches the response for 30 days.
  8. On that second pass (origin fetch), Nginx detects the X-Git-Cache-Internal header, decodes the original POST body from X-Git-Original-Body, restores the request method, and proxies to GitLab.

The Nginx and Lua layer

The Nginx configuration exposes two relevant locations. The first is the internal one used for the CDN proxy leg:

location ^~ /cdn-origin/ {
 internal;
 rewrite ^/cdn-origin(/.*)$ $1 break;
 proxy_pass $cdn_upstream;
 proxy_ssl_server_name on;
 proxy_ssl_name <cdn-hostname>;
 proxy_set_header Host <cdn-hostname>;
 proxy_set_header Accept-Encoding "";
 proxy_http_version 1.1;
 proxy_buffering on;
 proxy_request_buffering on;
 proxy_connect_timeout 10s;
 proxy_send_timeout 60s;
 proxy_read_timeout 60s;

 header_filter_by_lua_block {
 ngx.header["X-Git-Cache-Key"] = ngx.req.get_headers()["X-Git-Cache-Key"]
 ngx.header["X-Git-Body-Hash"] = ngx.req.get_headers()["X-Git-Body-Hash"]

 local xcache = ngx.header["X-Cache"] or ""
 if xcache:find("HIT") then
 ngx.header["X-Git-Cache-Status"] = "HIT"
 else
 ngx.header["X-Git-Cache-Status"] = "MISS"
 end
 }
}

The header_filter_by_lua_block here is doing something specific: it reads X-Cache from the response Fastly returns and translates it into a clean X-Git-Cache-Status header for observability. The X-Git-Cache-Key and X-Git-Body-Hash are also passed through so that callers can see what cache entry was involved.

The second location is git-upload-pack itself, which delegates all the logic to a Lua file:

location ~ /git-upload-pack$ {
 client_body_buffer_size 5m;
 client_max_body_size 5m;

 access_by_lua_file /etc/nginx/lua/git_upload_pack.lua;

 header_filter_by_lua_block {
 local key = ngx.req.get_headers()["X-Git-Cache-Key"]
 if key then
 ngx.header["X-Git-Cache-Key"] = key
 end
 }

 proxy_pass http://gitlab-webservice;
 proxy_http_version 1.1;
 proxy_set_header Host gitlab.gnome.org;
 proxy_set_header X-Real-IP $http_fastly_client_ip;
 proxy_set_header X-Forwarded-For $http_fastly_client_ip;
 proxy_set_header X-Forwarded-Proto https;
 proxy_set_header X-Forwarded-Port 443;
 proxy_set_header X-Forwarded-Ssl on;
 proxy_set_header Connection "";
 proxy_buffering on;
 proxy_request_buffering on;
 proxy_connect_timeout 10s;
 proxy_send_timeout 60s;
 proxy_read_timeout 60s;
}

The access_by_lua_file directive runs before the request is proxied. If the Lua script calls ngx.exec("/cdn-origin" .. uri), Nginx performs an internal redirect to the CDN location and the proxy_pass to GitLab is never reached. If the script returns normally (for private repos or non-fetch commands), the request falls through to the proxy_pass.

Building the cache key

The full Lua script that runs in access_by_lua_file handles both passes of the request. The first pass (client → nginx) does the heavy lifting:

local resty_sha256 = require("resty.sha256")
local resty_str = require("resty.string")
local redis_helper = require("redis_helper")

local redis_host = os.getenv("REDIS_HOST") or "localhost"
local redis_port = os.getenv("REDIS_PORT") or "6379"

-- Second pass: request arriving from CDN origin fetch.
-- Decode the original POST body from the header and restore the method.
if ngx.req.get_headers()["X-Git-Cache-Internal"] then
 local encoded_body = ngx.req.get_headers()["X-Git-Original-Body"]
 if encoded_body then
 ngx.req.read_body()
 local body = ngx.decode_base64(encoded_body)
 ngx.req.set_method(ngx.HTTP_POST)
 ngx.req.set_body_data(body)
 ngx.req.set_header("Content-Length", tostring(#body))
 ngx.req.clear_header("X-Git-Original-Body")
 end
 return
end

The second-pass guard is at the top of the script. When Fastly’s origin fetch arrives, it will carry X-Git-Cache-Internal: 1. The script detects that, reconstructs the POST body from the base64-encoded header, restores the POST method, and returns — allowing Nginx to proxy the real request to GitLab.

For the first pass, the script parses the repo path from the URI, reads and buffers the full request body, and computes a SHA256 over it:

-- Only cache "fetch" commands; ls-refs responses are small, fast, and
-- become stale on every push (the body hash is constant so a long TTL
-- would serve outdated ref listings).
if not body:find("command=fetch", 1, true) then
 ngx.header["X-Git-Cache-Status"] = "BYPASS"
 return
end

-- Hash the body
local sha256 = resty_sha256:new()
sha256:update(body)
local body_hash = resty_str.to_hex(sha256:final())

-- Build cache key: cache_versioning + repo path + body hash
local cache_key = "v2:" .. repo_path .. ":" .. body_hash

A few things worth noting here. The ls-refs command is explicitly excluded from caching. The reason is that ls-refs is used to list references and its request body is essentially static (just a capability advertisement). If we cached it with a 30-day TTL, a push to the repository would not invalidate the cache — the key would be the same — and clients would get stale ref listings. Fetch bodies, on the other hand, encode exactly the SHAs the client wants and already has. The same set of want/have lines always maps to the same pack, which makes them safe to cache for a long time.

The v2: prefix is a cache version string. It makes it straightforward to invalidate all existing cache entries if we ever need to change the key scheme, without touching Fastly’s purge API.

The POST-to-GET conversion

This is probably the most unusual part of the design:

-- Carry the POST body as a base64 header and convert to GET so that
-- Fastly's intra-POP consistent hashing routes identical cache keys
-- to the same server (Fastly only does this for GET, not POST).
ngx.req.set_header("X-Git-Original-Body", ngx.encode_base64(body))
ngx.req.set_method(ngx.HTTP_GET)
ngx.req.set_body_data("")

return ngx.exec("/cdn-origin" .. uri)

Fastly’s shield feature routes cache misses through a designated intra-POP “shield” node before going to origin. When two different edge nodes both get a MISS for the same cache key simultaneously, the shield node collapses them into a single origin request. This is important for us because without it, a burst of CI jobs fetching the same commit would all miss, all go to origin in parallel, and GitLab would end up generating the same pack multiple times anyway.

The catch is that Fastly’s consistent hashing and shield routing only works for GET requests. POST requests always go straight to origin. Fastly does provide a way to force POST responses into the cache — by returning pass in vcl_recv and setting beresp.cacheable in vcl_fetch — but it is a blunt instrument: there is no consistent hashing, no shield collapsing, and no guarantee that two nodes in the same POP will ever share the cached result. By converting the POST to a GET and encoding the body in a header, we get consistent hashing and shield-level request collapsing for free.

The VCL on the Fastly side uses the X-Git-Cache-Key header (not the URL or method) as the cache key, so the GET conversion is invisible to the caching logic.

Protecting private repositories

We cannot route private repository traffic through an external CDN — that would mean sending authenticated git content to a third-party cache. The way we prevent this is a denylist stored in Valkey. Before doing anything else, the Lua script checks whether the repository is listed there:

local denied, err = redis_helper.is_denied(redis_host, redis_port, repo_path)

if err then
 ngx.log(ngx.ERR, "git-cache: Redis error for ", repo_path, ": ", err,
 " — cannot verify project visibility, bypassing CDN")
 ngx.header["X-Git-Cache-Status"] = "BYPASS"
 return
end

if denied then
 ngx.header["X-Git-Cache-Status"] = "BYPASS"
 ngx.header["X-Git-Body-Hash"] = body_hash:sub(1, 12)
 return
end

-- Public/internal repo: strip credentials before routing through CDN
ngx.req.clear_header("Authorization")

If Valkey is unreachable, the script logs an error and bypasses the CDN entirely, treating the repository as if it were private. This is the safe default: the cost of a Redis failure is slightly increased load on GitLab, not the risk of routing private repository content through an external cache. In practice, Valkey runs alongside Nginx on the same node, so true availability failures are uncommon.

The denylist is maintained by gitlab-git-cache-webhook, a small FastAPI service. It listens for GitLab system hooks on project_create and project_update events:

HANDLED_EVENTS = {"project_create", "project_update"}

@router.post("/webhook")
async def webhook(request: Request, ...) -> Response:
 ...
 event = body.get("event_name", "")
 if event not in HANDLED_EVENTS:
 return Response(status_code=204)

 project = body.get("project", {})
 path = project.get("path_with_namespace", "")
 visibility_level = project.get("visibility_level")

 if visibility_level == 0:
 await deny_repo(path)
 else:
 removed = await allow_repo(path)
 return Response(status_code=204)

GitLab’s visibility_level is 0 for private, 10 for internal, and 20 for public. Internal repositories are intentionally treated the same as public ones here: they are accessible to any authenticated user on the instance, so routing them through the CDN is acceptable. Only truly private repositories go into the denylist.

The key format in Valkey is git:deny:<path_with_namespace>. The Lua redis_helper module does an EXISTS check on that key. The webhook service also ships a reconciliation command (python -m app.reconcile) that does a full resync of all private repositories via the GitLab API, which is useful to run on first deployment or after any extended Valkey downtime.

The Fastly VCL

On the Fastly side, three VCL subroutines carry the relevant logic. In vcl_recv:

if (req.url ~ "/info/refs") {
return(pass);
}
if (req.http.X-Git-Cache-Key) {
set req.backend = F_Host_1;
if (req.restarts == 0) {
set req.backend = fastly.try_select_shield(ssl_shield_iad_va_us, F_Host_1);
}
return(lookup);
}

/info/refs is always passed through uncached — it is the capability advertisement step and caching it would cause problems with protocol negotiation. Requests carrying X-Git-Cache-Key get an explicit lookup directive and are routed through the shield. Everything else falls through to Fastly’s default behaviour.

In vcl_hash, the cache key overrides the default URL-based key:

if (req.http.X-Git-Cache-Key) {
set req.hash += req.http.X-Git-Cache-Key;
return(hash);
}

And in vcl_fetch, responses are marked cacheable when they come back with a 200 and a non-empty body:

if (req.http.X-Git-Cache-Key && beresp.status == 200) {
if (beresp.http.Content-Length == "0") {
set beresp.ttl = 0s;
set beresp.cacheable = false;
return(deliver);
}
set beresp.cacheable = true;
set beresp.ttl = 30d;
set beresp.http.X-Git-Cache-Key = req.http.X-Git-Cache-Key;
unset beresp.http.Cache-Control;
unset beresp.http.Pragma;
unset beresp.http.Expires;
unset beresp.http.Set-Cookie;
return(deliver);
}

The 30-day TTL is deliberately long. Git pack data is content-addressed: a pack for a given set of want/have lines will always be the same. As long as the objects exist in the repository, the cached pack is valid. The only case where a cached pack could be wrong is if objects were deleted (force-push that drops history, for instance), which is rare and, on GNOME’s GitLab, made even rarer by the Gitaly custom hooks we run to prevent force-pushes and history rewrites on protected namespaces. In those cases the cache version prefix would force a key change rather than relying on TTL expiry.

Empty responses (Content-Length: 0) are explicitly not cached. GitLab can return an empty body in edge cases and caching that would break all subsequent fetches for that key.

Conclusions

The system has been running in production for a few days now and the cache hit rate on fetch traffic has been overall consistently high (over 80%). If something goes wrong with the cache layer, the worst case is that requests fall back to BYPASS and GitLab handles them directly, which is how things worked before. This also means we don’t redirect any traffic to github.com anymore.

That should be all for today, stay tuned!

Jussi Pakkanen: Multi merge sort, or when optimizations aren't

17 April 2026 at 10:41

In our previous episode we wrote a merge sort implementation that runs a bit faster than the one in stdlibc++. The question then becomes, could it be made even faster. If you go through the relevant literature one potential improvement is to do a multiway merge. That is, instead of merging two arrays into one, you merge four into one using, for example, a priority queue.

This seems like a slam dunk for performance.

  • Doubling the number of arrays to merge at a time halves the number of total passes needed
  • The priority queue has a known static maximum size, so it can be put on the stack, which is guaranteed to be in the cache all the time
  • Processing an element takes only log(#lists) comparisons
Implementing multimerge was conceptually straightforward but getting all the gritty details right took a fair bit of time. Once I got it working the end result was slower. And not by a little, either, but more than 30% slower. Trying some optimizations made it a bit faster but not noticeably so.

Why is this so? Maybe there are bugs that cause it to do extra work? Assuming that is not the case, what actually is? Measuring seems to indicate that a notable fraction of the runtime is spent in the priority queue code. Beyond that I got very little to nothing.

The best hypotheses I could come up with has to with the number of comparisons made. A classical merge sort does two if statements per output elements. One to determine which of the two lists has a smaller element at the front and one to see whether removing the element exhausted the list. The former is basically random and the latter is always false except when the last element is processed. This amounts to 0.5 mispredicted branches per element per round.

A priority queue has to do a bunch more work to preserve the heap property. The first iteration needs to check the root and its two children. That's three comparisons for value and two checks whether the children actually exist. Those are much less predictable than the comparisons in merge sort. Computers are really efficient at doing simple things, so it may be that the additional bookkeeping is so expensive that it negates the advantage of fewer rounds.

Or maybe it's something else. Who's to say? Certainly not me. If someone wants to play with the code, the implementation is here. I'll probably delete it at some point as it does not have really any advantage over the regular merge sort.

This Week in GNOME: #245 Infinite Ranges

17 April 2026 at 00:00

Update on what happened across the GNOME project in the week from April 10 to April 17.

GNOME Core Apps and Libraries

Libadwaita

Building blocks for modern GNOME apps using GTK4.

Alice (she/her) 🏳️‍⚧️🏳️‍🌈 reports

AdwAboutDialog’s Other Apps section title can now be overridden to say something other than “Other Apps by developer-name

Alice (she/her) 🏳️‍⚧️🏳️‍🌈 announces

AdwEnumListModel has been deprecated in favor of the recently added GtkEnumList. They work identically and so migrating should be as simple as find-and-replace

Maps

Maps gives you quick access to maps all across the world.

mlundblad announces

Maps now shows track/stop location for boarding and disembarking stations/stops on public transit journeys (when available in upstream data)

Image

GNOME Circle Apps and Libraries

Graphs

Plot and manipulate data

Sjoerd Stendahl says

After two years without a major feature-update, we are happy to announce Graphs 2.0. It’s by far our biggest update yet. We are targeting a stable release next month, but in the meantime we are running an official beta testing period. We are very happy for any feedback, especially in this period!

The upcoming Graphs 2.0, features some major long-requested changes: equations now span an infinite range and can be edited and manipulated analytically, the style editor has been redesigned with a live preview, we revamped the import dialog, and imported data now supports error bars. Equations with infinite values in them such as y=tan(x) now also render properly with values being drawn all the way to infinity and without having a line going from plus to minus infinity. We’ve also added support for spreadsheet and SQLite database files, drag-and-drop importing, improved curve fitting with residuals and better confidence bands, and now have proper mobile support.

These are just some highlights, a more complete list of changes, including a description of how to get the beta version, can be found here: https://blogs.gnome.org/sstendahl/2026/04/14/announcing-the-upcoming-graphs-2-0/

Image

Image

Gaphor

A simple UML and SysML modeling tool.

Arjan announces

Mareike Keil of the University of Mannheim published her article “NEST‑UX: Neurodivergent and Neurotypical Style Guide for Enhanced User Experience”. The paper explores how user interfaces can be designed to be accessible for both neurotypical and neurodivergent users, including people with autism, ADHD or giftedness.

The Gaphor team worked together with Mareike to implement suggestions she found during her research, allowing us to test how well these ideas work in practice.

The article can be found at https://academic.oup.com/iwc/advance-article-abstract/doi/10.1093/iwc/iwag011/8571596.

Mareike’s LinkedIn announcement can be found at https://www.linkedin.com/feed/update/urn:li:activity:7447176733759352832/.

Third Party Projects

Bilal Elmoussaoui announces

Now that most of the basic features work as expected, I would like to publicly introduce you to Goblin, a GObject Linter, for C codebases. You can read more about it at https://belmoussaoui.com/blog/23-goblin-linter/

Image

Anton Isaiev says

RustConn (connection manager for SSH, RDP, VNC, SPICE, Telnet, Serial, Kubernetes, MOSH, and Zero Trust protocols)

Versions 0.10.15–0.10.22 bring a week of polish across the UI, security, and terminal experience.

Terminal got better. Font zoom (Ctrl+Scroll, Ctrl+Plus/Minus) and optional copy-on-select landed. The context menu now works properly — VTE’s native API replaced the custom popover that was stealing focus and breaking clipboard actions. On X11 sessions (MATE, XFCE) where GTK4’s NGL renderer caused blank popovers, RustConn auto-detects and falls back to Cairo.

Sidebar and navigation. Groups expand/collapse on double-click anywhere on the row. The Local Shell button moved to the header bar so it’s always visible. Protocol filter bar is now optional and togglable. Tab groups show as a [GroupName] prefix in the tab title, and a new “Close All in Group” action cleans up grouped tabs at once. A tab group chooser dialog with clickable pill buttons replaces manual retyping.

RDP fixes. Multiple shared folders now map correctly in embedded IronRDP mode — previously only the first path was used. SSH Port Forwarding UI, which had silently disappeared from the connection dialog, is back.

Security hardened. Machine key encryption dropped the predictable hostname+username fallback; the /etc/machine-id path now uses HKDF-SHA256 with app-specific salt. Context menu labels and sidebar accessible labels are localized for screen readers.

Ctrl+K no longer hijacks the terminal — it was removed from the global search shortcut, so nano and other terminal apps get it back. Terminal auto-focus after connection means you can type immediately.

Export and import. Export dialog gained a group filter, and RustConn Native (.rcn) is now the default format in both import and export dialogs.

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

Image

Mufeed Ali reports

Wordbook 1.0.0 was released

Wordbook is now a fully offline application with no in-app downloads. Pronunciation data is now sourced from WordNet where possible, allowing better grouping of definitions in homonyms like “bass”. In general, many UI/UX improvements and bug fixes were also made. The community also helped by localizing the app for a total of 6 new languages.

Try it on Flathub.

Pods

Keep track of your podman containers.

marhkb says

Pods 3.0.0 is out!

This major release introduces a brand-new container engine abstraction layer allowing for greater flexibility.

Based on this new layer, Pods now features initial Docker support, making it easier for users to manage their containers regardless of their preferred backend.

Check it out on Flathub.

Image

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!

L’internet post-étasunien

16 April 2026 at 18:59

Voilà plus de 15 ans que le Framablog traduit les écrits du militant anglo-canadien Cory Doctorow. Le prolifique auteur d’ouvrage de fiction, d’essais (comme « Détruire le capitalisme de surveillance » (2020)), et d’innombrables billets de blog, est membre actif de l’Electronic Frontier Foundation, une organisation qui lutte notamment en faveur du respect de la vie privée en ligne.

Fin 2011, Cory donnait une conférence mémorable au Chaos Communication Camp, que Framasoft avait traduite et relayée : « On ferme ! La guerre imminente contre nos libertés d’utilisateurs ».

Le 28 décembre 2025, l’hacktiviste faisait en quelque sorte une mise-à-jour avec une nouvelle conférence « Un Internet post-étasunien, conçu pour résister à la merdification », à l’occasion de la 39e édition du CCC à Hambourg en Allemagne.

Voici une traduction de la transcription de cette conférence, réalisée par Framalang.


L’internet post-étasunien.

Transcription de Cory Doctorow de sa propre conférence au 39C3. Traduction par Framalang (Ambar, Booteille, christian, Henri-Paul, Javier, jums, Kit, Lumi, MathildeC, pyg, retrodev, tcit).
Mise en forme pour le blog, mèmes, illustrations, hyperliens, : pyg. 

 

Vidéo de la conférence « Un Internet post-étasunien, conçu pour résister à la merdification »,
de Cory Doctorow, à l’occasion de la 39e édition du CCC à Hambourg en Allemagne.
.
(Sous-titres FRSous-titres EN)
 

 

La plupart d’entre vous savent que je suis militant engagé depuis bientôt 25 ans à l’Electronic Frontier Foundation (EFF). Mon regard est sans doute biaisé, mais, selon moi, aucun autre groupe au monde ne fait un aussi bon boulot que l’EFF pour défendre nos droits numériques.

Je suis donc militant à l’EFF, et, depuis un quart de siècle, je me suis engagé dans ce que j’appelle « La guerre de l’informatique grand public ».

Si vous étiez présent·e au 28C3, il y a 14 ans, vous avez peut-être assisté à l’une de mes conférences du même titre. C’est un de mes combats depuis mes premiers jours à l’EFF, notamment quand j’ai débarqué à Los Angeles, à l’inauguration d’un truc appelé Broadcast Protection Discussion Group, une alliance diabolique d’entreprises de la tech, de conglomérats médiatiques, de diffuseurs et de câblo-opérateurs.

Ils s’étaient rassemblés car Billy Tauzin, membre particulièrement corrompu du Congrès étasunien, leur avait promis une nouvelle réglementation : un texte interdisant la production et la vente d’ordinateurs, à moins que ces derniers ne soient paramétrés et bridés de sorte qu’ils ne puissent plus effectuer d’opérations jugées indésirables par les actionnaires des entreprises membres de l’alliance.
Cette règle, le « Broadcast Flag » avait été validée par la Commission fédérale des communications (FCC), organisme régulateur des télécoms étasuniens. Nous avons donc poursuivi la FCC devant la Cour fédérale et fait annuler ce texte de loi.

Nous avons gagné cette bataille, mais, les ami·e·s, j’ai de mauvaises nouvelles, des nouvelles qui ne vous surprendront pas. Malgré ce genre de victoire, depuis ces 25 dernières années, nous perdons la guerre de l’informatique grand public.

C’est pourquoi, plusieurs décennies plus tard, je suis de retour à Hambourg. Je tente, depuis des années, d’enfoncer une porte fermée à double tour : une porte qui mène à un Internet neuf et vertueux, un Internet qui nous offre à la fois l’autodétermination technologique de l’Internet d’autrefois et la facilité d’accès pour tous, nos semblables néophytes compris, de l’Internet 2.0. Cette porte, mes ami·e·s, vient de s’ouvrir.

Aujourd’hui, la voilà enfin entrebâillée. Enfin !

Et le plus étonnant dans tout cela, c’est que c’est grâce à Donald Trump.

Bien sûr, il ne l’a pas fait exprès ! Mais grâce à son agressivité incontrôlable, nous sommes à l’aube d’un Internet post-étasunien, un nouveau système nerveux numérique pour le XXIe siècle, un Internet qui pourra se construire sans que nous ayons à nous préoccuper des attentes et priorités des États-Unis.

Cependant ne vous méprenez pas, je n’apprécie ni Trump ni sa politique. Ne vous méprenez pas, car cela ne me fait pas plaisir que Trump soit au pouvoir et je suis encore moins fan de ses politiques. Mais, comme aime à le rappeler mon ami Joey DaVilla « Quand la vie te donne une épidémie, tu fais des vaccins ». Le seul truc pire que de vivre toute la terreur que Trump fait subir aux États-Unis et au monde entier, serait de subir tout cela sans réussir à en tirer quoi que ce soit.

C’est ce dont je veux parler aujourd’hui : l’internet post-étasunien que nous pouvons arracher au chaos créé par Trump.

Un internet post-étasunien est possible, car Trump a mobilisé une nouvelle coalition qui se bat à nos côtés. En politique, le plus important ce sont les coalitions. Chaque fois que vous voyez un groupe de personnes réussir d’un coup, là où elles avaient toujours échoué jusque-là, c’est que ces personnes ont réuni leurs forces dans une coalition, en mobilisant de nouveaux allié⋅es. Tous ne veulent pas la même chose, mais ont assez en commun pour se battre côte à côte.

Trump est un pur produit d’une de ces coalitions, tout droit sorti d’un agglomérat de milliardaires, de suprémacistes blancs, de chrétiens sectaires, d’autoritaires, de conspirationnistes, d’impérialistes, et de « libertariens » auto-proclamés qui ont une telle obsession avec la non-taxation qu’ils pourraient voter pour Mussolini s’il leur promettait de baisser les impôts d’un centime.

Ce qui me rend vraiment enthousiaste, c’est que nous avons une nouvelle coalition dans cette guerre de l’informatique grand public : une coalition qui inclut celles et ceux qui se battent pour nos droits numériques depuis des décennies, mais aussi des gens qui veulent transformer les milliards des géants du numérique étasuniens en milliards pour leur propre économie, et enfin des obsédés de la sécurité nationale inquiets, à juste titre, quant à la souveraineté numérique.

La thèse que je défends ici est que cette coalition est inarrêtable. Et ça, c’est une excellente nouvelle ! Pour la première fois depuis des décennies, la victoire est à portée de main.

Du coup, laissez-moi vous expliquer : il y a 14 ans, devant ce groupe, j’ai expliqué la « guerre de l’informatique grand public ». C’était mon petit nom accrocheur pour ce combat. Toutefois, le nom ennuyeux employé dans les textes législatifs est « anti-contournement ».

Selon les lois anti-contournement, il est illégal de modifier le fonctionnement d’un produit ou service numérique, sans le consentement du fabricant, et – point crucial – cela reste vrai même si cette modification n’enfreint aucune autre disposition légale.

Les lois anti-contournement nous viennent des États-Unis : la Section 1201 du Digital Millennium Copyright Act de 1998 définit le contournement par un « contrôle d’accès » d’une œuvre soumise au droit d’auteur comme un crime passible d’une peine de prison de cinq ans et d’une amende de 500 000 dollars dans le cas d’une première condamnation.

Section 1201 du Digital Millennium Copyright Act de 1998

Section 1201 du Digital Millennium Copyright Act de 1998. Source.

 

Donc, d’un point de vue pratique, si vous concevez un appareil ou un service doté d’un système, aussi fragile soit-il, qui empêche la modification du code de l’application ou du logiciel embarqué, alors la modification de ce code ou logiciel embarqué est un délit – passible de prison. Divulguer des informations concernant le contournement de ce contrôle d’accès est aussi un délit, ce qui signifie que des expert⋅es en sécurité informatique s’exposent à des poursuites pénales, même si elles ne font que décrire comment elles accèdent à un appareil ou à un système.

Avec les lois anti-contournement, n’importe quel fabricant peut facilement transformer son produit en une zone de non-droit, qui criminalise à la fois le fait d’examiner, rapporter et corriger ces failles.

Il s’agit d’une loi que Jay Freeman qualifie à juste titre de « outrage grave au modèle commercial ». L’anti-contournement est entré en vigueur en 1998 avec la signature du DMCA [ndt le Digital Millennium Copyright Act] par Bill Clinton. Mais avant que vous ne commenciez à railler ces stupides étasuniens, sachez ceci : tous les autres pays du monde ont voté une loi comme celle-là, depuis. Ici, en UE, c’est l’article 6 de la Directive européenne sur le droit d’auteur de 2001 qui marque le début de l’anti-contournement.

Il y a une certaine logique perverse à ce que les États-Unis promulguent une loi comme celle-ci. Après tout, ils sont la locomotive technologique du monde, berceau des plus grandes et plus puissantes entreprises de la tech. En rendant illégale la modification des produits numériques sans l’accord du fabricant, les États-Unis accroissent les capacités de rente extractive des entreprises les mieux cotées de la bourse étasunienne.

Mais pourquoi l’Europe aurait-elle passé une loi comme celle-là ? L’Europe importe massivement des technologies numériques. En élargissant la protection légale aux entreprises qui veulent voler les données et l’argent de leurs utilisateurices, l’UE permettait de faciliter un transfert de valeur à sens unique vers les États-Unis. Pourquoi l’Europe ferait-elle cela ?

Laissez-moi vous raconter les circonstances qui ont mené d’autres pays à promulguer leur loi anti-contournement et peut-être identifierez-vous un schéma qui répondra à la question.

L’Australie a eu sa loi anti-contournement via l’accord de libre-échange avec les États-Unis, obligeant l’Australie à promulguer une loi anti-contournement.

Le Canada et le Mexique l’ont eue via l’accord de libre-échange avec les États-Unis, obligeant le Canada et le Mexique à promulguer une loi anti-contournement.

Des nations andines comme le Chili ont eu la leur, via des accords bilatéraux de libre-échange avec les États-Unis, les obligeant à promulguer des lois anti-contournement.

Et des nations d’Amérique centrale ont eu la leur via le CAFTA – Central American Free Trade Agreement with the USA – (NdT : Zone de Libre-Échange de l’Amérique Centrale avec les États-Unis) qui les obligent à promulguer elles aussi une loi anti-contournement.

Mème : un cowboy, l'air peu rassuré, regarde au loin. Une astronaute le tient par l'épaule, montre le paysage de la main et dit, en souriant : « Des accords de libre-échange, Des accords de libre-échange partout ».

 

J’imagine qu’à ce stade, vous avez identifié le schéma : le représentant étasunien au commerce a obligé chacun de ses partenaires commerciaux à adopter une loi anti-contournement, pour faciliter l’extraction de données et d’argent de leur propre peuple par des entreprises étasuniennes. Mais bien sûr, cela ne fait que soulever une autre question : pourquoi tous les autres pays du monde accepteraient-ils de laisser les États-Unis voler les données et l’argent de leurs propres peuples, et empêcher leurs secteurs technologiques nationaux de faire des produits interopérables qui éviteraient ce vol ?

Voici une anecdote qui résout cette énigme : il y a de cela plusieurs années, avant que Viktor Orban n’accède au pouvoir, je donnais des conférences, en tant que conférencier invité, pour le programme doctoral d’été en sciences politiques de l’Université d’Europe centrale de Budapest. Et un été, à l’issue d’un cours portant sur la loi anti-contournement, un de mes étudiants m’approcha.

Il me dit qu’il avait été ministre de l’information d’un pays d’Amérique Centrale pendant les négociations du CAFTA et, un jour, il avait reçu un appel téléphonique de son négociateur commercial, qui appelait depuis la table des négociations. Le négociateur dit : « Tu sais à propos de ta consigne de ne donner aux étasuniens l’anti-contournement sous aucun prétexte ? Eh bien, ils disent qu’ils n’achèteront pas notre café à moins qu’on ne leur donne l’anti-contournement. Et je suis désolé mais nous ne pouvons tout simplement pas perdre le marché étasunien. Notre économie s’effondrerait. Donc on va leur donner l’anti-contournement. Je suis vraiment désolé. »

Voilà. C’est pour cela que tous les gouvernements du monde ont autorisé les géants du numérique étasuniens à déclarer ouverte la chasse aux données personnelles et aux profits faciles.Mème : deux boutons rouges, un dit « Filer nos données aux USA », l'autre « Ne plus vendre de produits aux USA ». Un homme tagué « Touts les États du monde (ou presque) » transpire en ne sachant sur quel bouton appuyer.

L’alternative c’était les droits de douane. Eh bien, je ne sais pas si vous êtes au courant, mais on a les droits de douane maintenant !

Je veux dire, si quelqu’un menace de brûler votre maison à moins que vous ne lui obéissiez et qu’ensuite il brûle quand même votre maison, vous n’êtes pas tenu de continuer à lui obéir. Alors… Vive la Libération ?

Jusqu’à présent, les pays du monde entier n’ont eu que deux réponses aux droits de douane de Trump.

La première était : « Donnons à Trump tout ce qu’il demande (sauf le Groenland) et peut-être qu’il arrêtera de s’en prendre à nous ». Celle-ci a été un échec absolu. Si vous donnez à Trump le doigt, il prend le bras. Il prendra ce fichu Groenland. La reddition est un échec.

Mais l’autre tactique n’est pas meilleure : les droits de douane en représailles. C’est ce que nous avons fait au Canada (comme tous les meilleurs Américains, je suis Canadien). Notre meilleure idée a été d’imposer des droits de douane sur les choses que nous importons depuis les États-Unis, ce qui a augmenté leur coût à l’achat. C’est une étrange manière de punir les États-Unis ! Comme se frapper soi-même très fort en espérant que le voisin du dessous dise « Aïe ! »

Et c’est sans distinction. Pourquoi coller des droits de douane sur le soja d’un pauvre fermier d’un État commençant et finissant par une voyelle ? Ce gars n’a jamais rien fait de mal au Canada.

Mais il y a une troisième réponse possible aux droits de douane. Une réponse qui n’attend qu’à être testée : et si on abrogeait les lois anti-contournement ?

 

Mème : sur l'autoroute, un panneau indique « Mettre des droits de douanes élevés sur tous les produits » tout droit et « Abroger les lois anti-contournement » sur la sortie à droite. Une voiture taguée « L'Europe » fait un dérapage pour prendre la sortie ; Texte 4 : « (dans un avenir idéal) ».

 

 

Si vous êtes un acteur de la Tech ou un investisseur installé dans un pays qui a abrogé sa loi anti-contournement, vous pouvez vous lancer dans la création de produits de dé-merdification, qui se branchent sur les technologies défectueuses exportées par les États-Unis pour permettre aux gens qui possèdent et utilisent ces produits de le faire à leur propre avantage, même si cela énerve les actionnaires.

Pensez aux tracteurs John Deere : quand le tracteur John Deere d’un fermier tombe en panne, on s’attend à ce qu’il le répare, en installant de nouvelles pièces pour remplacer ce qui ne fonctionne plus. Mais le tracteur ne reconnaît pas ces nouvelles pièces et refuse de démarrer tant que le fermier n’a pas dépensé quelques centaines de dollars pour faire appel à un réparateur John Deere officiel, dont le seul travail consiste à saisir un code de déverrouillage sur la console du tracteur, pour initialiser la pièce et l’associer à l’ordinateur central du tracteur.

Modifier un tracteur pour contourner cette étape d’activation est une violation de la loi anti-contournement. Cela signifie que des fermiers partout dans le monde sont coincés par cette arnaque, parce que leur propre gouvernement mettra sous les barreaux quiconque modifie un tracteur pour désactiver le système d’association de pièces de ce produit étasunien.

Mais que se passerait-il si le Canada abrogeait le projet de loi C-11 de la loi de modernisation du droit d’auteur de 2012 (c’est notre loi anti-contournement) ? Alors, une entreprise comme Honeybee, qui fabrique des capots de tracteurs, pourrait embaucher quelques bon·ne·s étudiant·e·s en informatique de l’Université de Waterloo, les mettre au travail sur le déverrouillage du logiciel des tracteurs John Deere, et le mettre à disposition du monde entier. Ils pourraient vendre la solution à toute personne disposant d’une connexion Internet et d’un moyen de paiement, y compris ce pauvre fermier étasunien dont nous avons soumis le soja à des droits de douane.

Il est difficile de mesurer les sommes en jeu ici. Prenons juste un exemple : l’App Store d’Apple. Apple force tous ses vendeurs d’application à utiliser son système de paiement, et prend une commission de 30 % sur chaque euro dépensé dans une application.

30 % ! C’est une affaire tellement rentable qu’Apple en tire 100 milliards de dollars chaque année. Si l’Union Européenne abrogeait l’article 6 de la Directive sur le droit d’auteur, quelques geeks malins en Finlande pourraient faire de la rétro-ingénierie sur les systèmes de démarrage d’App et créer un appareil qui déverrouille les téléphones afin qu’ils puissent utiliser des magasins d’application alternatifs. Ils pourraient vendre cet appareil, ainsi que l’infrastructure nécessaire pour faire tourner un magasin d’application à toute personne dans le monde qui souhaite entrer en compétition avec Apple pour capter ses utilisateurs et ses éditeurs d’applications.

Ces concurrents pourraient offrir une réduction de 90 % à tou·te·s les bricoleur·euse·s de Etsy, tou·te·s les artistes de Patreon, tous les médias d’actualité, tou·te·s les développeur·euse·s de jeux, tous les systèmes de VOD. Ils pourraient leur offrir 90 % de réduction sur les paiements et quand même gagner 10 milliards de dollars par an.

Peut-être la Finlande n’aura-t-elle jamais de nouveau Nokia, car c’est une affaire difficile à reproduire. Il faut fabriquer du matériel, ce qui est coûteux et risqué. Mais si l’Union Européenne légalise le déverrouillage, c’est Apple qui devrait engager tous les coûts et les risques de fabrication et de déploiement du matériel, tandis que ces geeks finlandais pourraient écrémer les 100 milliards de dollars qu’Apple pompe de l’économie globale par son arnaque à la rente illégitime.

Comme l’a dit Jeff Bezos aux éditeurs : « Vos marges bénéficiaires sont mes opportunités ». Avec ces gens-là, c’est toujours « disruption pour vous mais pas pour moi ». Quand ils nous font ça, ils appellent ça du progrès. Quand on le leur fait, c’est du piratage. Et tous les pirates veulent devenir des amiraux.

Eh bien, tant pis. Bougez vite et cassez les choses de Tim Cook. Bougez vite et cassez les rois ! [NdT : c’est une référence à la citation « move fast and break things » de Mark Zuckerberg. Doctorow emploie la formule « Move fast and break kings » dans la version originale aussi en référence au mouvement « No king » aux USA]

C’est marrant : j’ai passé 25 ans de ma vie à me faire botter les fesses par le bureau du représentant au commerce étasunien (pour ma défense, le combat n’était pas équilibré). J’ai développé une sorte d’admiration réticente pour leur capacité à lier le monde entier à un système commercial qui confère des avantages injustes aux États-Unis et à leurs entreprises, leur laissant le champ libre pour piller les données et les économies du monde. Il a donc été particulièrement impressionnant de regarder Trump démanteler en un clin d’œil le système commercial mondial et détruire la situation dans laquelle les affaires du monde étaient organisées pour protéger les intérêts de la classe capitaliste étasunienne.

Ce n’est pas le chemin que j’aurais choisi, évidemment. J’aurais préféré que cette avancée ait lieu sans Trump. Mais, si Trump insiste, j’accepte cet énorme but contre son camp. Je ne dis pas que je suis devenu accélérationniste, mais au point où on en est, je ne suis plus vraiment « non-accélérationniste ».

Vous devez avoir entendu dire que certains gouvernements ont tenté de pousser Apple à ouvrir son magasin d’application, et ils ont totalement échoué. Quand l’Union Européenne frappe Apple d’une ordonnance dans le cadre du Règlement sur les marchés numériques (DMA), Apple répond en proposant d’autoriser les magasins tiers, mais seulement s’ils vendent des applications qu’Apple a approuvées.

Mème : Anakin Skywalker (représentant Apple) dit « Nous allons autoriser d'autres appstores que le notre ». Padmé répond, sereine : « Et ces appstores pourront publier ce qu'ils veulent. ». Anakin a un sourire flippant. Padmé, moins rassurée, dit : « Et ces appstores pourront publier ce qu'ils veulent., hein ? » ;

Eh bien que ces magasins d’application puissent utiliser leurs propres systèmes de paiement, Apple leur facturerait tant de frais pourris que cela deviendrait plus cher. Et si Apple détermine qu’un téléphone a été utilisé hors de l’Union Européenne pendant plus de 21 jours, toutes les données et applications seraient supprimées.

Quand l’Union Européenne a expliqué que cela n’était pas conforme à la réglementation, Apple a menacé de se retirer de l’Union Européenne. Puis, une fois que tout le monde a cessé de rire, Apple a déposé plus d’une douzaine de recours bidon, dans le but de bloquer la situation dans les tribunaux pendant une décennie, tout comme Google et Meta l’ont fait pour le RGPD.

Il n’est pas clair que l’Union Européenne soit en capacité de forcer Apple à écrire du code qui ouvre la plateforme iOS à des magasins d’applications et des systèmes de paiement alternatifs. Mais il y a une chose que l’UE peut faire de manière fiable à 100 % : elle peut décider de ne pas laisser Apple utiliser les tribunaux européens dans le but de faire fermer les entreprises européennes qui déverrouillent les téléphones pour défendre les éditeurs, artistes, bricoleur·euse·s, médias d’actualité, développeur·euse·s de jeux et créateur·ice·s européen·ne·s contre les arnaques d’Apple.

Tout ce que l’Union Européenne a besoin de faire, c’est d’abroger l’Article 6 de la Directive sur le droit d’auteur et, ainsi, priver Apple du privilège d’utiliser le système judiciaire européen pour consolider sa taxe annuelle de 100 milliards de dollars sur l’économie numérique du monde. Les entreprises européennes qui réaliseront à quel point il est rentable de déverrouiller des iPhones auront des clients du monde entier, y compris des États-Unis, où Apple n’utilise pas seulement son veto pour décider quelles applications vous pouvez faire tourner sur votre téléphone pour siphonner 30 % de chaque dollar que vous dépensez, mais aussi pour retirer des applications qui protègent ses clients de la prise de pouvoir fasciste de Trump.

En octobre dernier, Apple a viré l’application « ICE Block » de l’App Store. C’est une application qui sert à prévenir les utilisateurs si une équipe de voyous masqués de l’ICE est dans les parages à la recherche de quelqu’un à kidnapper et à envoyer dans un goulag à l’étranger. Apple a classé en interne les kidnappeurs de l’ICE comme un « groupe protégé », et a déclaré que l’application ICE block était une atteinte aux droits de ces pauvres voyous de l’ICE.

 

Capture du site France Info : « Aux États-Unis, le succès d'ICEBlock, l'application signalant la présence d’agents chargés d’arrêter les sans-papiers »

Capture du site France Info : « Aux États-Unis, le succès d’ICEBlock, l’application signalant la présence d’agents chargés d’arrêter les sans-papiers ». Source.

 

Et puisque nous parlons des brutes de l’ICE, de nombreux techniciens qualifiés ont fui les États-Unis cette année, devançant les bataillons de l’ICE qui voulaient les placer ainsi que leurs enfants dans un camp. Ces hackers compétents vivent maintenant partout dans le monde, rejoints par des investisseurs qui aimeraient bien soutenir une affaire dont le succès sera déterminé par la qualité de ses produits, et non par le nombre de cryptomonnaies $TRUMP qu’ils achètent.

Les marges bénéficiaires d’Apple pourraient être leur opportunité.

Légaliser le déverrouillage, piller les activités aux plus hautes marges des entreprises les plus rentables des États-Unis est une bien meilleure réponse aux droits de douane de Trump que des représailles par droit de douanes.

En premier lieu, il s’agit d’une réponse ciblée : visez les marges des géants du numérique, et vous vous attaquez frontalement à ces entreprises dont les PDG ont chacun payé un million de dollars pour s’asseoir derrière Trump le jour de son investiture.

Piller les marges bénéficiaires des géants du numérique n’est pas une attaque contre le peuple des États-Unis, ni contre les petites entreprises des États-Unis qui se font arnaquer par les géants du numérique. C’est une attaque contre les entreprises qui arnaquent quotidiennement le monde entier comme les étasuniens. C’est un moyen de rendre chacun plus riche au dépend de ces entreprises arnaqueuses.

Et c’est vachement mieux que brûler des centaines de milliards de dollars pour construire des centres de données dédiés à l’IA dans l’espoir qu’un jour, un secteur qui a perdu un billion de dollars (mille milliards de dollars) pour produire des agents conversationnels pourris trouve enfin un usage aux cartes graphiques qui ne soit pas une hémorragie financière dès qu’ils les branchent.

Voilà donc nos nouveaux alliés dans la guerre de l’informatique grand public : des entrepreneurs et des techniciens qui veulent faire des milliards de dollars en pillant les marges bénéficiaires des géants du numérique, et des législateurs qui veulent que leur pays soit celui de la dé-merdification. Le pays qui n’a pas seulement protégé l’argent et la vie privée de son peuple en achetant des déverrouillages à d’autres pays, mais plutôt le pays qui a fait des milliards de dollars en vendant au reste du monde ces technologies de protection de la vie privée et du portefeuille.

C’est une alliance puissante, mais ce ne sont pas les seuls alliés que Trump a poussé dans notre camp. Il y a un autre allié puissant qui attend dans les coulisses.

Vous vous souvenez quand, en juin dernier, la Cour Pénale Internationale de la Haye avait publié un mandat d’arrêt contre le génocidaire Benjamin Netanyahou, et Trump avait désavoué la CPI, et la CPI avait alors perdu son accès à Outlook, ses archives email, ses fichiers de travail, ses carnets d’adresses, ses calendriers ?

 

Capture écran de l'article Next.ink : « Microsoft a supprimé le compte email du procureur de la Cour pénale internationale.

Capture écran de l’article Next.ink : « Microsoft a supprimé le compte email du procureur de la Cour pénale internationale. Source.

 

Microsoft a dit qu’ils n’avaient pas planté la CPI, que ce n’était qu’une coïncidence. Mais au petit jeu de « C’est lui qui l’a dit ! Non, c’est Clippy ! » entre les juristes de la CPI et les monopolistes condamnés de Microsoft, je sais qui croire.

C’est exactement le genre de risque infrastructurel dont on nous avait prévenu si nous laissions des entreprises chinoises comme Huawei fournir nos équipements téléphoniques essentiels. Quasiment tous les ministères, toutes les grandes corporations, toutes les petites entreprises et tous les foyers du monde se sont enfermés dans un service de cloud basé aux États-Unis.

La poignée d’entreprises du numérique étasuniennes qui fournissent les outils d’administration du monde entier sont vulnérables à la pression de l’administration Trump, et cela signifie que Trump peut planter une nation entière.

L’attaque contre la CPI était un acte de cyberguerre, tout comme les hackers russes qui arrêtent des centrales électriques ukrainiennes, sauf que Microsoft n’a pas besoin de pirater Outlook pour planter la CPI : elle possède Outlook.

En vertu du CLOUD Act de 2018, le gouvernement étasunien peut contraindre toute entreprise basée aux États-Unis à divulguer des données de ses utilisateurs – y compris celles de gouvernements étrangers – et peu importe l’endroit où sont stockées ces données. En juillet dernier, Anton Carniaux, directeur des affaires publiques et juridiques de Microsoft France, a déclaré à une commission d’enquête du gouvernement français [NdT, en fait il s’agit d’une commission d’enquête parlementaire, pouvoir législatif, et non du gouvernement, pouvoir exécutif] qu’il ne pouvait pas « garantir » que Microsoft ne transmettrait pas des données sensibles françaises au gouvernement étasunien, même si ces données étaient stockées dans un centre de données européen.

Et toujours en vertu du CLOUD Act, le gouvernement étasunien peut imposer des obligations de silence aux entreprises qu’il force à cracher ces données, tant et si bien qu’il n’y aurait aucun moyen de savoir si cela a eu lieu ou si c’est déjà arrivé auparavant.

Ça ne s’arrête pas aux outils administratifs : souvenez-vous, en 2022, lorsque les voyous de Poutine ont pillé des tracteurs John Deere d’une valeur de plusieurs millions de dollars en Ukraine et que ces tracteurs sont apparus en Tchétchénie ? L’entreprise John Deere les a éteints à distance et les a rendus inutilisables.

John Deere est aussi vulnérable que Microsoft face à l’administration Trump, et ils peuvent rendre inutilisable la plupart des tracteurs au monde. Et ceux qu’ils ne peuvent pas désactiver sont probablement faits par Massey Ferguson, deuxième entreprise du cartel agro-technologique, qui est aussi une entreprise étasunienne et tout aussi vulnérable face aux attaques politiques du gouvernement étasunien.

Mais bon, rien de tout cela ne surprendra les dirigeants mondiaux. Même avant que Trump et Microsoft ne rendent la CPI inopérante, ils essayaient déjà de trouver un moyen d’atteindre la « souveraineté numérique ». Mais l’attitude et la rhétorique scandaleuses de l’administration Trump au cours des 11 derniers mois ont fait passer la « souveraineté numérique » de facultative à essentielle.

Alors enfin, des choses se mettent en mouvement, comme « Eurostack« , un projet visant à cloner les fonctionnalités des silos des géants du numérique étasuniens sous forme de logiciels libres/open source, et à construire des centres de données basés dans l’Union Européenne sur lesquels on pourra déployer le code de ces logiciels.

 

Capture écran du site Eurostack.

Capture écran du site Eurostack.eu

 

Mais Eurostack va au devant d’une crise. C’est super de fabriquer des services ouverts, hébergés localement, auditables et dignes de confiance qui répliquent les fonctionnalités utiles des géants de la tech mais on a aussi besoin de construire les outils d’interopérabilité antagonistes qui permettent d’exporter en masse des millions de documents, les structures de données sensibles et les historiques de modifications.

On a besoin de scrapers et de navigateurs sans interface graphique pour mettre au point l’interopérabilité antagoniste qui garantira une continuité de service aux institutions encore hébergées par des services cloud étasuniens, car les entreprises étasuniennes ne faciliteront pas d’elles-mêmes l’exode massif de leurs clients internationaux hors de leurs plateformes.

Il suffit de voir comment Apple a répondu à la demande, relativement mineure, d’ouvrir l’App Store de iOS, pour imaginer l’amplitude du traînage de pied, de la bouderie et de la conformité malveillante qu’ils appelleront à leur rescousse face au départ de nombre d’entreprises et de gouvernements dans un bloc de 27 nations remplies de 500 millions de riches consommateurs.

Toute velléité de souveraineté numérique nécessite des outils de migrations qui fonctionnent sans la coopération des géants du numérique. Sinon c’est comparable à construire des habitations pour des Allemands de l’est et les situer à Berlin ouest. Quelle que soit la taille des logements, votre audience cible va avoir du mal à déménager si vous ne détruisez pas d’abord le mur.

La première étape pour détruire ce mur est de tuer les lois anti-contournement, afin que l’on puisse faire tourner des outils virtuels pouvant être scriptés, casser les systèmes de démarrage pour changer les micrologiciels et plus généralement prendre le contrôle des moyens de calcul.

C’est le troisième bloc de l’armée de dé-merdification : pas seulement les hippies des droits numériques, comme moi, pas seulement les entrepreneurs et le secteur économique se frottant les mains à l’idée de transformer les milliards étasuniens en millions européens mais aussi tous les faucons sécuritaires qui sont totalement confortés dans leur peur de l’abandon complet de leur sécurité numérique nationale aux mains de plateformes étasuniennes qui ont montré leur manque complet de fiabilité.

C’est comme cela que nous aurons un internet post-étasunien : avec une coalition inarrêtable d’activistes, d’entrepreneurs et de conseillers en sécurité intérieure.

Cela vient de loin. Depuis l’ordre international mis en place après la guerre [NdT : la deuxième guerre mondiale], le monde a traité les États-Unis comme une plateforme neutre, un garant de confiance stable des systèmes essentiels aux échanges mondiaux. C’est ce que les politologues Henry Farrell et Abraham Newman appellent « l’Empire souterrain ». Mais lors des 15 dernières années, les États-Unis ont systématiquement brisé la confiance mondiale en leurs institutions, un processus qui n’a fait que s’accélérer sous Trump.

Prenez les câbles à fibre optique transocéaniques : la manière dont les routes que suivent ces câbles sont planifiées fait que la majorité d’entre eux font escale sur les côtes des États-Unis, là où les interconnexions sont gérées. Il y a de bons arguments en faveur de cette topologie de réseaux en étoile, surtout en comparaison avec la mise en place de liaisons directes entre tous les pays. Ce serait un problème de complexité O(N²) : relier directement chacun des 205 pays de la planète Terre les uns avec les autres nécessiterait 20 910 liaisons en fibre.

Capture écran du site https://www.submarinecablemap.com/

Capture écran du site https://www.submarinecablemap.com/ (oui, les fans d’histoire-géographie et de topologie y reconnaîtront quasiment trait pour trait une carte coloniale du 19e siècle)

 

Mais mettre tous les œufs des télécommunications mondiales dans le (même) panier étasunien ne marche que si les États-Unis ne tirent pas profit de leur centralité. Et alors que beaucoup de gens se souciaient de ce que les États-Unis pouvaient faire à la tête de l’infrastructure mondiale, ce n’est qu’avec les révélations de Mark Klein en 2006 sur les écoutes à l’échelle nationale de la NSA du réseau de fibres optiques de AT&T, et les documents d’Edward Snowden en 2013 qui montraient l’ampleur mondiale de ces écoutes, que le monde a dû se confronter à cette réalité indéniable : on ne pouvait plus faire confiance aux États-Unis comme centre mondial de la fibre.

Ce n’est pas que de la fibre. Le monde fait affaire en dollars. La plupart des pays maintiennent des comptes en dollars à la Réserve Fédérale étasunienne comme principale source de réserves de change. Mais en 2005, des fonds vautours étasuniens ont racheté des milliards de dollars de bons du Trésor argentin après que la nation souveraine d’Argentine se soit déclarée en faillite.

Ils ont convaincu un juge à New York de leur céder les avoirs étasuniens du gouvernement argentin pour percevoir le remboursement de prêts que ces recouvreurs de dette n’avaient pas émis, mais qu’ils avaient acheté pour une bouchée de pain. À ce moment-là, tous les gouvernements du monde ont dû se confronter au fait qu’ils ne pouvaient pas faire confiance à la Réserve Fédérale étasunienne pour leurs réserves de change. Mais qu’auraient-ils pu faire d’autre ?

Sans réponse claire, la domination du dollar continua, mais ensuite, sous Biden, les oligarques alignés avec Poutine et les entreprises russes ont perdu l’accès au système SWIFT [NdT, un réseau de messagerie sécurisé utilisé par les banques du monde entier pour se transmettre des ordres de paiement] pour le règlement en dollars. Puisque les biens – tels que le pétrole – sont vendus en dollars, ces acheteurs doivent seulement trouver quelqu’un qui échange leur propre monnaie en dollars, qu’ils peuvent alors échanger contre n’importe quel bien dans le monde.

Encore une fois, il y a un bon argument en faveur du règlement en dollars : il n’est tout simplement pas pratique d’avoir à gérer les quasi 200 devises du monde de pair à pair. C’est un autre problème de complexité O(N²).

Mais cela ne marche que si le dollar est une plateforme neutre. À partir du moment où le dollar devient un instrument de la politique étrangère étasunienne, que vous soyez d’accord avec cette politique ou pas, ce n’est plus une plateforme neutre et le monde entier se met à la recherche d’alternatives.

Personne ne sait ce que cette alternative sera, tout comme personne ne sait quelle disposition finiront par prendre les liaisons fibre du monde entier. Il y a des kilomètres de fibre déployées sur les fonds océaniques, et des pays sont en train de tenter des paris plutôt improbables en guise d’alternative au dollar, comme l’Éthiopie qui réévalue sa dette souveraine en renminbi chinois [NdT, nom officiel du yuan, la monnaie chinoise]. Sans une alternative claire aux plateformes américaines merdifiées, le siècle post-étasunien est bon pour un départ sur des chapeaux de roue.

Mais il y a un système post-étasunien qui est facile à imaginer.

Le projet de remplacer toutes les boites noires connectées au cloud, dotées de portes dérobées et auxquelles on ne peut pas se fier, qui font tourner nos institutions, nos implants médicaux, nos véhicules et nos tracteurs, par un code ouvert, libre, fiable, vérifiable et maintenu collectivement.

Ce projet est le seul qui tire profit des économies d’échelle au lieu de se retrouver paralysé par des crises exponentielles de mise à l’échelle. Cela vient du fait que n’importe quel outil libre et ouvert adopté par une institution publique – comme les services Eurostack – peut être audité, localisé, soumis à des tests de sécurité, débogué et amélioré par des institutions de tous les autres pays.

C’est un bien commun, plutôt comme une science que comme une technologie. Il est universel, international et collaboratif. Nous n’avons pas de principes concurrents pour l’ingénierie structurelle entre la Chine et l’Occident. Nous avons plutôt des principes universels pour nous assurer que les bâtiments ne s’écroulent pas, adaptés aux circonstances locales.

Nous ne tolérerions pas de secret dans les calculs effectués pour maintenir nos bâtiments debout et nous ne devrions pas tolérer d’opacité dans le logiciel qui maintient en activité nos tracteurs, prothèses auditives, ventilateurs, pacemakers, trains, jeux de console, téléphones, caméras de surveillance, serrures et ministères gouvernementaux.

 

Mème : dans le Seigneur des anneaux, Boromir, l'air inquiet, dit « On ne peut pas simplement redonner l'accès à nos outils du quotidien ».

 

Le fait est que le logiciel n’est pas un atout, c’est une responsabilité.

Les capacités que l’exécution d’un logiciel apporte – automatisation, production, analyse et administration – ça, ce sont des atouts. Mais le logiciel en lui-même ? C’est une responsabilité. Vulnérable, fragile, qui tombe sans cesse en panne au fur et à mesure que les logiciels en amont, en aval ou qui lui sont accolés sont mis à jour ou remplacés, révélant au passage des défauts ou des défaillances dans des systèmes qui ont pourtant bien marché depuis des années.

Passer à une production de logiciel basée sur les biens communs est un moyen de réduire les responsabilités que le logiciel impose à ses créateurs et utilisatrices, en répartissant cette responsabilité entre plusieurs acteurs.

Évidemment, les patrons du secteur du numérique sont complètement à l’ouest sur ce sujet. Ils croient que le logiciel est un atout. C’est pour ça qu’ils sont si excités par leurs chatbots qui chient des logiciels à des vitesses surhumaines. Ils pensent qu’il est bon d’avoir un chatbot qui « produit mille fois plus de code qu’une développeuse ».

Produire du code qui n’est pas conçu pour la lisibilité et la maintenabilité, mais qui est plutôt optimisé pour la vitesse de production est un moyen d’accumuler de la dette technique à grande échelle.

C’est un parfait résumé de toute cette histoire d’IA : le chatbot ne peut pas faire ton travail mais un commercial qui vend des IA peut convaincre ton patron de te virer et de te remplacer par un chatbot qui ne peut pas faire ton travail.

Ton patron est une cible facile pour le vendeur de chatbot qui racole, parce que ton patron te déteste. Les patrons savent bien que s’ils ne venaient pas travailler, les affaires continueraient à tourner toutes seules, mais si les travailleurs arrêtaient de se pointer, l’entreprise s’effondrerait instantanément.

Les patrons aiment à croire qu’ils sont à la place du conducteur, mais ce qu’ils redoutent le plus c’est d’être attachés à la banquette arrière avec un volant Fisher Price. Pour eux, l’IA est un moyen de relier directement le volant jouet à la transmission du véhicule. C’est l’accomplissement du fantasme de l’entreprise sans travailleuses.

Quand j’étais allé au piquet de grève à Hollywood pendant la grève des scénaristes, l’un d’eux m’a raconté qu’on prompte une AI de la même manière qu’un patron de studio donne ses mémos pourris à une équipe de scénaristes : « Faites moi E.T. mais centrez le autour d’un chien et donnez lui une histoire d’amour et une course-poursuite en voiture pendant le troisième acte ».

Dites ça à des scénaristes, iels vous traiteront d’idiot en costard et iels vous diront « Pourquoi tu retournes pas dans ton bureau sur ton fichier Excel. Ici, les adultes sont en train d’écrire un film ».

À l’inverse, si vous donnez ce prompt à un chatbot, il chiera allègrement un script qui colle à la demande. Le fait que ce script soit affreux et inutilisable est moins important que la perspective d’une vie de travail où personne ne vous traite d’idiot en costard.

L’IA fait miroiter la promesse d’une équipe de scénaristes sans scénariste, d’un film sans actrice, d’un hôpital sans infirmier, d’une agence web sans développeuse.

 

Mème : le méchant Gru fait un plan. Il est très exalté et sûr de lui sur les trois premières images où son plan est : « 1. S'inspirer d'un film à succès », « 2. Demander à l'IA quelques variations scénaristiques » et « 3. Se retrouver avec une grosse bouse qui fait un flop ». Sur la quatrième image, il devient soudain très incertain et penaud devant « 3. Se retrouver avec une grosse bouse qui fait un flop ».

 

Quand Mark Zuckerberg avait déclaré dans un podcast que l’étasunien moyen avait trois amis, mais qu’il voulait en avoir 15 et qu’il pourrait satisfaire ce besoin en nous donnant des chatbots comme amis, on lui est tous tombé dessus en le traitant de martien milliardaire déconnecté qui ne comprenait rien à la nature de l’amitié.

Mais la réalité, c’est que pour Zuck, vos amis sont un problème. Les interactions avec vos amis déterminent combien de temps vous passez sur ses plateformes et donc combien d’annonces publicitaires rémunérées il peut vous montrer.

Vos amis refusent obstinément d’organiser leur relation avec vous afin de maximiser la rentabilité pour ses actionnaires. Du coup Zuck est là-bas, à Menlo Park, en train de fantasmer furieusement sur le remplacement de vos amis par des chatbots, parce que, comme ça, il pourra enfin atteindre le rêve d’un service de média social sans aucune sociabilité.

Les riches et les puissants sont, à la base, des solipsistes. Le seul moyen d’amasser un milliard de dollars est d’infliger des misères et des privations à des pans entiers de la population. Le seul moyen de se regarder dans la glace après avoir fait ça, c’est de se convaincre que ces gens ne comptent pas et que, d’une certaine manière, ils ne sont pas réels.

Pensez à Elon Musk traitant quiconque n’étant pas d’accord avec lui de « PNJ » [NdT : un « personnage non jouable », i.e un personnage « figurant » non contrôlé par un joueur] ou pensez à tous ces « altruistes efficaces » qui pensent avoir une morale supérieure en prétendant se soucier de 53 billions d’humains imaginaires qui existeront dans 10 000 ans, au détriment de la considération morale due aux personnes vivantes d’aujourd’hui.

Ou encore à la manière dont Trump a viré tous les scientifiques du gouvernement étasunien, puis a annoncé le lancement du programme « Genesis », avec pour objectif que les États-Unis produiront des avancées scientifiques annuelles d’une magnitude comparable à un lancement vers la Lune, via un chatbot. La science sans scientifiques.

Les chatbots ne peuvent pas vraiment faire de science mais, aux yeux de Trump, ils seront toujours meilleurs que des scientifiques, parce qu’un chatbot ne lui dira jamais de ne pas regarder directement une éclipse ou de ne pas s’injecter de l’eau oxygénée dans les veines. Un chatbot ne lui dira même pas que les personnes transgenres existent ou que l’urgence climatique est réelle.

Les puissants sont à fond sur l’IA parce qu’elle alimente leurs fantasmes d’un monde sans humains : un patron, un ordinateur uniquement. Pas de confrontations avec des gens compétents en train de vous dire « non » qui leur ferait mal à l’égo.

L’IA est un moyen de produire de la dette technique à grande échelle, de remplacer des écrivains talentueux par des systèmes d’autocomplétion approximatifs et défaillants, et de perdre de l’argent dans des proportions jamais observées de mon vivant.

Comparez ça avec la construction d’un internet post-étasunien : qui réduit la dette technique, qui libère les billions du monopole étasunien, puis les répartit aux entrepreneurs du monde entier (pour qui cela représente des profits inouïs) et aux utilisateurices du monde entier (pour qui cela représente des économies inouïes) ; tout cela en consolidant résilience et souveraineté.

Bon, certain⋅es d’entre vous sont probablement un peu cyniques sur ce sujet à l’heure actuelle. Après tout, vos dirigeants politiques ont fait étalage d’une déférence inefficace et incompétente à l’égard des États-Unis pendant des décennies, et d’une incapacité à agir, même quand le besoin était urgent. Si nos dirigeants n’ont pas pu agir résolument face à l’urgence climatique, quel espoir avons-nous de les voir prendre ce moment historique au sérieux ?

Mais les crises accélèrent le changement. Vous vous souvenez quand un autre empereur fou – Vladimir Poutine – a envahi l’Ukraine et que l’Europe a dû faire face à une pénurie d’énergie soudaine ? En trois petites années, l’adoption du solaire a atteint des sommets sur le continent. L’UE est passée de 15 ans de retard dans la transition énergétique à 10 ans d’avance sur ses prévisions.

 

Mème : en haut, Sophie (représentant l'Europe) n'aime pas « 15 ans de retard sur la transition énergétique » ; en bas, Sophie aime « 10 ans d'avance sur les prévisions ».

 

Parce que quand vous tremblez dans le noir, beaucoup de batailles que vous ne pensiez pas dignes d’être menées deviennent soudainement des batailles existentielles que vous ne pouvez pas vous permettre de perdre.

Bien sûr, personne ne veut se chamailler avec un voisin pénible qui pique une crise de colère esthétique rien qu’à l’idée d’un panneau solaire accroché au balcon de son voisin. Mais quand vient l’hiver, qu’il n’y a plus de gaz russe et qu’on tremble dans le noir, alors cette personne peut prendre ses objections esthétiques, les replier plusieurs fois et se les fourrer dans le derrière.

De toute façon, nous n’avons pas besoin que l’Europe mène la charge vers un Internet post-étasunien en abrogeant les lois anti-contournement. N’importe quel pays pourrait le faire ! Et le pays qui le fait en premier va profiter du fait de fournir des outils de déverrouillage au reste du monde, il deviendra la Nation de la Dé-merdification, et le reste du monde pourra acheter ces outils et se défendre contre le pillage financier et de la vie privée des entreprises étasuniennes.

Il suffit qu’un seul pays brise le consensus, et les arguments pour que tous les pays le fassent n’ont jamais été aussi puissants. Avant, les pays qui dépendaient de USAID [NdT: l’Agence de Développement étasunienne, qui avait divers programmes d’assistance en place] risquaient de perdre un soutien alimentaire, sanitaire et monétaire s’ils se mettaient à dos les États-Unis. Mais Trump a détruit USAID, donc cette dépendance a disparu.

Pendant ce temps, la place des États-Unis en tant que plus gros consommateur de la planète a été démolie par des décennies de politiques anti-travailleureuses et pro-milliardaires. Aujourd’hui, les États-Unis sont aux prises avec leur troisième reprise « en forme de K » , c’est-à-dire une reprise économique où les riches s’enrichissent, et les autres s’appauvrissent. Pendant une génération, les États-Unis ont dissimulé cette inégalité grandissante avec des crédits faciles à obtenir, les étasuniens moyens finançant leur consommation avec des cartes de crédit et une seconde ou une troisième hypothèque.

Tant qu’iels pouvaient se permettre de continuer à acheter, les autres pays devaient se préoccuper des États-Unis en tant que marché d’export. Mais une extraction longue a laissé les 90 % des étasuniens les plus pauvres en difficulté pour acheter à manger et des produits de première nécessité, les frais de logement, d’éducation et de santé qui s’envolent produisant des dettes écrasantes qu’iels ne peuvent espérer rembourser, suite à 50 années de stagnation des salaires.

L’administration Trump s’est rangée fermement du côté des créanciers, des escrocs et des rentiers. Trump a neutralisé les plaintes contre les agences immobilières qui augmentent les loyers, telles que Realpage, relancé le recouvrement des dettes de 8 millions d’étudiant·e·s, et mis fin à un plan qui visait à rendre les médicaments essentiels un peu moins chers, laissant les étasuniens payer les prix les plus élevés au monde pour les médicaments.

Chaque dollar dépensé pour payer un emprunt est un dollar qui n’est pas dépensé pour la consommation. Et alors que toujours plus d’étasuniens glissent dans la pauvreté, les États-Unis détruisent les programmes qui profitent au public, comme SNAP, le programme de bons alimentaires qui évite la famine à une part toujours plus grande d’étasuniens.

Les États-Unis poursuivent le rêve d’un « monde sans les gens », dans lequel les travailleurs n’ont rien, ne dépensent rien, et donnent chaque centime à des rentiers qui injectent rapidement cet argent dans le marché financier, les crypto-merdes ou les sites de paris. Mais je me répète.

Même l’armée étasunienne – longtemps une institution sacro-sainte – est mise à genoux pour enrichir les rentiers. Le Congrès vient d’enterrer une loi sur le « droit à la réparation » militaire. Maintenant, les soldats étasuniens basés à l’étranger vont devoir poursuivre la fière tradition du Pentagone de renvoyer le matériel, des générateurs aux jeeps, jusqu’aux États-Unis pour qu’ils soient réparés par leurs fabricants avec une marge de 10 000 %, parce que le Pentagone signe régulièrement des contrats de maintenance qui interdisent d’apprendre à un Marine comment réparer un moteur.

Le monde post-étasunien est vraiment en train d’arriver à toute vitesse. Au fur et à mesure qu’on abroge nos lois anti-contournement, on n’a plus à se soucier de ce que pensent les États-Unis, on n’a plus à se soucier de ses droits de douane parce qu’ils sont déjà en train de nous taper avec des droits de douane ; et parce que les seules personnes qui peuvent encore s’acheter des choses aux États-Unis sont les riches, qui n’achètent pas assez de choses. Il y a une limite au nombre de Lambos [NdT, diminutif de la marque de voiture Lamborghini] et de Sub-Zeros [NdT, marque de réfrigérateur de luxe] qu’un ploutocrate, même le plus guillotinable, peut posséder.

Mais que se passerait-il si les entreprises européennes voulaient continuer à tirer profit des lois anti-contournement ? Eh bien il y a de bonnes nouvelles de ce côté-là également. « Bonnes nouvelles » parce que les entreprises européennes qui dépendent de l’anti-contournement sont impliquées dans les fraudes les plus sordides et dégoûtantes que l’on puisse imaginer.

Les lois anti-contournement sont la raison pour laquelle Volkswagen a pu s’en sortir avec le Dieselgate. En imposant une responsabilité juridique à ceux qui auraient pu découvrir ce crime létal en faisant de la rétro-ingénierie, l’article 6 de la loi sur le droit d’auteur a créé un effet dissuasif et des milliers d’européens sont morts chaque année.

 

Mème : dans une usine, un homme blasé s'apprête à remplacer le zéro par un autre zéro dans la phrase « zéro jours sans que des vies soient perdues à cause de lois à la con sur le numérique, visant à maximiser les profits ».

 

Aujourd’hui, les constructeurs automobiles allemands perpétuent la tradition du Dieselgate, en sabotant leurs voitures pour prélever de l’argent aux conducteurs. Cela va de Mercedes, qui vous loue la pédale d’accélération de votre voiture de luxe et ne vous débloque la pleine accélération du moteur qu’en payant une souscription mensuelle, jusqu’à BMW, qui vous loue le système qui diminue automatiquement vos feux de route lorsqu’il y a des véhicules qui arrivent en face.

Légalisez le déverrouillage et n’importe quel garagiste en Europe pourrait débloquer ces fonctionnalités qui marchent à l’abonnement pour un paiement en une fois, sans rien en reverser à BMW et Mercedes.

Et puis il y a Medtronic, une entreprise qui prétend être irlandaise. Medtronic est la plus grande entreprise technologique dans le secteur médical, ayant racheté tous ses concurrents, et qui a ensuite entrepris la plus grande « inversion fiscale » de l’histoire, en se vendant à une petite entreprise irlandaise de manière à transformer comme par magie leurs profits en un état de grâce fiscale qui flotte sur la mer d’Irlande.

Medtronic fournit au monde les ventilateurs les plus répandus et les a piégés de la même manière que John Deere piège ses tracteurs. Après qu’un technicien hospitalier remplace une pièce dans un ventilateur Medtronic, l’unité centrale du ventilateur refuse de reconnaître ce composant tant qu’une validation cryptographique n’a pas été effectuée, prouvant ainsi qu’un technicien habilité par Medtronic a été payé des centaines d’euros pour certifier une réparation que le technicien de l’hôpital aurait probablement pu faire lui-même.

C’est juste une manière de pomper des centaines d’euros des hôpitaux chaque fois qu’un ventilateur tombe en panne. En soi, c’est déjà assez vilain comme ça mais pendant les confinements dus au Covid, quand chaque ventilateur était d’une nécessité vitale et que les avions ne volaient plus, il n’y avait pas moyen qu’un technicien Medtronic vienne et bénisse les réparations techniques. Ce fut létal. Cela a tué des gens.

Il y a une autre société européenne qui compte sur l’anti-contournement dont je voudrais discuter ici parce que ce sont de vieux amis du CCC : il s’agit de la compagnie de trains polonaise Newag. Newag sabote ses propres locomotives, les piégeant de manière à ce que si jamais elles détectent qu’elles ont été déplacées dans le périmètre d’une compagnie concurrente, le train se met à l’arrêt. Quand l’opérateur du train appelle Newag à propos de ce mystérieux problème, la société se montre « aidante » en accédant aux ordinateurs de la locomotive pour effectuer des « diagnostics » qui ne sont rien d’autre qu’une commande de redémarrage qu’ils facturent 20 000 euros.

L’année dernière, des hackers polonais de la société de recherche en sécurité Dragon Sector ont présenté leurs découvertes sur cet odieux racket ici-même dans cette salle et, maintenant, ils sont poursuivis par Newag car dévoiler de manière avérée les produits intentionnellement défaillants de Newag contrevient aux lois anti-contournement.

Voici donc les acteurs en faveur des lois anti-contournement : les assassins du Dieselgate, les fabricants de voiture qui veulent vous louer vos phares et votre pédale d’accélération, le géant médical qui a planté tous les ventilateurs pendant la pandémie et la société qui a amarré la Pologne aux voies ferrées.

Je savoure l’opportunité de combattre ces bâtards à Bruxelles et de les voir se pointer et chouiner « Personne ne pense aux saboteurs de train ? ».

La merdification de la technologie, le délabrement des plateformes et systèmes sur lesquels on compte, a de nombreuses causes : l’effondrement de la compétition, la capture réglementaire [NdT, d’après wikipedia, « corruption de l’autorité qui se produit lorsqu’une entité politique, un législateur ou un organisme de réglementation est coopté pour servir les intérêts commerciaux, idéologiques ou politiques d’un membre mineur, tel qu’une aire géographique, une industrie, une profession ou un groupe idéologique »] et l’écrasement des travailleurs de la tech. Mais surtout, la merdification est le résultat de l’interdiction d’interopérabilité des lois anti-contournement.

En bloquant l’interopérabilité, en déclarant la guerre à l’informatique grand public nos décideurs ont créé un environnement merdigène qui a récompensé les entreprises qui se sont montrées merdiques et ont inauguré le merdocène, dans lequel tout est en train de se transformer en merde.

 

emoji "caca"

Vision de l’auteur concernant le monde merdifié. — Allégorie.                         (vous noterez au passage l’inventivité de nos traducteurices sur ce type de passages :) )

 

 

Marquons un temps d’arrêt dans la merdification.

Réapproprions-nous les moyens informatiques. Construisons des alternatives, gratuites, ouvertes, et auditables aux services et logiciels dont nous dépendons.

Mettons un terme à l’ère des silos. Je veux dire, est-ce que ce n’est pas foutrement bizarre à quel point on doit se soucier de savoir quelle application ou réseau une personne utilise si on veut communiquer avec elle ? Au lieu de juste avoir à se demander à qui on veut parler ?

Le fait qu’on ait à déterminer si la discussion à laquelle on veut se joindre se déroule sur Twitter ou Bluesky, Mastodon ou Instagram, c’est la manière la plus Prodigy/AOL/Compuserve [NdT, Fournisseurs d’Accès Internet américains historiques, chacun d’entre eux doté de son propre écosystème] de faire tourner un monde numérique. Je veux dire, 1990 a appelé, et il veut récupérer son jardin clos.

De puissants alliés se joignent à nous dans notre guerre de l’informatique grand public. Ce ne sont pas juste des gens comme nous, qui nous battons pour cela depuis que ce foutu siècle a commencé, mais aussi des pays qui veulent convertir les billions sur lesquels est assise la technologie étasunienne en combustible pour une fusée à usage unique qui propulse leur propre secteur technologique vers une orbite stable.

Ce sont les faucons de la Sécurité Nationale qui sont inquiets que Trump plante leurs ministères ou leurs tracteurs et qui sont aussi préoccupés, à juste titre, par Xi Jinping plantant leurs convertisseurs solaires et leurs batteries. Parce qu’après tout, l’internet post-étasunien est aussi un internet post-chinois.

Aucun champ de saisie ne devrait être conçu pour pouvoir être mis à jour sans l’autorisation de l’utilisateur. Rien de critique ne devrait être une boîte noire.

Comme je l’ai dit au début de cette conférence, je fais ce travail depuis 24 ans à l’Electronic Frontier Foundation, me jetant continuellement contre une porte verrouillée à double tour et maintenant que cette porte s’est entrouverte, bon sang de bonsoir, j’ai de l’espoir.

Je ne suis pas optimiste. Aux chiottes l’optimisme ! L’optimisme c’est l’idée que les choses vont s’arranger quoi qu’on fasse. Je sais que ce qu’on fait compte. L’espoir, c’est la conviction que si nous pouvons améliorer les choses, même de manière réduite, nous pouvons gravir la pente vers le monde que nous voulons et atteindre des points de vue plus élevés d’où nous verrons de nouveaux moyens d’action, invisibles à notre altitude actuelle, se révéler.

L’espoir est une discipline. Cela demande de ne pas céder au désespoir. C’est pourquoi je suis ici pour vous dire : ne désespérez pas.

Pendant toute cette décennie, partout dans le monde, des pays ont pris les armes contre des conglomérats de pouvoir concentré. Nous avons eu de grosses attaques bien musclées contre les grosses corporations étasuniennes (sous Trump I et sous Biden) ; au Canada, au Royaume-Uni, dans l’Union Européenne et dans des pays membres comme l’Allemagne, la France et l’Espagne, en Australie, au Japon, en Corée du Sud, à Singapour, au Brésil et en Chine.

C’est un retournement de conjoncture quasi miraculeux. Partout dans le monde, les gouvernements déclarent la guerre aux monopoles, la source de richesse et de pouvoir des milliardaires.

 

Mème. Texte 1 : « Gouvernements  ; Texte 2 : « Guerre contre les monopoles et les milliardaires » ; Texte 3 : « Société civile ».

L’auteur de ce mème est un peu moins enthousiaste que l’auteur de la conférence.

 

Même le vent le plus fort est invisible. Nous ne pouvons que voir ses effets. Ce que nous voyons ici c’est que quand un politicien décidé à limiter le pouvoir des conglomérats lève une voile, peu importe où se trouve ce politicien dans le monde, sa voile se gonfle de vent et propulse sa politique d’une manière que nous n’avions pas vue depuis plusieurs générations.

La longue accalmie de la bataille contre le pouvoir des conglomérats s’est terminée et un vent féroce et inarrêtable est en train de souffler. Il ne souffle pas qu’en Europe, au Canada, en Corée du Sud, au Japon, en Chine, en Australie ou au Brésil. Il souffle en Amérique également. N’oubliez pas qu’aussi foireux et terrifiants que soient les évènements aux États-Unis, le pays a traversé et continue de traverser un tsunami de projets de loi antitrust et de mesures coercitives à des échelles locales et fédérales.

Et n’oubliez pas qu’un internet post-étasunien sera bon pour les étasuniens. Parce que dans des États-Unis en forme de K, divisés et inégalitaires, les billions que pillent les entreprises étasuniennes ne ruissellent pas jusqu’aux étasuniens. L’étasunien moyen détient un portefeuille d’actions proche de zéro et cela inclut les actions dans la Silicon Valley.

L’étasunien moyen n’est pas actionnaire dans un géant du numérique, l’étasunien moyen est une victime des géants du numérique. Libérer le monde des géants du numérique étasuniens, c’est aussi libérer les États-Unis des géants du numérique étasuniens.

Cela a été la mission de l’EFF pendant 35 ans. Cela a été ma mission à l’EFF pendant 25 ans. Si vous voulez vous impliquer dans cette bataille, et j’espère que vous le voulez, cela peut être votre mission, à vous aussi. Vous pouvez rejoindre l’EFF dans votre pays, comme Netzpolitik ici en Allemagne ou l’Irish Council for Civil Liberties, ou La Quadrature du Net en France ou l’Open Rights Group du Royaume-Uni, ou EF Finlande ou ISOC Bulgarie, XNet, DFRI, Quintessenz, Bits of Freedom, Openmedia, FSFE ou n’importe laquelle des douzaines d’organisations autour du monde.

La porte est entrouverte, le vent souffle, l’internet post-étasunien est devant nous : un internet nouveau et bon, qui apporte toute l’autodétermination du bon vieil internet et la facilité d’utilisation du Web 2.0 pour que tout le monde puisse en profiter.

J’ai tellement hâte qu’on y traîne tous et toutes ensemble. Ça va être génial.

Thibault Martin: TIL that Pagefind does great client-side search

16 April 2026 at 10:00

I post more and more content on my website. What was visible at glance then is now more difficult to look for. I wanted to implement search, but it is a static website. It means that everything is built once, and then published somewhere as final, immutable pages. I can't send a request for search and get results in return.

Or that's what I thought! Pagefind is a neat javascript library that does two things:

  1. It produces an index of the content right after building the static site.
  2. It provides 2 web components to insert in my pages: <pagefind-modal> that is the search modal itself, hidden by default, and <pagefind-modal-trigger> that looks like a search field and opens the modal.

The pagefind-modal component looks up the index when the user types a request. The index is a static file, so there is not need for a backend that processes queries. Of course this only works for basic queries, but it's a great rool already!

Pagefind is also easy to customize via a list of CSS variables. Adding it to this website was very straightforward.

GDB source-tracking breakpoints

Image

One of the main abilities of a debugger is setting breakpoints.
GDB: The GNU Project Debugger now introduces an experimental feature
called source-tracking breakpoints that tracks the source line a breakpoint
was set to.

Introduction

Imagine you are debugging: you set breakpoints on a bunch of
source lines, inspect some values, and get ideas about how to change your
code. You edit the source and recompile, but keep your GDB session running
and type run to reload the newly compiled executable. Because you changed
the source, the breakpoint line numbers shifted. Right now, you have to
disable the existing breakpoints and set new ones.

GDB source-tracking breakpoints change this situation. When you set a
breakpoint using file:line notation, when this feature is enabled, GDB
captures a small window of the surrounding source code. When you recompile
and reload the executable, GDB adjusts any breakpoints whose lines shifted
due to source changes. This is especially helpful in ad-hoc debug sessions
where you want to keep debugging without manually resetting breakpoints
after each edit-compile cycle.

Setting a source-tracking breakpoint

To enable the source-tracking feature, run:

(gdb) set breakpoint source-tracking enabled on

Set a breakpoint using file:line notation:

(gdb) break myfile.c:42
Breakpoint 1 at 0x401234: file myfile.c, line 42.

GDB now tracks the source around this line. The info breakpoints command
shows whether a breakpoint is tracked:

(gdb) info breakpoints
Num Type Disp Enb Address What
1 breakpoint keep y 0x0000000000401234 in calculate at myfile.c:42
source-tracking enabled (tracking 3 lines around line 42)

Now edit the source — say a few lines are added above the breakpoint,
shifting it from line 42 to line 45. After recompiling and reloading the
executable with run, GDB resets the breakpoint to the new line and displays:

Breakpoint 1 adjusted from line 42 to line 45.

Run info breakpoints again to confirm the new location:

(gdb) info breakpoints
Num Type Disp Enb Address What
1 breakpoint keep y 0x0000000000401256 in calculate at myfile.c:45
source-tracking enabled (tracking 3 lines around line 45)

As you can see, GDB updated the breakpoint line to match the new location.

Limitations

The matching algorithm requires an exact string match of the captured source
lines. Whitespace-only changes or trivial reformatting of the tracked lines
will confuse the matcher and may cause the breakpoint not to be found.

GDB only searches within a 12-line window around the original location. If
the code shifted by more than that — for example, because a large block was
inserted above — the breakpoint will not be found. GDB will keep the
original location and print a warning:

warning: Breakpoint 1 source code not found after reload, keeping original
location.

Source context cannot be captured when a breakpoint is created pending
(e.g., with set breakpoint pending on), because no symbol table is available
yet. When the breakpoint later resolves to a location, it will not be
source-tracked.

Source tracking is not supported for ranged breakpoints (set with
break-range).

Breakpoints on inline functions that expand to multiple locations are not
source-tracked, as each location may have moved differently.

How to try this experimental feature

This feature is not yet available in a stable GDB release. There are two
ways to try it.

Install from COPR (for Fedora users)

A pre-built package is available through a COPR repository. Enable it and
install:

sudo dnf copr enable ahajkova/GDB-source-tracking-breakpoints
sudo dnf upgrade gdb

To disable the repository again after testing:

sudo dnf copr disable ahajkova/GDB-source-tracking-breakpoints

The COPR project page is at:
https://copr.fedorainfracloud.org/coprs/ahajkova/GDB-source-tracking-breakpo
ints/

Build from source

  1. Clone the GDB repository:
    git clone git://sourceware.org/git/binutils-gdb.git
    cd binutils-gdb
  2. Download and apply the patch from the upstream mailing list:
    https://sourceware.org/pipermail/gdb-patches/2026-April/226349.html
  3. Build GDB:
    mkdir build && cd build
    ../configure --prefix=/usr/local
    make -j$(nproc) all-gdb
  4. Run the newly built GDB:
    ./gdb/gdb

Conclusion

GDB source-tracking breakpoints are an experimental feature currently under
upstream review and not yet available in a stable GDB release. This link
https://sourceware.org/gdb/current/onlinedocs/gdb.html/Set-Breaks.html
covers all available breakpoint commands. If you try this feature out and
hit any kind of unexpected behavior, feedback is very welcome — you can
follow and respond to the upstream patch discussion on the GDB mailing list
at https://sourceware.org/pipermail/gdb-patches/2026-April/226349.html

Steven Deobald: End of 10 Handout

14 April 2026 at 21:28

There was a silly little project I’d tried to encourage many folks to attempt last summer. Sri picked it up back in September and after many months, I decided to wrap it up and publish what’s there.

The intention is a simple, 2-sided A4 that folks can print and give out at repair cafes, like the End of 10 event series. Here’s the original issue, if you’d like to look at the initial thought process.

When I hear fairly technical folks talk about Linux in 2026, I still consistently hear things like “I don’t want to use the command line.” The fact that Spotify, Discord, Slack, Zoom, and Steam all run smoothly on Linux is far removed from these folks’ conception of the Linux desktop they might have formed back in 2009. Most people won’t come to Linux because it’s free of ✨shlop✨ and ads — they’re accustomed to choking on that stuff. They’ll come to Linux because they can open a spreadsheet for free, play Slay The Spire 2, or install Slack even though they promised themselves they wouldn’t use their personal computer for work.

The GNOME we all know and love is one we take for granted… and the benefits of which we assume everyone wants. But the efficiency, the privacy, the universality, the hackability, the gorgeous design, and the lack of ads? All these things are the icing on the cake. The cake, like it or not, is installing Discord so you can join the Sunday book club.

Here’s the A4. And here’s a snippet:

 

An A4 snippet including "where's the start menu?", "where are my exes?", and "how do I install programs?"

 

If you try this out at a local repair cafe, I’d love to know which bits work and which don’t. Good luck! ❤

 

Sjoerd Stendahl: Announcing the upcoming Graphs 2.0

14 April 2026 at 10:33

It’s been a while since we last shared a major update of Graphs. We’ve had a few minor releases, but the last time we had a substantial feature update was over two years ago.

This does not mean that development has stalled, to the contrary. But we’ve been working hard on some major changes that took some time to get completely right. Now after a long development cycle, we’re finally getting close enough to a release to be able to announce an official beta period. In this blog, I’ll try to summarize most of the changes in this release.

New data types

In previous version of Graphs, all data types are treated equally. This means that an equation is actually just regular data that is generated when loading. Which is fine, but it also means that the span of the equation is limited, the equation cannot be changed afterward, and operations on the equation will not be reflected in the equation name. In Graphs 2.0, we have three distinct data types: Datasets, Generated Datasets and Equations.

Datasets are the regular, imported data that you all know and love. Nothing really has changed here. Generated Datasets are essentially the same as regular datasets, but the difference is that these datasets are generated from an equation. They work the same as regular datasets, but for generated datasets you can change the equation, step size and the limits after creating the item. Finally, the major new addition is the concept of equations. As the name implies, equations are generated based on an equation you enter, but they span an infinite range. Furthermore, operations you perform on equations are done analytically. Meaning if you translate the equation `y = 2x + 3` with 3 in the y-direction, it will change to `y = 2x + 6`. If you perform a derivative, the equation will change to `y = 2x` etcetera. This is a long-requested feature, and has been made possible thanks to the magic of sympy and some trickery on the canvas. Below, there’s a video that demonstrates these three data types.

Revamped Style Editor

We have redesigned the style editor, where we now show a live preview of the edited styles. This has been a pain point in the past, when you edit styles you cannot see how it actually affects the canvas. Now the style editor immediately tells you how it will affect a canvas, making it much easier to change the style exactly to your preferences.

We have also added the ability to import styles. Since Graphs styles are based on matplotlib styles, most features from a matplotlib style generally work. Similarly, you can now export your styles as well making it easier to share your style or simply to send it to a different machine. Finally, the style editor can be opened independently of Graphs. By opening a Graphs style from your file explorer, you can change the style without having to open Graphs.

We also added some new options, such as the ability to style the new error bars. But also the option to draw tick labels (so the values) on all axes that have ticks.

A screenshot of the Graphs style editor, on the left you can see the different settings as in the previous version. On the right you can see the live preview
The revamped style editor

Improved data import

We have completely reworked the way data is imported. Under the hood, our modules are completely modular making it possible to add new parsers without having to mess with the code. Thanks to this rework, we have added support for spreadsheets (LibreOffice .ods and Microsoft Office .xlxs) and for sqlite databases files. The UI automatically updates accordingly. For example for spreadsheets, columns are imported by the column name (alphabetical letter) instead of an index, while sqlite imports show the tables present in the database.

The new import dialog for Graphs. You can see how multiple different types of items are about the be imported, as well as new settings
The new import dialog

Furthermore, the import dialog has been improved. It is not possible to add multiple files at once, or import multiple datasets from the same file. Settings can be adjusted for each dataset individually. And you can even import just from a single column. We also added the ability to import error-bars on either axes, and added some pop-up buttons that explain certain settings.

Error bars

I mentioned this in the previous paragraph, but as it’s a feature that’s been requested multiple times I thought it’d be good to state this explicitly as well. We now added support for error bars. Error bars can easily be set on the import dialog, and turned on and off for each axis when editing the item.

Singularity handling

The next version of Graph will also finally handle singularities properly, so equations that have infinite values in them will be rendered as they should be. What was happening in the old version, was that for equations with values that go to infinity and then flip sign, that the line was drawn from the maximum value to the minimum value. Even though there are no values in between. Furthermore, since we render a finite amount of datapoints, the lines don’t go up to infinity either, giving misleading Graphs.

This is neatly illustrated in the pictures below. The values go all the way up to infinity like they should, and Graphs neatly knows that the line is not continuous, so it does not try to draw a straight line going from plus to minus infinity.

The old version of Graphs trying to render tan(x). Lines don't go all the way to plus/minus infinity, and they also draw a line between the high and low values.
The old version of Graphs trying to render tan(x). Lines don’t go all the way to plus/minus infinity, and they also draw a line between the high and low values.
Image
The upcoming version of Graphs, were equations such as tan(x) are drawn properly.

Reworked Curve fitting

The curve fitting has been reworked completely under the hood. While the changes may not be that obvious as a user, the code has basically been completely replaced. The most important change is that the confidence band is now calculated completely correctly using the delta-method. Previously a naive approach was used where the limits were calculated using the standard deviation each parameter. This does not hold up well in most cases though. The parameter values that are given are also no longer rounded in the new equation names (e.g. 421302 used to be rounded to 421000). More useful error messages are provided when things go wrong, custom equations now have an apply button which improves smoothness when entering new equations, the root mean squared error is added as a second goodness-of-fit measure, you can now check out the residuals of your fit. The residuals can be useful to check if your fit is physically correct. A good fit will show residuals scattered randomly around zero with no visible pattern. A systematic pattern in the residuals, such as a curve or a trend suggests that the chosen model may not be appropriate for the data.

Image
The old version of Graphs with the naive calculation of the confidence band
Image
The new version of Graphs with the proper calculation of the confidence band.

UI changes

We’ve tweaked the UI a bit all over the place. But one particular change that is worth to highlight, is that we have moved the item and figure settings to the sidebar. The reason for this, is that the settings are typically used to affect the canvas so you don’t want to lose sight of how your setting affects the canvas while you’re updating. For example, when setting the axes limits, you want to see how your graph looks with the new limit, having a window obstructing the view does not help.

Another nice addition is that you can now simply click on a part of the canvas, such as the limits, and it will immediately bring you to the figure settings with the relevant field highlighted. See video below.

Mobile screen support

With the upcoming release, we finally have full support for mobile devices. See here a quick demonstration on an old OnePlus 6:

Figure exporting

One nice addition is the improved figure export. Instead of simply taking the same canvas as you see on the screen, you can now explicitly set a certain resolution. This is vital if you have a lot of figures in the same work, or need to publish your figures in academic journals, and you need consistency both in size and in font sizes. Of course, you can still use the previous setting and have the same size as in the application.

Image
The new export figure dialog

More quality of life changes

The above are just a highlight of some major feature updates. But there’s a large amount of features that we added. Here’s a rapid-fire list of other niceties that we added:

    • Multiple instances of Graphs can now be open at the same time
    • Data can now be imported by drag-and-drop
    • The subtitle finally shows the full file path, even in the isolated Flatpak
    • Custom transformations have gotten more powerful with the addition of new variables to use
    • Graphs now inhibits the session when unsaved data is still open
    • Added support for base-2 logarithmic scaling
    • Warnings are now displayed when trying to open a project from a beta version

And a whole bunch of bug-fixes, under-the-hood changes, and probably some features I have forgotten about. Overall, it’s our biggest update yet by far, and I am excited to finally be able to share the update soon.

As always, thanks to everyone who has been involved in this version. Graphs is not a one-person project. The bulk of the maintenance is done by me and Christoph, the other maintainer. And of course, we should thank the entire community. Both within GNOME projects (such as help from the design team, and the translation team), as well as outsiders that come with feedback, report or plain suggestions.

Getting the beta

This release is still in beta while we are ironing out the final issues. The expected release date is somewhere in the second week of may. In the meantime, feel free to test the beta. We are very happy for any feedback, especially in this period!

You can get the beta directly from flathub. First you need to add the flathub beta remote:

flatpak remote-add --if-not-exists flathub-beta https://flathub.org/beta-repo/flathub-beta.flatpakrepo

Then, you can install the application:
flatpak install flathub-beta se.sjoerd.Graphs

To run the beta version by default, the following command can be used:

sudo flatpak make-current se.sjoerd.Graphs beta

Note that the sudo is neccesary here, as it sets the current branch on the system level. To install this on a per-user basis, the flag –user can be used in the previous commands. To switch back to the stable version simply run the above command replacing beta with stable.

The beta branch on update should get updated somewhat regularly. If you don’t feel like using the flathub-beta remote, or want the latest build. You can also get the release from the GitLab page, and build it in GNOME Builder.

Nominate Your Fedora Heroes: Mentor and Contributor Recognition 2026

14 April 2026 at 09:30
Mentor and Contributor Recognition 2026 - Generated using Gemini Nano Banana Pro by Akashdeep Dhar

It’s time to show our appreciation of the amazing contributors who help shape the Fedora community.

The Fedora Project thrives through the devotion, guidance, and tireless drive of the contributors who consistently perform. From developing testcases to onboarding contributors, from technical writing to coordinating events, it is these vital champions who ensure that the community flourishes. In coordination with the Fedora Mentor Summit 2026, we will be returning to Flock To Fedora 2026 to announce the winners. This wiki reflects the deep gratitude and careful thought behind this community recognition program.

As we prepare to spotlight exceptional mentors and contributors across the Fedora Project, we invite you to help us appreciate the amazing contributors who help shape the community. Whether it is a veteran mentor who helped you begin your journey or a contributor whose efforts have truly reshaped the community’s landscape, now is the moment to celebrate them! Discover more about the nomination guidelines and submit your entry using the link provided below:

👉 Find more information here: https://fedoraproject.org/wiki/Contributor_Recognition_Program_2026
👉 Submit your nominations here: https://forms.gle/mBAVKw4qLu14R5YY7

🗓 Deadline: 15th May 2026

Let us appreciate the amazing contributors who help shape the community. Your nomination could be the recognition that might enable them to do more – and a moment of achievement for the entire community.

Jakub Steiner: 120+ Icons and Counting

14 April 2026 at 00:00

Back in 2019, we undertook a radical overhaul of how GNOME app icons work. The old Tango-era style required drawing up to seven separate sizes per icon and a truckload of detail. A task so demanding that only a handful of people could do it. The "new" style is geometric, colorful, but mainly achievable. Redesigning the system was just the first step. We needed to actually get better icons into the hands of app developers, as those should be in control of their brand identity. That's where app-icon-requests came in.

As of today, the project has received over a hundred icon requests. Each one represents a collaboration between a designer and a developer, and a small but visible improvement to the Linux desktop.

How It Works

Ideally if a project needs a quick turnaround and direct control over the result, the best approach remains doing it in-house or commission a designer.

But if you're not in a rush, and aim to be a well designed GNOME app in particular, you can make use of the idle time of various GNOME designers. The process is simple. If you're building an app that follows the GNOME Human Interface Guidelines, you can open an icon request. A designer from the community picks up the issue, starts sketching ideas, and works with you until the icon is ready to ship. If your app is part of GNOME Circle or is aiming to join, you're far more likely to get a designer's attention quickly.

The sketching phase is where the real creative work happens. Finding the right metaphor for what an app does, expressed in a simple geometric shape. It's the part I enjoy most, and why I've been sharing my Sketch Friday process on Mastodon for over two years now (part 2). But the project isn't about one person's sketches. It's a team effort, and the more designers join, the faster the backlog shrinks.

Highlights

Here are a few of the icons that came through the pipeline. Each started as a GitLab issue and ended up as pixels on someone's desktop.

Alpaca Bazaar Field Monitor Dev Toolbox Exhibit Plots Gradia Millisecond Orca Flatseal Junction Carburetor

Alpaca, an AI chat client, went through several rounds of sketching to find just the right llama. Bazaar, an alternative to GNOME Software, took eight months and 16 comments to go from a shopping basket concept through a price tag to the final market stall. Millisecond, a system tuning tool for low-latency audio, needed several rounds to land on the right combination of stopwatch and waveform. Field Monitor shows how multiple iterations narrow down the concept. And Exhibit, the 3D model viewer, is one of my personal favorites.

You can browse all 127 completed icons to see the full range — from core GNOME apps to niche tools on Flathub.

Papers: From Sketch to Ship

To give a sense of what the process looks like up close, here's Papers — the GNOME document viewer. The challenge was finding an icon that says "documents" without being yet another generic file icon.

Papers concept sketch with magnifying glass Papers concept sketch width stacked papers Papers concept sketch with reading glasses Papers final icon

The early sketches explored different angles — a magnifying glass over stacked pages, reading glasses resting on a document. The final icon kept the reading glasses and the stack of colorful papers, giving it personality while staying true to what the app does. The whole thing played out in the GitLab issue, with the developer and designer going back and forth until both were happy.

While the new icon style is far easier to execute than the old high-detail GNOME icons, that doesn't mean every icon is quick. The hard part was never pushing pixels — it's nailing the metaphor. The icon needs to make sense to a new user at a glance, sit well next to dozens of other icons, and still feel like this app to the person who built it. Getting that right is a conversation between the designer's aesthetic judgment and the maintainer's sense of identity and purpose, and sometimes that conversation takes a while.

Bazaar is a good example.

Bazaar early concept - shopping basket Bazaar concept - price tag Bazaar concept - market stall Bazaar final icon

The app was already shipping with the price tag icon when Tobias Bernard — who reviews apps for GNOME Circle — identified its shortcomings and restarted the process. That kind of quality gate is easy to understate, but it's a big part of why GNOME apps look as consistent as they do. Tobias is also a prolific icon designer himself, frequently contributing icons to key projects across the ecosystem. In this case, the sketches went from a shopping basket through the price tag to a market stall with an awning — a proper bazaar. Sixteen comments and eight months later, the icon shipped.

Get Involved

There are currently 20 open icon requests waiting for a designer. Recent ones like Kotoba (a Japanese dictionary), Simba (a Samba manager), and Slop Finder haven't had much activity yet and could use a designer's attention.

If you're a designer, or want to become one, this is a great place to start contributing to Free software. The GNOME icon style was specifically designed to be approachable: bold shapes, a defined color palette, clear guidelines. Tools like Icon Preview and Icon Library make the workflow smooth. Pick a request, start with a pencil sketch on paper, and iterate from there. There's also a dedicated Matrix room #appicondesign:gnome.org where icon work is discussed — it's invite-only due to spam, but feel free to poke me in #gnome-design or #gnome for an invitation. If you're new to Matrix, the GNOME Handbook explains how to get set up.

If you're an app developer, don't despair shipping with a placeholder icon. Follow the HIG, open a request, and a designer will help you out. If you're targeting GNOME Circle, a proper icon is part of the deal anyway.

A good icon is one of those small things that makes an app feel real — finished, polished, worth installing. Now that we actually have a place to browse apps, an app icon is either the fastest way to grab attention or make people skip. If you've got some design chops and a few hours to spare, pick an issue and start sketching.

Need a Fast Track?

If you need a faster turnaround or just want to work with someone who's been helping out with GNOME's visual identity for as long as I can remember — Hylke Bons offers app icon design for open source projects through his studio, Planet Peanut. Hylke has been a core contributor to GNOME's icon work for well over a decade. You'll be in great hands.

His service has a great freebie for FOSS projects — funded by community sponsors. You get three sketches to choose from, a final SVG, and a symbolic variant, all following the GNOME icon guidelines. If your project uses an OSI-approved license and is intended to be distributed through Flathub, you're eligible. Consider sponsoring his work if you can — even a small amount helps keep the pipeline going.

Previously, Previously.

Adrien Plazas: Monster World IV: Disassembly and Code Analysis

13 April 2026 at 22:00

This winter I was bored and needed something new, so I spent lots of my free time disassembling and analysing Monster World IV for the SEGA Mega Drive. More specifically, I looked at the 2008 Virtual Console revision of the game, which adds an English translation to the original 1994 release.

My long term goal would be to fully disassemble and analyse the game, port it to C or Rust as I do, and then port it to the Game Boy Advance. I don’t have a specific reason to do that, I just think it’s a charming game from a dated but charming series, and I think the Monaster World series would be a perfect fit on the Game Boy Advance. Since a long time, I also wanted to experiment with disassembling or decompiling code, understanding what doing so implies, understanding how retro computing systems work, and understanding the inner workings of a game I enjoy. Also, there is not publicly available disassembly of this game as far as I know.

As Spring is coming, I sense my focus shifting to other projets, but I don’t want this work to be gone forever and for everyone, especially not for future me. Hence, I decided to publish what I have here, so I can come back to it later or so it can benefit someone else.

First, here is the Ghidra project archive. It’s the first time I used Ghidra and I’m certain I did plenty of things wrong, feedback is happily welcome! While I tried to rename things as my understanding of the code grew, it is still quite a mess of clashing name conventions, and I’m certain I got plenty of things wrong.

Then, here is the Rust-written data extractor. It documents how some systems work, both as code and actual documentation. It mainly extracts and documents graphics and their compression methods, glyphs and their compression methods, character encodings, and dialog scripts. Similarly, I’m not a Rust expert, I did my best but I’m certain there is area for improvement, and everything was constantly changing anyway.

There is more information that isn’t documented and is just floating in my head, such as how the entity system works, but I yet have to refine my understanding of it. Same goes for the optimimzations allowed by coding in assembly, such as using specific registers for commonly used arguments. Hopefully I will come back to this project and complete it, at least when it comes to disassembling and documenting the game’s code.

❌