On the spring 2024 I presented my candidature , and eventually got elected for the Board of Directors at the GNOME Foundation. Directors are elected democratically by the GNOME Foundation members, and positions are usually up for election every 2 years. However, when I started my term there was one position open for a single year (due to some changes in composition of the Board). And I volunteered for it, thus my term expired more or less a month ago. When directors get elected, the information that voters have to decide on their vote is:

• Their personal connection to the candidates
• The candidatures themselves
• And further questions the voters might ask about specific topics

For the shake of transparency and accountability, I am going to discuss my own personal candidature against the work that I contributed to the Board for the last year. Although pretty basic and a self-assessment, I believe this is important for any organization. Without retrospectives, feedback, and public discussion it is very hard to learn lesson, make improvements, and ensure knowledge transfer. Not to mention that public scrutiny and discussion are crucial for any kind of functional democratic governance. Though there are reasons to sometimes not discuss things in public, most of my work for the last year can indeed be discussed in public.

Candidature goals

I joined the Board to contribute mostly from the economic perspective. I wanted to become part of the Finance Committee to contribute to improve:

• The communication about economic and funds-related topics. My goal was to ensure that funds were handled more transparently, and build trust by making sure the information reported was detailed and correct. Avoiding issues like those of which I spoke in a previous blog post .
• The way funds were assigned, to make sure those were spent on fulfilling the goals we set to the Foundation.

Unfortunately, when I joined the Board there were some considerable governance issues still unresolved that we got handed over from the previous year. Given my status as a developer and recent community member based in Europe, I had not had time to build relationships with many people in the community. As such, I also set it as one of my goals to represent those people that I knew, which had been under-represented in the previous board.

Goals into actions

Let it be said that being part of a governance body for a non-profit in a foreign country with a different history and legal background can be challenging. A non-trivial amount of my time was dedicated to understanding and getting used to such a body: its internal rules, ways of working, and expectations. I wish the governance was closer to home (has anybody in the American continent worked in organizations with a General Assembly?), but that would be a discussion for another time. Now I will stick to discussing actions related to the goals above.

Becoming part of the Finance Committee

I presented my candidature to become the Treasurer. The Board did a vote , and instead decided to appoint me as Vice-treasurer. As such, I had no powers, more than the right to attend the Finance Committee meetings, which was enough for me to work on my other self-stated goals. Unfortunately, despite multiple requests from different Board members, and assurances in different meetings , I was never called to a Finance Committee meeting. With the resignation of Michael Downey as a directory during the change of the year, I was then offered the Treasurer position. I declined the offer, since at that point I was not willing to volunteer more of my time for the Foundation.

Economic-related communication and funds

During the first months of my term I got heavily involved in this aspect. In addition to taking part in discussions and decision-making, I was one of the the main authors of a general economic update and one focused specifically on the budget . It of course took input and effort from multiple directors, but I am confident that my contribution was considerable. Happily, those updates did have an impact on how people saw the Foundation and the project, with some hints that such work could help regain good will and trust from further people in the membership and the wider FOSS community. Those two were concentrated in the first half of my term, and although there are usually more economic news around budget planning, I did not contribute further work on this for the second half of my term.

Regarding the usage of funds, I was quite involved in the drafting and approval of the budget for 2024/2025. Even if Richard (then Interim Executive Director) took the lion’s share of the work. Such budget managed to retain spending essential for the fulfilling of the goals (conferences, infra), while at the same time making sure available restricted funds were put to use (parental controls and well-being). Unfortunately, some of the fears I expressed in my candidature were right, and expenses had to be cut considerably, leading to us not being able to support all the previous staffers. In general, those executive decisions were not made by me, but by the Executive Director. However, I am happy my input was taken into consideration, and we managed to have a budget that brought us to 2025.

Governance and community engagement

Although the governance issues were carried over from a previous board, I tried to apply the best of my judgement in every situation. I did communicate, when the situation allowed, with the community, and sit in countless meetings to both mediate and express my opinion. At some point, when I was not sure I was doing a good job, presented my resignation a considerable amount of people I knew had voted for me, and all considered it would be best for me to stay.

Evaluation

I put a lot of effort and time moving forward those things I promised in the first half of my term. Unfortunately, I was unable to continue with such engagement through the second half. Part of that had to be with bad management of my time and energy, where I surely burned too much too early. Another part had to be with the realization that many of the problems that I was hoping to tackle at the Foundation are symptoms of deeper structural issues at the project level. For example, no team or committee has official and effective communication channels. So why would the people running the project change their behavior just because being part of  the Board? I believe I do not have the leverage, skills, or experience to tackle those issues at their core, which strongly reduced my motivation. I am happy, though, that senior members in the community are really trying .

I am specially sorry I did not take the Treasurer position when I was offered it. This was less than I expected from myself. I offered my resignation to community members that I knew had voted me, but nobody took it. I also presented my resignation to another Board member which took most of the burden for my decision of not taking the role. It was also politely declined. In hindsight I maybe should have resigned anyway.

On the positive side, I learned a lot of lessons just by being on the Board, specially related to governance. I take most of those lessons with me to postmarketOS , and I hope they serve as an useful inter-FOSS lesson sharing experiment. They have surely already helped!

Overall, I am a bit disappointed with myself, as I would have expected to keep doing a lot of the things I did at the beginning for the whole of my term. At the same time, considering the complete year, I think my overall level of work and engagement was probably on average compared to the rest of the Board. In general, the whole experience was considerably draining, specially emotionally, as we were going through uncommon circumstances, e.g: governance issues, staff reduction, etc.

Moving forward

I do not plan to come back to do governance for the GNOME project for a while. I am very happy with what we are building in postmarketOS: the community and the full-stack and upstreaming commitment we bring with us. I hope the GNOME project and Foundation can transition to more open and structured models of governance, where tracking decisions, communicating regularly, and taking responsibility over good and bad decisions becomes the norm. I hope this posts motivates other directors to write their own retrospectives and hold themselves accountable in public in the future.

It is also encouraging to see that we have a new Executive Director, Steven, which rapidly understood many of the issues and needs of the project and organization in a similar way than I do. I wish him the best of successes, and thank him for taking over such an endeavor.

Thanks also to every Board member: Cassidy, Erik, Federico, Julian, Karen, Michael, Philip, Robert, as well as the staff I interacted Rosanna, Kristi, Bart, and Richard. I’ve seen the passion and effort, and it is truly remarkable. With this, I also want to give a special mention to Allan Day. He’s worked non-stop during months to decisively contribute to the Foundation staying afloat. Thank you very much for your work, it is unmatched.

If you have any feedback you want to share, thoughts about my term, improvements to suggest, or just some thanks, feel free to comment or email me. I am always happy to hear other people’s thoughts, and there’s no improvement without feedback!

## Bureaucracy

You may have noted that there wasn’t a Foundation Update last week. This is because almost everything that has been happening at the Foundation lately falls under the banner of “bureaucracy” and/or “administration” and there isn’t much to say about either of those topics publicly.

Also, last Friday was GNOME’s 28th birthday and no one wants to hear about paper-shuffling on their birthday.

I’m sorry to say there isn’t much to add this week, either. But I hope you did all take a moment to reflect on the nearly-three-decades-of-work that’s gone into GNOME last week.

Happy Belated Birthday, Computer.

Update on what happened across the GNOME project in the week from August 15 to August 22.

GNOME Core Apps and Libraries

Glycin ↗

Sandboxed and extendable image loading and editing.

Sophie (she/her) announces

Glycin 2.0.beta.3 has been released. Among the important changes are fixes for thumbnailers not working in certain configurations, loading speed for JPEG XL having been dramatically improved, fixed sandbox rules that broke image loading on some systems, and fixed editing for some JPEG images saved in progressive mode.

GNOME Circle Apps and Libraries

Déjà Dup Backups ↗

A simple backup tool.

Michael Terry announces

Déjà Dup 49.beta was released! It just fixes a few small bugs and uses the new libadwaita shortcuts dialog.

But if you haven’t tried the 49.x branch yet, it has a big UI refactor and adds file-manager-based restore for Restic backups.

Read more details and install instructions in the previous 49.alpha announcement . Thanks for any testing you can do before this reaches the masses!

Third Party Projects

Mir Sobhan announces

We forked the TWIG website and forged it into a “good first issue” tracker. It catches all GNOME-related projects on GitHub and GNOME GitLab to show issues labeled “good first issue” or “Newcomers.” This can help newcomers find places to contribute including myself.

Website: https://ggfi.mirsobhan.ir Repo: https://gitlab.gnome.org/misano/goodfirstissue

Džeremi says

Chronograph gets a BIG new 4.0 update!

What is Chronograph?

Chronograph is an app for syncing lyrics, making them display like karaoke in supported players. It comes with a beautiful GTK4 + LibAdwaita interface and includes a built-in metadata editor, so you can manage your music library along with syncing lyrics. Default LRC files can be published to the large lyrics database LRClib.net , which is widely used by many open-source players to fetch lyrics. Until now, Chronograph supported only line-by-line lyrics, which was enough for most cases since standard LRC is the most common format. But times change…

Word-by-Word support!

Starting August 24th , Chronograph will gain support for Word-by-Word syncing. This feature uses the eLRC format (also known as LRC A2 or Enchanted LRC). In eLRC, each word has its own timestamp, allowing players that support it to animate lyrics word-by-word , giving you a true karaoke experience. And this is just the beginning: future updates will also bring support for TTML (Timed Text Markup Language) .

Final notes

I hope you’ll enjoy using the latest version of Chronograph, and together we can spread awareness of eLRC to the wider community. Sync lyrics of your loved songs! ♥️

Nathan Perlman announces

Rewaita — Give Adwaita some flavour

Hi there, a few weeks ago I released Rewaita , a spiritual successor to Gradience . With it, you can recolour GTK4/Adwaita apps to popular colour schemes. That’s where the name comes from ~ Re(colour Ad)waita.

As of v1.0.4, released this week, you can create your own custom colour palettes if the ones we provide don’t suit you, and you can also change the window controls to be either coloured or MacOS-styled.

You can find it on Flathub , but also in the AUR and NIXPKGS (the Nix Package is still under review).

Rewaita is also going through rapid development, so any help would be appreciated , or just leave us a star :). In particular, GTK3 and Cinnamon support are next up on the chopping block.

Miscellaneous

JumpLink says

ts-for-gir - TypeScript bindings for GObject Introspection

This week we’ve released a major improvement for GObject interface implementation: Virtual Interface Generation .

Instead of having to implement all methods of a GObject interface, developers can now only implement the virtual methods ( vfunc_* ). This matches the actual GObject-Introspection pattern and makes interface implementation much cleaner.

Before (implement all methods):

class CustomPaintable implements Gdk.Paintable {
  // Implement all methods manually
  get_current_image(): Gdk.Paintable { ... }
  get_flags(): Gdk.PaintableFlags { ... }
  get_intrinsic_width(): number { ... }
  // ... and many more
}

After (only virtual methods):

class CustomPaintable implements Gdk.Paintable.Interface {
  // Declare for TypeScript compatibility
  declare get_current_image: Gdk.Paintable["get_current_image"];
  declare get_flags: Gdk.Paintable["get_flags"];
  
  // Only implement virtual methods
  vfunc_get_current_image(): Gdk.Paintable { ... }
  vfunc_get_flags(): Gdk.PaintableFlags { ... }
}

We’ve created a comprehensive example: https://github.com/gjsify/ts-for-gir/tree/main/examples/virtual-interface-test

This shows both Gio.ListModel and Gdk.Paintable implementations using the new pattern.

Release : v4.0.0-beta.35 and v4.0.0-beta.36

Note : Last week we also released v4.0.0-beta.34 which introduced Advanced Variant Types by default, completing the gi.ts integration with enhanced TypeScript support for GLib.Variant.deepUnpack() and better type inference for GObject patterns.

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!

At the Linux App Summit (LAS) in Albania three months ago, I gave a talk about testing in the xdg-desktop-portal project. There is a recording of the presentation, and the slides are available as well.

To give a quick summary of the work I did:

• Revamped the CI
• Reworked and improved the pytest based integration test harness
• Added integration tests for new portals
• Ported over all the existing GLib/C based integration tests
• Support ASAN for detecting memory leaks in the tests
• Made tests pretend to be either a host, Flatpak or Snap app

The hope I had is that this will result in:

• Fewer regressions
• Tests for new features and bug fixes
• More confidence in refactoring
• More activity in the project

While it’s hard to get definite data on those points, at least some of it seems to have become reality. I have seen an increase in activity (there are other factors to this for sure), and a lot of PRs already come with tests without me even having to ask for it. Canonical is involved again, taking care of the Snap side of things. So far it seems like we didn’t introduce any new regressions, but this usually shows after a new release. The experience of refactoring portals also became a lot better because there is a baseline level of confidence when the tests pass, as well as the possibility to easily bisect issues. Overall I’m already quite happy with the results.

Two weeks ago, Georges merged the last piece of what I talked about in the LAS presentation, so we’re finally testing the code paths that are specific to host, Flatpak and Snap applications! I also continued a bit with improving the tests, and now they can be run with Valgrind , which is super slow and that’s why we’re not doing it in the CI, but it tends to find memory leaks which ASAN does not. With the existing tests, it found 9 small memory leaks .

If you want to improve the Flatpak story, come and contribute to xdg-desktop-portal. It’s now easier than ever!

• Up extremely early, worked for a few hours, out for a run with J. painful left hip.
• Merger/finance call, sync with Dave, Gokay & Szymon, Lunch.
• Published the next strip: on Fixed Price projects
  
• Productivity All Hands meeting.

If you have spent any time around HID devices under Linux (for example if you are an avid mouse, touchpad or keyboard user) then you may have noticed that your single physical device actually shows up as multiple device nodes (for free! and nothing happens for free these days!). If you haven't noticed this, run libinput record and you may be part of the lucky roughly 50% who get free extra event nodes.

The pattern is always the same. Assuming you have a device named FooBar ExceptionalDog 2000 AI [1] what you will see are multiple devices

/dev/input/event0: FooBar ExceptionalDog 2000 AI Mouse
/dev/input/event1: FooBar ExceptionalDog 2000 AI Keybard 
/dev/input/event2: FooBar ExceptionalDog 2000 AI Consumer Control 

The Mouse/Keyboard/Consumer Control/... suffixes are a quirk of the kernel's HID implementation which splits out a device based on the Application Collection . [2]

A HID report descriptor may use collections to group things together. A "Physical Collection" indicates "these things are (on) the same physical thingy". A "Logical Collection" indicates "these things belong together". And you can of course nest these things near-indefinitely so e.g. a logical collection inside a physical collection is a common thing.

An "Application Collection" is a high-level abstractions to group something together so it can be detected by software. The "something" is defined by the HID usage for this collection. For example, you'll never guess what this device might be based on the hid-recorder output:

# 0x05, 0x01,                    // Usage Page (Generic Desktop)              0
# 0x09, 0x06,                    // Usage (Keyboard)                          2
# 0xa1, 0x01,                    // Collection (Application)                  4
...
# 0xc0,                          // End Collection                            74

Yep, it's a keyboard. Pop the champagne[3] and hooray, you deserve it.

The kernel, ever eager to help, takes top-level application collections (i.e. those not inside another collection) and applies a usage-specific suffix to the device. For the above Generic Desktop/Keyboard usage you get "Keyboard", the other ones currently supported are "Keypad" and "Mouse" as well as the slightly more niche "System Control", "Consumer Control" and "Wireless Radio Control" and "System Multi Axis". In the Digitizer usage page we have "Stylus", "Pen", "Touchscreen" and "Touchpad". Any other Application Collection is currently unsuffixed (though see [2] again, e.g. the hid-uclogic driver uses "Touch Strip" and other suffixes).

This suffix is necessary because the kernel also splits out the data sent within each collection as separate evdev event node. Since HID is (mostly) hidden from userspace this makes it much easier for userspace to identify different devices because you can look at a event node and say "well, it has buttons and x/y, so must be a mouse" (this is exactly what udev does when applying the various ID_INPUT properties, with varying levels of success).

The side effect of this however is that your device may show up as multiple devices and most of those extra devices will never send events . Sometimes that is due to the device supporting multiple modes (e.g. a touchpad may by default emulate a mouse for backwards compatibility but once the kernel toggles it to touchpad mode the mouse feature is mute). Sometimes it's just laziness when vendors re-use the same firmware and leave unused bits in place.

It's largely a cosmetic problem only, e.g. libinput treats every event node as individual device and if there is a device that never sends events it won't affect the other event nodes. It can cause user confusion though: "why does my laptop say there's a mouse?" and in some cases it can cause functional degradation - the two I can immediately recall are udev detecting the mouse node of a touchpad as pointing stick (because i2c mice aren't a thing), hence the pointing stick configuration may show up in unexpected places. And fake mouse devices prevent features like "disable touchpad if a mouse is plugged in" from working correctly. At the moment we don't have a good solution for detecting these fake devices - short of shipping giant databases with product-specific entries we cannot easily detect which device is fake. After all, a Keyboard node on a gaming mouse may only send events if the user configured the firmware to send keyboard events, and the same is true for a Mouse node on a gaming keyboard.

So for now, the only solution to those is a per-user udev rule to ignore a device . If we ever figure out a better fix, expect to find a gloating blog post in this very space.

[1] input device naming is typically bonkers, so I'm just sticking with precedence here
[2] if there's a custom kernel driver this may not apply and there are quirks to change this so this isn't true for all devices
[3] or sparkling wine, let's not be regionist here

Hello! I’m working on an interesting project this month, related to open source Linux operating systems. Actually I’m not working on it this week, I’m instead battling with vinyl floor tiles. Don’t let anyone tell you they are easy to fit. But I think on the 5th attempt I’ve got the technique. The wooden mallet is essential.

When I started these “status update” posts, back in 2021 , I imagined they’d be to talk about open technology projects I was working on, mixed with a bit of music and art and so on. In fact I write more about politics these days. Let me explain why.

In my book review earlier this year I mentioned economics dude Gary Stevenson. I still didn’t read his book but I do watch all his videos now and I’m learning a lot.

I learned a bit about the housing crisis, for example. The housing crisis in Manchester had several major effects on my life. I just read today in The Manchester Mill that the average rent in Salford jumped from £640/mo to £1,121/mo in a decade.

(Lucky for me, I got into computers early in life, and nobody understands their secrets so they still have to pay a good salary to those of us who do. So far I’ve weathered the crisis. Many of my friends don’t have that luck, and some of them have been struggling for 15 years already. Some even had to become project managers .)

Until about 2020, I assumed the Manchester housing crisis was caused by people moving up from London. Galicia had some cheap ass rents when I arrived and it’s only around 2021, when they started suddenly doubling just as I’d seen happen in Manchester, that I realised the same crisis was about to play out here as well, and perhaps it wasn’t entirely the fault of Gen-X Londoners. I thought, maybe it’s a Europe-wide housing crisis?

Let me summarize the video Gary Stevenson did about the housing crisis ( this one ), to save you 28 minutes. It’s not just houses but all types of asset which are rapidly going up in price, and it’s happening worldwide. We notice the houses because we need them to live normal lives, unlike other types of asset such as gold or government bonds which most of us can live without.

The most recent video is titled like this: “Is the economy causing a mental health crisis? “. I’ve embedded it below. ( It’s hosted on a platform controlled by Google, but Gary is good enough to turn off the worst of the YouTube ads, those bastards that pop up during a video in mid-sentence or while you’re figuring out a yoga pose .)

My answer to that question, when I saw it, was “ Yes, obviously “. For example, if rent increases by 75% in your city and you’re forced back into living with your parents age 35, it’s tough to deal with alright. What do you think?

But the video is about more than that. The reason asset prices are through the roof is because the super rich are taking all the assets . The 1% have more money than ever. Wealth inequality is rapidly rising, and nothing is stopping it. For thousands of years, the aristocracy owned all the land and castles and manor houses, and the rest of us had a few cabbages and, perhaps if you were middle class, a pig.

The second half of the 20th century levelled the playing field and put in place systems which evened things out and meant your grandparents maybe could buy a house. The people in charge of those systems have given up, or have been overpowered by the super rich.

In fact, the video “Is the economy causing a mental health crisis?” is about the effect on your mental health when you realize that all of society as you know it is headed towards complete collapse.

(Lucky for me, I grew up thinking society was headed for collapse due to the climate crisis, so I listened to a lot of punk rock and over-developed my capacity for nihilism. Maybe my mind looks for crises everywhere? Or maybe I was born in a time well-supplied with global crises. I share a birthday with the Chernobyl disaster.)

So how does all this relate back to open technology?

Maybe it doesn’t. I went to the GNOME conference last month and had very little overtly “political” conversations. We chatted about GNOME OS, live-streaming, openQA, the GNOME Foundation, the history of the GNOME project, accessibility at conferences, our jobs, and so on. Which was great, I for some reason find all that stuff mega interesting. (Hence why I went there instead of a conference about 21st century world politics).

Or maybe it does. Tech is part of everyone’s lives now. Some of the most powerful organizations in the world now are tech companies and they get their power from being omnipresent. Software engineers built all of this. What were we thinking?

I think we just enjoyed getting paid to work on fun problems. I suppose none of today’s tech billionaires seemed like particularly evil-minded people in the mid 2000s. Spotify used to talk about reducing MP3 piracy, not gutting the income streams of 95% of professional recording artists. Google used to have a now laughable policy of “Don’t be evil”.

There is one exception who were clearly evil bastards in the 2000s as well. The US anti-trust case against Microsoft, settled in 2001, is an evidence trail of lies and anti-competitive behaviour under Bill Gates’ leadership. Perhaps in an attempt to one-up his predecessor, the Satya Nadella Microsoft is now helping the far-right government of Israel to commit war crimes every day. No Azure for Apartheid . At least they are consistent, I suppose.

In fact, I first got interested in Linux due to Microsoft. Initially for selfish reasons. I was a child with a dialup internet connection, and I just wanted to have 5 browser windows open without the OS crashing. (For younger readers — browser tabs weren’t invented until the 21st century).

Something has kept me interested in open operating systems, even in this modern era when you can download an MP3 in 5 seconds instead of 5 consecutive evenings. It’s partly the community of fun people around Linux. It’s partly that it led me to the job that has seen me through the housing crisis so far. And its partly the sense that we are the alternative to Big Tech.

Open source isn’t going to “take over the world”. That’s what Microsoft, Spotify and Google were always going to do (and have now done). I’m honestly not sure where open source is going. Linux will go wherever hardware manufacturers force it to go, as it always has done.

GNOME may or may not make it mainstream one day. I’m all for it, if it means some funding for localsearch maintainers. If it doesn’t, that’s also fine, and we don’t need to be part of some coherent plan to save the world or to achieve a particular political aim. Nothing goes according to plan anyway. Its fine to work on stuff just cus its interesting.

What we are doing is leading by example, showing that its possible to develop high quality software independently of any single corporation. You can create institutions where contributors do what we think is right, instead of doing what lunatics like Sam Altman or Mark Zockerborg think.

At the same time, everything is political.

What would happen if I travelled back to 2008 and asked the PHP developers building Facebook: “Do you think this thing could play a determining role in a genocide in Myanmar?”

I met someone this weekend who had just quit Spotify. She isn’t a tech person. She didn’t even know Bandcamp exists. Just didn’t want to give more money to a company that’s clearly evil. This is the future of tech, if there is any. People who pay attention to the world, who are willing to do things the hard way and stop giving money to people who are clearly evil.

This week is still largely focused on finalizing API/ABI for the 1.0 of Foundry in a few weeks.

Foundry

• Did a bunch of work on LLM completion and and conversation APIs. They are not focused on supporting everything possible but instead making some of the common stuff extremely simple. That goes for both the model size of things and the UI side of things.

  For example, heavy usage of GListModel everywhere we can.

• Created new abstractions for LlmTool, LlmToolProviders, and the actual call of a tool (aptly, LlmToolCall). One reason this all takes so much time to scaffold is that you want to allow some amount of flexibility when connecting models, but also avoid too much API surface area.

  I think I’ve managed to do that here.

• Landed Ollama implementation of the FoundryLlmConversation API. The ollama server appears to be stateless, which means copying the conversation over-and-over as you go. I guess this at least gives you an idea of your context window.

• Setup a couple tool call implementations to test out that infrastructure. For example, it’s really easy to tell the model that you build with build tool and then provide it the results.

• Fixed some licensing issues where I mostly just forgot to update the headers when copying them over. Things should be in a good place now for distributions to adhere to their SPDX rules.

• Language settings now have a very last resort setting which are the “defaults” we ship with the library. That is just sensible stuff like using 4 spaces for tabs/indent in Python.

  Settings at any layer can override these values.

• Lots of work on project templates. We have both GTK 4 and Adwaita templates again. They support C/Python/rust/JavaScript like Builder does too.

  But this time I tried to go a bit further. They should have a bunch of integration bits setup which we didn’t get to before.

• Setup an example Flatpak manifest for applications wanting to use libfoundry (see examples/flatpak/ ) that should help get you started.

• Setup i18n/l10n for libfoundry . I don’t think anything is consuming translations for GNOME 49 though, so mostly just gets us up and running for 50.

• Landed some new API for working with the stage/index within FoundryGitVcs . Tested it with a speed-run challenge a bit later on in this report.

Assist

• To test out the LLM APIs and ensure they can actually be used I did a speed-run to implement a “Foundry-based Developer Chat” with a time limit of two hours.

  The reality is that I’m still _much_ faster writing code with all of my templates and snippets than I thought.

  The new templates in Foundry are killer though.

• It requires a model which supports tool calls if you want to do anything interesting with it. I’m not sure if there are models which can do both written output _and_ tool-calls which makes this a bit annoying to wait while it figures out it should call a tool.

• While doing this, I realized a bunch of little things to fix in the LLM APIs. One piece still missing that I’d want to have in the future is the ability for specialized FoundryLlmMessage which not only have text content but typed data as well.

  For example, a tool call that is essentially a ls should really display the output as an interactive directory list and not text.

  But since this was a speed run, I did not implement that. Only made sure that the APIs could adapt to it in the future.

Staged

• Started another speed-run app to test out the version control engine we have in Foundry. This one is basically just to replace my very quick use of git-gui to line stage patches.

  Came up with a neat way to highlight old/new versions of a file and then display them with GtkListView instead of using a source view. No reason to power up the editing infrastructure if you’ll never be editing.

Manuals

• Discovered I wasn’t getting notifications since the move to the GNOME/ namespace so flushed out the backlog of MR there.

GtkSourceView

• Fix click-through on the overview map which broke again during this development cycle. My fault for not reviewing and/or testing better.

• Now that we have GNOME CI doing LSAN/ASAN/UBSAN/coverage/scanbuild I went ahead and fixed a bunch of leaks that are part of the testsuite.

  Additionally, it helped me find a few that were there in everyday code use, so that is always a lovely thing to fix.

Ptyxis

• Merge some last minute string changes before we can’t anymore.

• Still having to unfortunately close issues which come from Debian not sourcing /etc/profile.d/vte.sh by default, thus breaking integration features.

  The good news I hear is that will be changing before long.

• Other good news is that Ptyxis has landed in the 25.10 builds and will also be landing in Debian unstable in the near future as the default terminal.

• After some back-and-forth I merged support for the kgx palette as the “GNOME” palette in Ptyxis. My very hopeful desire is that this becomes something maintained by the design team. The problem is just that terminal colors are a huge piles of hacks on hacks.

• Nightly builds should be fixed. Apparently something changed in the CI setup and since we’re under chergert/ptyxis/ and not GNOME/ it didn’t get automatically applied.

• Some styling changed in libadwaita this cycle and I needed to adapt how we propagate our styling to tab close buttons.

  Really though, this all just needs to be redone (like Text Editor and Builder) to use var() properly in CSS.

Libspelling

• Merged patch improving life-cycle tracking of the piecetable/b+tree regions (branches/leaves).

Sysprof

• More code review and future feature planning so we can land GSoC things after I branch for 49 (very soon I hope).

Other

• Turned 41, saw Stevie Ray Vaughan’s broadcaster guitar, finally had the “weird” pizza at Lovely’s fifty/fifty, jammed at MoPOP with my niece.

• Lots of random little things this week to lend a hand/ear here or there as we get closer to release.

Misc news about the gedit text editor, mid-August edition! (Some sections are a bit technical).

Code Comment plugin rewritten

I forgot to talk about it in the mid-July news, but the Code Comment plugin has been rewritten in C (it was previously implemented in Python) and the bulk of it is implemented as re-usable code in libgedit-tepl. The implementation is now shared between Enter TeX and gedit.

File loading and saving: a new GtkSourceEncoding class

I've modified the GtkSourceEncoding class that is part of libgedit-gtksourceview, and adapted gedit accordingly. The new version of GtkSourceEncoding comes from an experiment that I did in libgedit-tepl several years ago.

GtkSourceEncoding represents a character set (or "charset" for short). It is used in combination with iconv to convert text files from one encoding to another (for example from ISO-8859-15 to UTF-8).

The purpose of the experiment that was done in libgedit-tepl (the TeplEncoding class) was to accomodate the needs for a uchardet usage (note that uchardet is not yet used by gedit, but it would be useful). uchardet is a library to automatically detect the encoding of some input text. It returns an iconv-compatible charset, as a string.

It is this string - returned by uchardet - that we want to store and pass to iconv unmodified, to not lose information.

The problem with the old version of GtkSourceEncoding: there was a fixed set of GtkSourceEncoding instances, all const (so without the need to free them). When trying to get an instance for an unknown charset string, NULL was returned. So this was not appropriate for a uchardet usage (or at least, not a clean solution: with the charset string returned by uchardet it was not guaranteed that a corresponding GtkSourceEncoding instance was available).

Since GtkSourceEncoding is used in a lot of places, we don't want to change the code to represent a charset as just a string. And a simple string is anyway too basic, GtkSourceEncoding provides useful features.

So, long story short: the new GtkSourceEncoding class returns new instances that must be freed, and has a constructor that just makes a copy of the charset string (there is the get_charset() method to get back the string, unmodified).

So gedit can keep using the GtkSourceEncoding abstraction, and we are one step closer to being able to use uchardet or something similar!

Know more about the gedit's maintainer

I now have a personal web site, or more accurately a single web page :
wilmet-software.be (Sébastien Wilmet)

gedit is a 27-years-old project, the first lines were written in 1998 (and normally it won't be part of the 27 Club !). I've been a contributor to the project for 14 years, so more than half the project existence. Time flies!

Robust file loading - some progress

After the rework of GtkSourceEncoding (which is part of the File Loading and Saving subsystem in libgedit-gtksourceview), I've made good progress to make the file loading more robust - although there is more work still to do.

It is a basis in programming to check all program input. gedit makes things a bit harder to accomplish this. To open a document :

• There is first the problem of the character encoding. It is not sufficient for a general-purpose text editor to accept only UTF-8. So text files can be almost anything in binary form.
• Then gedit allows to open documents containing invalid characters in the specified or auto-detected encoding. With this, documents can really be anything in binary form.
• Finally the GtkTextView widget used at the heart of gedit has several limitations: (1) very big files (like log files or database dumps) are not supported, a limit on the content size must be set (and if reached, still allow to load the file with truncated content). (2) very long lines cause performance problems and can freeze the application.

So, the good news is that progress has been made on this. (There is only a good news, let's stay positive!).

If you appreciate the work that I do in gedit, I would like to know your feedback, what I should improve or which important feature is missing. You can contact me by email for example, or on a discussion channel . Thank you :-) !