Ptyxis

• More back and forth on people who have issues with diacritics and ibus interaction. It’s extremely frustrating at times because the two places where stuff like this gets reported first is the text editor and terminal, when rarely those two applications have anything to do with the issue.

  In this case we might have a workaround by being a bit more explicit about focus grabs.

• Merge support for changing profile on existing tab.

VTE

• Back-and-forth on updating MR for PTY errno, merge to master, vte-0-82, possibly backport further for RHEL/CentOS.

• Research some us dead key issues with diacritics and see if we can find where in VTE a problem could be. Text Editor apparently doesn’t replicate the same issue, so it’s possible we should fix something in VTE directly or in GTK IM abstractions. As mentioned in Ptyxis we can probably work around this for now.

Foundry

• Now that foundry has support for API keys we need to have a mechanism to rotate those keys (and query for expiration). FoundryKeyRotator provides this abstraction to FoundrySecretService .

  This comes with foundry secret rotate HOST SERVICE which makes it easy to keep things up-to-date. It would be nice to do this automatically at some point though it’s rather annoying because you’ll get an email about it, at least from gitlab.

  To check the expiration, foundry secret check-expires-at is provided check again, takes a HOST SERVICE pair.

  Defaults to what the server wants for minimum key lifetime, or you can provide --expire-at=YYYY-MM-DD to specify expiration.

• Implement symbol APIs for FoundryTextDocument which will power things like the symbol tree, what symbol is underneath my cursor, symbol path bars, and the like. Also added some command line tools for this so that it is easy to test the infrastructure when issues are inevitably filed.

  foundry symbol-tree FILE and foundry find-symbol-at FILE LN COL will quickly test the machinery for filing bug reports.

• Updated the CTags parser (which is our usually “first implementation” symbol provider) out of simplicity. Allow it to generate data to GBytes instead of files on disk for usage on modified buffers. Also allow it to load an index from memory w/o touching disk for the other side of this index structure.

• GCC changed the SARIF environment variable to EXPERIMENTAL_SARIF_SOCKET so track that for GCC 16 release.

• Handy foundry_read_all_bytes(int fd) to exhaust a FD into a GBytes using the libdex AIO subsystem ( io_uring , etc).

• Prototype a tree-sitter based plugin for symbol providers so we can have some faster extractors at least for some very common languages.

• Add FoundrySymbolLocator for locating symbols by a number of strategies that can be different based on the provider. Combine this with a new FoundrySymbolIntent to integrate into the intent system.

• Implement FoundryPathNavigator for use in future pathbar work. Add subclasses for FoundrySymbolNavigator and FoundryDocumentationNavigator to make pathbars of those common hierarchies super easy from applications. A FoundryFileNavigator to be able to navigate the file-system. This ties in well with the intent system so activating path elements routes through intents like open-file intent, symbol intent, etc.

• Implement FoundryPathBar and associated infrastructure for it to be abstracted in libfoundry-adw.

• Implement LSP progress operations ( $/progress and creation operations) so we can bridge them to FoundryOperation . Had to implement some missing bits of FoundryJsonrpcDriver while at it.

• Improve support for LSP symbol APIs, particularly around support for hierarchical symbol trees. Newer revisions allow for symbols to contain other symbols rather than trying to recreate it from the containerName .

• Discovered that there is an upper-limit to the number of GWeakRef that can be created and that number is surprisingly lower than I would expect. Sure there is extra overhead with weak refs, but having limits so low is surely a mistake.

• Lots of work on LSP implementation to bridge things like diagnostics and symbols. It is amazing now much easier it is to do this time around now that I have fibers instead of callback noodles.

• We have a much saner way of implementing buffer tracking this time around (especially after pushing commit notify into GTK) so the LSP integration around buffer synchronization has a cleaner implementation now.

• Add tooltips support to the diagnostics gutter renderer.

• A new “retained” listmodel which allows you to hold/release items in a list model and they’ll stay pinned until the hold count reaches zero. This is helpful for situations where you don’t want to affect an item while there is a mouse over something, or a popover is shown, that sort of deal. I didn’t opt for the scalable RBTree implementation yet, but someone could certainly improve it to do so.

Buider

• Work on the new auxiliary panel design which will work a bit like it does in Text Editor but allow for panel groupings.

• Symbols panel implementation work using the new symbol providers. Implement symbol intent handling as well to tie it all together.

• Implement pathbar integration into text editor and documentation browser using new navigator integration.

• Diagnostics panel for monitoring diagnostics across the active page without having to resort to scanning around either the global diagnostics or within the gutter.

• Add annotation provider so we can show diagnostics/git-blame like we do now but in a much more optimized manner. Having diagnostics inline is new though.

• Lots of styling work for the auxiliary panel to try to make it work well in the presence of a grid of documents. A bit harder to get right than in Text Editor.

• Ergonomics for the messages panel (clipboard support, clearing history, etc).

• Work on operation bay for long running operations similar to what Nautilus does. This will handle things like progress from LSPs, deployment to remote devices, etc.

CentOS

• libadwaita backports. This one is rather frustrating because I’ve been told we can’t do sassc on the build infrastructure and since 1.6.3 libadwaita no longer generates the CSS on CI to be bundled with the tarball.

  So continue with the madness of about 60 patches layered on top of 1.6.2 to keep things progressing there. One patch won’t get in because of the CSS change which is unfortunate as it is somewhat a11y related.

  At the moment the options are (given the uncompromising no-sassc restriction), to keep back-porting and not get CSS changes, to pull in newer tarballs and generate the CSS on my machine and patch that in, or just keep doing this until we can *gestures* do something more compromising on the CentOS build infrastructure.

• VTE backports for 0.78.6

GtkSourceView

• Branched for 5.20 development so we can start adding new features.

• Fix a gir annotation on GtkSourceAnnotation that had wrong transfer.

• Make GtkSourceAnnotation right justified when it fits in the available space.

• Add some nice styling to annotations so they are bit more pleasing to look at.

GNOME’s Code of Conduct is our community’s shared standard of behavior for participants in GNOME. This is the Code of Conduct Committee’s periodic summary report of its activities from May 2025 to October 2025.

The current members of the CoC Committee are:

• Anisa Kuci
• Carlos Garnacho
• Christopher Davis
• Federico Mena Quintero
• Michael Downey
• Rosanna Yuen

All the members of the CoC Committee have completed Code of Conduct Incident Response training provided by Otter Tech, and are professionally trained to handle incident reports in GNOME community events.

The committee has an email address that can be used to send reports: conduct@gnome.org as well as a website for report submission: https://conduct.gnome.org/

Reports

Since May 2025, the committee has received reports on a total of 25 possible incidents. Many of these were not actionable; all the incidents listed here were resolved during the reporting period.

• Report on a conspiracy theory, closed as not actionable.
• Report that was not actionable.
• Report about a blog post; not a CoC violation and not actionable.
• Report about interactions in GitLab; not a CoC violation and not actionable.
• Report about a blog post; not a CoC violation and not actionable.
• Question about an Export Control Classification Number (ECCN) for GDM; redirected to discourse.gnome.org.
• Report about a reply in GitLab; not a CoC violation; pointed out resources about unpaid/volunteer work in open source.
• Report about a reply in GitLab; not a CoC violation but using language against the community guidelines; sent a reminder to the reported person to use non-violent communication.
• Two reports about a GNOME Shell extension; recommended actions to take to the extension reviewers.
• Report about another GNOME Shell extension; recommended actions to take to the extension reviewers.
• Multiple reports about a post on planet.gnome.org; removed the post from the feed and its site.
• Report with a fake attribution; closed as not actionable.
• Report with threats; closed as not actionable.
• Report with a fake attribution; closed as not actionable.
• Report that was not actionable.
• Support request; advised reporter to direct their question to the infrastructure team.
• Report closed due to not being actionable; gave the reporter advice on how to deal with their issue.
• Report about a reply in GitLab; reminded both the reporter and reported person how to communicate appropriately.
• Report during GUADEC about an incident during the conference; in-person reminder to the reported individual to mind their behavior.
• Report about a long-standing GitLab interaction; sent a request for a behavior change to the reported person.
• Report on a conspiracy theory, closed as not actionable.
• Report about a Mastodon post, closed as it is not a CoC violation.
• Report closed due to not being actionable, and not a CoC violation.
• Report closed due to not being actionable, and not a CoC violation.
• Report closed due to not being actionable, and not a CoC violation.

Meetings of the CoC committee

The CoC committee has two meetings each month for general updates, and weekly ad-hoc meetings when they receive reports. There are also in-person meetings during GNOME events.

Ways to contact the CoC committee

• https://conduct.gnome.org – contains the GNOME Code of Conduct and a reporting form.
• conduct@gnome.org – incident reports, questions, etc.

PDF/A is a specific version of PDF designed for long term archival of electronic data. The idea being that PDF/A files are both self contained and fully specified, so they can be opened in the future without any loss of fidelity.

Implementing PDF/A export is complicated by the fact that the specification is an ISO standard, which is not publicly available. Fortunately, there are PDF/A validators that will tell you if (and sometimes how) your generated PDF/A is invalid. So, given sufficient patience, you can keep throwing PDF files at the validator, fixing the issues reported and repeating this loop over and over until validation passes. Like this:

This will be available in the next release of CapyPDF.

Ptyxis

• Handle some incoming issue reports which basically amounts to copying their question into google, searching, and copying the first result back. A reminder that we really need dedicated support channels that are not the issue tracker.

  But more importantly, how you move people there is still problematic. I could of course just tell them to go over “there”, but when the questions are so simple you end up taking the gentler approach and just answering it begrudgingly rather than coming off abrupt.

• Issue reported about an async spin loop from GMainLoop after closing a window which has a really long paste actively feeding it. Looks like it needs to be addressed in VTE (more on that below), but also decided to raise priority of our fallback SIGKILL handler if SIGHUP failed.

• Code review for incoming community feature to swap profiles on an active tab.

VTE

• MR sent upstream to hopefully address the corner case of disposing a terminal widget while paste is ongoing.

• Noticed that ibus-daemon is taking considerable CPU when running the ucs-decode test tool on Ptyxis/VTE. Probably something related to tracking input cursor positions w/ the text protocol or similar. Reached out to @garncho for any tricks we might be able to pull off from the VTE side of things.

Libdex

• Looking into some strange behaviors with dex_thread_wait_for() when implementing the cross-thread semantics for libgit2 wrapping. As a result I changed where we control life-cycle for the waited upon future so that it is guaranteed longer than the DexWaiter.

• Spend some time thinking about how we might approach a more generalized wrapper for existing GIO-like async functions. I was never satisfied with DexAsyncPair and perhaps now that we will gain a gdbus-codegen for Libdex we could gain a *.gir future wrapping codegen too.

• Add a new DexFutureListModel which is a GListModel which is populated by a DexFuture resolving to a GListModel . Very handy when you have a future and want a GListModel immediately.

Foundry

• Add FoundryFileRow so we have easy mechanics for the whole typing a file/directory path and browsing to it. Re-use the existing path collapse/expand stuff in Foundry to allow for niceties like ~/Directory . Fix a bunch of obnoxiousness that was in the Builder implementation of this previously.

• Add foundry_operation_is_cancelled() to simplify integrating with external blocking/threaded code such as libgit2. This allows breaking out of a clone operation by checking for cancellation in the progress callbacks from the server but works for any sort of blocking API that itself has callback functions in its state machine.

• Add new CLI formatter for GFlags to use value_nick instead of the whole enumeration value in UP_CASE .

• Add FoundryBuildPipeline:build-system with discover from the FoundryBuildAddin before full addin loading occurs. This replicates the IdeBuildSystemDiscovery from Builder without having to use a secondary addin object.

• Add priorities to FoundryBuildAddin so that we can pre-sort by priority before build-system discovery. That fixes loading the WebKit project out of the box so that CMakeLists.txt will be matched before Makefile if you configured in tree.

• Implement write-back for FoundrySdkManager:sdk to the active configuration after checking of the config supports the SDK.

• Implement write-back for buildconfig files.

• Implement mechanics for write-back PluginFlatpakConfig . Also start on implementation for all the FlatpakSerializable types. This is made much more complicated by needing to keep track of the different subtle ways lists can be deserialized as well as referenced files which can be included. It will mean write-back may have a bucket of files to update. Though right now we only will do this for a few select fields so we can probably punt a bit.

• Meson cleanup to all our tools that test various aspects of Foundry outside the confines of an entire IDE.

• Non-destructive editing of flatpak manifests works for the core feature-set we need. It requires storing a lot of state while parsing manifests (and recursively their includes) but it seems to work well enough.

• Setup needs-attention tracking for panels and pages.

• Write a new foundry.1 manpage for inclusion in distributions that really want that provided.

• Add :author property to FoundryForgeIssue and FoundryForgeMergeRequest so we can start presenting peer information in the Builder UI. Implement this for gitlab plugin.

• Improve handling to changes in implicit-trailing-newline from file settings getting loaded/applied. That way we don’t run into weird behavior with file-change monitoring with ligbit2 getting something different than we’d expect.

• Support for keyword search when listing issues/merge-requests through the forge interfaces.

• Add FoundryDocumentationIntent for intent to read documentation.

• Very basic support for Justfile using just to build. Currently it is sort of a cop-out because it uses build and clean instead of trying to track down [default] and what not. Contributions welcome.

Builder

• Iteration on the new clone dialog based on Foundry including wiring up all the PTY usage, page navigation, etc.

• Update builder-dark GtkSourceView style to fit in better with updated Adwaita palette. Even though it’s not using Tango palette for all the colors, we still want it to fit in.

• Iteration on forge listings

• Wire up needs attention for panels/pages

• Setup forge splitbutton so we can jump to gitlab (or other forge) quickly or alternatively list issues/etc in app as we gain more forge support.

• Implement manuals panel and page on top of the Foundry service FoundryDocumentationManager .

• Implement browser page and port over old urlbar implementation. Still slogging through all the intricacies of navigation policy which I didn’t handle so well in Builder originally.

• Work on bringing over path bar from Manuals so we can use it more generically for things like symbol paths and what not.

• A lot of little things here and there that just need plumbing now that we’re in a world of futures and listmodels.

• Lots of work on the updated greeter using Foundry. It looks mostly the same, just less madness in implementation.

Flathub

• Investigate why older Builder is what is shown as published.

• Merge PR to update Ptyxis to 49.2

• Update Manuals to 49.1 since I missed the .0. Had a lot of libfoundry things to bring over as well. Needs an exceptions update to flathub linter.

Text Editor

• Update builder style scheme

Libpanel

• Update needs-attention style for the panel switcher buttons

Manuals

• Make ctrl+k select all the existing text in the search entry as part of the focus-search action.

It’s been four months since my last Digital Wellbeing update . In that previous post I talked about the goals of the Digital Wellbeing project. I also described our progress improving and extending the functionality of the GNOME Parental Controls application, as well as redesigning the application to meet the current design guidelines.

Introducing Screen Time Limits

Following our work on the Parental Controls app, the next major work item was to implement screen time limits functionality, offering the parents ability to check the child’s screen time usage, set the time limits, and lock the child account outside of a specified curfew. This feature actually spanned across *three* different GNOME projects:

• Parental Controls: Screen Time page was added to the Parental Controls app, so that parents can view child screen usage an set the time limits, it also includes a detailed bar chart
• Settings: Wellbeing panel needed to make its own time limits settings impossible to change when the child has parental controls session limits enabled, since they are not in effect in such situation. There’s now also a banner with an explanation that guides to the Parental Controls app
• Shell: Child session needed to actually lock when the limit was reached

Out of all of the three above, the Parental Controls and Shell changes have been already merged, while the Settings integration has been through unwritten review during the bi-weekly Settings meeting and adjusted to the feedback, so it’s only a matter of time now before it reaches the main branch as well. You can find the screenshots of the added functionalities below, and the reference designs can be find in the app-mockups and os-mockups tickets.

Child screen usage

When viewing a managed account, a summary of screen time is shown with actions for changing further settings, as well as actions to access additional settings for restrictions and filtering.

Child account view with added screen time overview and action for more options

The Screen Time view shows an overview of the child’s account’s screen time as well as controls which mirror those of the Settings panel to control screen limits and downtime for the child.

Screen Time page with detailed screen time records and time limit controls

Settings integration

On the Settings side, a child account will see a banner in the Wellbeing panel that lets them know some settings cannot be changed, with a link to the Parental Controls app.

Wellbeing panel with a banner informing that limits can only be changed in Parental Controls

Screen limits in GNOME Shell

We have implemented the locking mechanism in GNOME Shell. When a Screen Time limit is reached, the session locks, so that the child can’t use the computer for the rest of the day.

Following is a screen cast of the Shell functionality:

Preventing children from unlocking has not been implemented yet. However, fortunately, the hardest part was implementing the framework for the rest of the code, so hopefully the easier graphical change will take less to implement and the next update will be much sooner than this one.

GNOME OS images

You don’t have to take my word for it, especially since one can notice I’ve had to cut the recording at one point (forgot that one can’t switch users in the lock screen :P) – you can check out all of these features in the very same GNOME OS live image I’ve used in the recording, that you can either run in GNOME Boxes , or try on your hardware if you know what you’re doing

Malcontent changes

While all of these user facing changes look cool, none of them would be actually possible without the malcontent backend, which Philip Withnall has been working on. While the daily schedule had already been implemented, the daily limit session limit had to be added, as well as malcontent timer daemon API for Shell to use. There has been many other improvements, web filtering daemon has been added, which I’ll use in the future for implementing Web Filtering page in Parental Controls app.

Conclusion

Our work for the GNOME Foundation is funded by Endless and Dalio Philanthropies, so kudos to them! I want to thank Florian Müllner for his patience too, during the very educative for me merge request review, and answering to all of my Shell development wonderings. I also want to thank Matthijs Velsink and Felipe Borges for finding time to review the Settings integration.

Now that this foundation has been made, we’ll be focusing on finishing the last remaining bit of the session limits support in Shell, which is tweaking the appearance of lock screen when the limit is reached, and implementing the ignore button for extending screen limit, as well as notifications, followed by Web Filtering support in Parental Controls. Until next update!

Some notes on my first serious coding projects in something like 20 years, possibly longer. If you’re curious what these projects mean , more thoughts over on the OpenML.fyi newsletter.

TLDR

A GitHub contribution graph, showing a lot of activity in the past three weeks after virtually none the rest of the year.

News, Fixed

The “ Fix The News ” newsletter is a pillar of my mental health these days, bringing me news that the world is not entirely going to hell in a handbasket. And my 9yo has repeatedly noted that our family news diet is “broken” in exactly the way Fix The News is supposed to fix—hugely negative, hugely US-centric. So I asked Claude to create a “newspaper” version of FTN — a two page pdf of some highlights. It was a hit.

So I’ve now been working with Claude Code to create and gradually improve a four-days-a-week “News, Fixed” newspaper. This has been super-fun for the whole family—my wife has made various suggestions over my shoulder, my son devours it every morning, and it’s the first serious coding project I’ve tackled in ages. It is almost entirely strictly personal (it still has hard-coded Duke Basketball schedules) but nevertheless is public and FOSS . (It is even my first usage of reuse.software —and also of SonarQube Server !)

Example newspaper here .

No matter how far removed you are from practical coding experience, I cannot recommend enough finding a simple, fun project like this that scratches a human itch in your life, and using the project to experiment with the new code tools.

Getting Things Done assistant

While working on News, Fixed a friend pointed out Steve Yegge’s “ beads ”, which reimagines software issue tracking as an LLM-centric activity — json-centric, tracked in git, etc. At around the same time, I was also pointed at Superpowers —essentially, canned “skills” like “teach the LLM, temporarily, how to brainstorm”.

The two of these together in my mind screamed “do this for your overwhelmed todo list”. I’ve long practiced various bastardized versions of Getting Things Done, but one of the hangups has been that I’m inconsistent about doing the daily/weekly/nth-ly reviews that good GTD really relies on. I might skip a step, or not look through all my huge “someday-maybe” list, or… any of many reasons one can be tired and human when faced with a wall of text. Also, while there are many tools out there to do GTD, in my experience they either make some of the hardest parts (like the reviews) your problem, or they don’t quite fit with how I want to do GTD, or both. Hacking on my own prompts to manage the reviews seems to fit these needs to a T.

I currently use Amazing Marvin as my main GTD tool. It is funky and weird and I’ve stuck with it much longer than any other task tracker I’ve ever used. So what I’ve done so far:

• wrapped the Marvin API to extract json
• discovered the Marvin API is very flaky, so done some caching and validation
• written a lot of prompts for the various phases/tasks in GTD. These work to varying degrees and I really want to figure out how to collaborate with others on them, because I suspect that as more tools offer LLM-ish APIs ( whoa, todoist! ) these prompts are where the real fun and action will be.

This is all read-only right now because of limitations in the Marvin API but for various reasons I’m not yet ready to embark on building my own entire UI. So this will do for now. But this code, therefore, is very limited to me. The prompts on the other hand…

Note that my emphasis is not on “do tasks”, it is on helping me stay on priority. Less “chief of staff”, more “executive assistant”—both incredibly valuable when done well, but different roles. This is different from some of the use examples for Yegge’s Beads, which really are around agents.

Also note: the results have been outstanding. I’m getting more easily into my doing zone, I think largely because I have less anxiety about staring at the Giant Wall of Tasks that defines the life of any high-level IC. And my projects are better organized and todos feel more accurate than they have been in a long time, possibly ever.

a note on LLMs and issue/TODO tracking

It is worth noting that while LLMs are probabilistic/lossy, so they can’t find the “perfect” next TODO to work on, that’s OK. Personal TODO and software issue tracking are inherently subjective, probabilistic activities—there is no objectively perfect “next best thing to work on”, “most important thing to work on”, etc. So the fact that an LLM is only probabilistic in identifying the next task to work on is fine—no human can do substantially better. In fact I’m pretty sure that once an issue list is past a certain point, the LLM is likely to be able to do better— if (and like many things LLM, this is a big if) you can provide it with documented standards explaining how you want to do prioritization. (Literally one of the first things I did at my first job was write standards on how to prioritize bugs—the forerunner of this doc —so I have strong opinions, and experience, here.)

Skills for license “concluded”

While at a recent Linux Foundation event, I was shocked to realize how many very smart people haven’t internalized the skills/prompts/context stuff. It’s either “you chat with it” or “you train a model”. This is not their fault; it is hard to keep up!

Of course this came up most keenly in the context of the age-old problem of “how do I tell what license an open source project is under”. In other words, what is the difference between “I have scanned this” and “I have reached the zen state of SPDX’s ‘ concluded ’ field”.

So … yes, I’ve started playing with scripts and prompts on this. It’s much less further along than the other two projects above, but I think it could be very fruitful if structured correctly. Some potentially big benefits above and beyond the traditional scanning and/or throw a lawyer at it approaches:

• reporting: my very strong intuition, admittedly not yet tested, is that plain-English reports on factors below, plus links into repos, will be much easier for lawyers to use as a starting point than the UIs of traditional license-scanner tools. And I suspect ultimately more powerful as well, since they’ll be able to draw on some of the things below.
• context sensitivity: unlike a regexp, an LLM can likely fairly reliably understand from context some of the big failures of traditional pattern matching like “this code mentions license X but doesn’t actually include it”.
• issue analysis and change analysis: unlike traditional approaches, LLMs can look at the change history of key files like README and LICENSE and draw useful context from them. “oh hey README mentioned a license change on Nov. 9, 2025, here’s what the change was and let’s see if there are any corresponding issues and commit logs that explain this change” is something that an LLM really can do. (Also it can do that with much more patience than any human.)

ClearlyDefined offers test data on this, by the way — I’m really looking forward to seeing if this can be made actually reliable or not. (And then we can hook up reuse.software on the backend to actually improve the upstream metadata…)

But even then, I may not ever release this. There’s a lot of real risks here and I still haven’t thought them through enough to be comfortable with them. That’s true even though I think the industry has persistently overstated its ability to reach useful conclusions about licensing, since it so persistently insists on doing licensing analysis without ever talking to maintainers.

More to come?

I’m sure there will be more of these. That said, one of the interesting temptations of this is that it is very hard to say “something is done” because it is so easy to add more. (eg, once my personal homebrew News Fixed is done… why not turn it into a webapp? once my GTD scripts are done… why not port the backend? etc. etc.) So we’ll see how that goes.

• Slept badly, up late, catch up with Dave. Prepared TTT slides on making patches easy to review with Szymon & gave that.
• Lunch, synched with Andras to unwind some horror service authentication issue. Collected car from MOT/service in Bury with J.
• Interview, dinner, interview prep with M.
• Unclear whether to be encouraged or disappointed to have a new SpaceX association from a bogus profile on Linked-In, apparently we're the obvious choice of COOL-kid to associate with:
  
  I'd never considered to check the staff for bogus employees before, I wonder how many companies do that; kudos to Darshan for the catch.

It’s Friday, so it’s time to provide an update on what’s been happening at the GNOME Foundation over the past week. Here’s my summary of the main activities and events, covering what both Board and staff members have been up to.

GNOME.Asia

I mentioned GNOME.Asia 2025 in my last post, but I’ll mention it again since it’s only a month until the event in Tokyo, which is being co-hosted with LibreOffice Asia .

As you’d expect, there is a lot of activity happening as GNOME.Asia 2025 approaches. Kristi has been busy with a plethora of organisational tasks, including scheduling, printing, planning for the day trip, and more.

Travel has also been a focus this week. The Travel Committee has approved sponsorship for a number of attendees, and we have moved on to providing assistance to those who need documentation for visas.

Finally, registration is now open! There are two registration sites: one for in-person attendees , and one for remote attendees . If you plan on attending, please do take the time to register!

Transitions

This week was a big week for us, with the announcement of Rosanna’s departure from the organisation. Internally transition arrangements have been in progress for a little while, with responsibilities being redistributed, accounts being handed over, and infrastucture that was physically managed by Rosanna being replaced (such as our mailing address and phone number). This work continued this week.

I’d like to thank Rosanna for her extremely helpful assistance during this transition. I’d also like to thank everyone who was pitched in this week, particularly around travel (thank you Kristi, Julian, Maria, Asmit!), as well as Cassidy and Arun for picking up tasks as they have arisen.

The Foundation is running smoothly despite our recent staffing change. Payments are being processed quickly and reliably, events and sysadmin work are happening as normal, and accounting tasks are being taken care of. I’m also confident that we’ll continue to work reliably and effectively as we move forward. There are improvements that we have planned which help with this, such as the streamlining of our financial systems and processes.

Ongoing tasks

It has become a common refrain in my updates that there is lots going on behind the scenes that doesn’t make it into these posts. This week I thought that I’d call some of those more routine activities out, so readers can get a sense of what those background tasks are.

It turns out that there is indeed quite a lot of them, so I’ve broken them down into sections.

Finances and accounting

It’s the beginning of the month, which is when most invoices tend to get submitted to us, so this week has involved a fair amount of payments processing. We use a mix of platforms for payments, and have a shared tracker for payments tasks. At the time of writing all invoices received since the beginning of the month have been paid, except for a couple of items where we needed additional information.

As mentioned in previous posts, we are in the process of deploying a set of improvements to our banking arrangements, and this continued this week. The changes are coming in bit by bit, and there are tasks for us to do at each step. It will be a number of weeks before the changes are completed.

Dawn who joined us last week has been doing research as part of her work to improve our finance systems. This has involved doing calls with team members and stakeholders, and is nearly complete.

Meetings!

Kristi booked the room for our regular pre-FOSDEM Advisory Board meeting, and I’ve invited representatives. Thanks to everyone who has sent an RSVP so far!

Next week we have another regular Board meeting scheduled, so there has been the routine work of preparing the agenda and sending out invitations.

Sysadmin work

Bart has been busy as usual, and it’s hard to capture everything he does. Recent activity includes improvements to donate.gnome.org, improvements to Flathub build pipelines, and working through a troublesome issue with the geolocation data used by GNOME apps.

That’s it for this week! Thanks for reading, and see you next week.