The timeline for Google Summer of Code is coming to an end, and us interns are piecing together the final touches to our projects for submission. Thanks to the help of my mentors, and the duck sitting on my monitor, the algorithm that beats the heart of Vocab Crosswords in GNOME Crosswords has been tremendous strides in accuracy and testability. The primary focus shifted to getting the algorithm landed by the end of the summer, and working on the frontend of the application post-GSoC.

Unit Tests

At GUADEC, with the help of Federico, I created unit tests to see how my functions reacted in a given circumstance. Jonathan and I worked on creating different circumstances for the run and helper functions.

Optimization

For user optimization, we don’t want to keep the board at a strict 30×30 grid and only allow for the first viable option. We decided to incorporate a new function to trim the dimensions of the generated grids based on the outermost edges of the letters, create a new board based on the newly calculated dimensions, trim that board down respectively, and copy the words over in the exact respective format. This is due to the libipuz grid’s origin point (0, 0) being fixed at the uppermost left corner cell. All in all, the trimming function essentially does this:

Additionally, it is pretty ideal to have some leeway of choice on how you want your puzzle to look. Some puzzles might generate lanky, while others extensively branched out all the way to the maximum borders, and the rest perhaps condensed together. The ability to rearrange the ordering of the words is already a feature in Crosswords thanks to PuzzleTask. But, it is for known grids of typically 15×15 sandwiched together. What is different with the vocab puzzle is that the rearrangement must still respect the same constraints of intersecting at a single letter nodal point, words cannot be on top of nor right next to each other (edge of nodes must respect space), and no islands (all words must share at least one node with another word). For instance, grids A and B here pertain the same words 1 through 6, but these words can connect differently on the graph, producing two options to choose from.

Tested, I achieved these 3 different versions of grids based off the same word bank:

Island Checking

The final component I will implement within GSoC’s timeline is checking for islanding words. Say a user provides a list of words and one word absolutely cannot intersect with any other word, it shares no node. The backtracking algorithm will spend a lot of time trying to place it, or invalidate any graph generation at all. We want to check beforehand if a word would not belong along the rest, and warn the user about it. Because there are many alphabets that exist, we are going to analyze the sets of characters as guint64 bitsets and GHashTable. Every unique character gets its own bit-slot, and every word’s 64-bit mask is compared to available words using bit operations.

I’m happy to announce that the SparkleShare project will receive a grant from the NLnet Foundation’s NGI0 Commons fund!

Sync files with Git

SparkleShare is a Free and Open Source collaboration app. It allows people who are not software developers or otherwise technical (designers, lawyers, students, academics, etc.) to work together and share files in projects that use the Git version control system.

SparkleShare provides an automatic sync algorithm and a friendly user interface to review changes and restore files from history.

What happened?

SparkleShare has been around since 2010. I guess that makes it an “old” project now… Since then, the Mono/C# community active around that time has all but disbanded. The platform underneath slowly started to rot.

Eventually the app had to be removed from Flathub, also due to my own maintainer burnout. Providing maintenance and support next to a full-time job proved too much.

But that’s no longer an issue.

Now I have an opportunity to rebuild and address long-standing issues and feature requests. I have renewed energy to bring back the project better than ever!

The work

The funding proposal is to finish porting to Rust, bring SparkleShare in line with modern security and privacy practices, and design a fresh user interface informed by years worth of community feedback.

The goal is to get a Linux release back on Flathub. I’m planning to post frequent updates, so subscribe or follow me on GitHub or the Fediverse.

In these turbulent times, one frequently needs to run some tooling in a sandbox. The goal is mainly to reduce the blast radius: make it so programs within the sandbox cannot damage the host system (e.g. delete or overwrite something unintended), but also, to a lesser extent, to hide most of the filesystem to avoid exfiltrating sensitive data.

Recently, Bartosz Taudul (of Tracy fame) showed how to use systemd-nspawn for this purpose. He creates a container configuration, installs a distro inside, and bind-mounts some cache and project folders from the host. The mounts have an overlayfs on top, so within the container, tools can write over the files, but those writes do not affect the host filesystem.

I also want to share my sandboxing approach. My goal was to make it easy to use and reduce friction as much as possible, so that I always have a sandbox at my fingertips.

The result boils down to spawning a container-like environment, sharing enough of the host filesystem read-only to make all host binaries runnable, and sharing the current working directory read-write. Within this sandbox, you don’t need to install a separate distro—everything from your host just works, while the filesystem is kept mostly isolated (except for the folder where you run the sandbox).

For example, I’ll run the script in a Tracy checkout.

┌ ((8c8d451a)) ~/s/c/tracy
└─ box fish
Welcome to fish, the friendly interactive shell
Type help for instructions on how to use fish
yalter@sandbox ~/s/c/tracy>

I can run the build since all my host binaries are accessible:

yalter@sandbox ~/s/c/tracy> meson setup build
The Meson build system
Version: 1.11.2
Source dir: /home/yalter/source/cpp/tracy
Build dir: /home/yalter/source/cpp/tracy/build
Build type: native build
Project name: tracy
Project version: 0.13.1
C++ compiler for the host machine: /usr/bin/ccache c++ (clang 22.1.8 "clang version 22.1.8 (AerynOS)")
C++ linker for the host machine: c++ ld.lld 22.1.8
Host machine cpu family: x86_64
Host machine cpu: x86_64
Checking if define "_MSC_VER" exists: NO
Run-time dependency threads found: YES
Found pkg-config: YES (/usr/bin/pkg-config) 2.5.1
Build targets in project: 1

Found ninja-1.13.2 at /usr/bin/ninja
yalter@sandbox ~/s/c/tracy> ninja -C build
ninja: Entering directory `build'
[2/2] Linking target libtracy.so

The home folder contains the working directory, and is otherwise mostly empty:

yalter@sandbox ~/s/c/tracy> ls -l ~
total 0
drwx------ 4 1000 1000 80 Aug  9 20:20 source/

I can write into the home folder, but the write will go into a tmpfs, and will not affect the host system:

yalter@sandbox ~/s/c/tracy> touch ~/evil
yalter@sandbox ~/s/c/tracy> ^D
┌ ((8c8d451a)) ~/s/c/tracy
└─ cat ~/evil
cat: /home/yalter/evil: No such file or directory

Only changes to the Tracy folder, where I ran the sandbox, persisted on the host, all with correct user ID and everything:

┌ ((8c8d451a)) ~/s/c/tracy
└─ ls -l build/
total 28K
drwxr-xr-x 1 yalter yalter   48 Aug  9 20:21 libtracy.so.p
drwxr-xr-x 1 yalter yalter  496 Aug  9 20:21 meson-info
drwxr-xr-x 1 yalter yalter   56 Aug  9 20:21 meson-logs
drwxr-xr-x 1 yalter yalter  310 Aug  9 20:21 meson-private
drwxr-xr-x 1 yalter yalter   40 Aug  9 20:21 meson-uninstalled
-rw-r--r-- 1 yalter yalter 5,3K Aug  9 20:21 build.ninja
-rw-r--r-- 1 yalter yalter  545 Aug  9 20:21 compile_commands.json
-rwxr-xr-x 1 yalter yalter  14K Aug  9 20:21 libtracy.so

The box script #

I use Bubblewrap to spawn the sandbox. This is an unprivileged sandboxing tool used by Flatpak (though, I hear there are plans to replace it with something else).

The script itself composes a long bwrap invocation. Let’s look at some of the parts.

#!/usr/bin/env bash
set -euo pipefail

# Export ALLOW_NET=0 to disable network access inside the sandbox.
#
# Keep in mind that if your X11/Xwayland doesn't check Xauth,
# then network access lets the sandbox connect to your X11
# via an abstract Unix socket. This is quite dangerous.
ALLOW_NET="${ALLOW_NET:-1}"

# The current folder that we're binding read-write.
REPO="$(readlink -f .)"

BWRAP=( bwrap
  --die-with-parent
  # Unshare (isolate) a bunch of things inside the sandbox.
  --unshare-pid
  --unshare-uts
  --unshare-cgroup-try
  --unshare-user-try
  --cap-drop ALL
  # Create/mount important folders.
  --proc /proc
  --dev /dev
  --tmpfs /tmp
  --tmpfs /var
  --dir /run
  --dir /etc
  --hostname sandbox

  # Warning: this script shares all environment variables.
  # If on your system the environment can contain secrets,
  # you may want to clear them:
  # --clearenv

  # Bind the current folder read-write and chdir there.
  --bind "$REPO" "$REPO"
  --chdir "$REPO"
)

# --- Read-only system binds ---
SYS_RO_BINDS=(
  # Folders with binaries and libraries.
  /usr
  /bin
  /sbin
  /lib
  /lib64
  # Random configuration files that programs tend to need.
  /etc/alternatives
  /etc/nsswitch.conf
  /etc/hosts
  /etc/localtime
  /etc/timezone
  /etc/pki
  /etc/ca-certificates
  /etc/ssl
  /etc/crypto-policies
  /etc/fonts
  # I fill these as I bump into problems, more or less.
  /etc/java
  /etc/texlive
  /var/lib/texmf
  /usr/lib/jvm
  /usr/share/java
)
# Bind all of them read-only.
for p in "${SYS_RO_BINDS[@]}"; do
  [[ -e "$p" ]] && BWRAP+=( --ro-bind "$p" "$p" )
done

BWRAP+=( --ro-bind-try /etc/ld.so.cache /etc/ld.so.cache )

# resolv.conf is fun because it's a symlink into /run,
# a folder which we do not want to expose.
RESOLV_REAL="$(readlink -f /etc/resolv.conf 2>/dev/null || true)"
if [[ -n "$RESOLV_REAL" && -f "$RESOLV_REAL" ]]; then
  BWRAP+=( --ro-bind "$RESOLV_REAL" /etc/resolv.conf )
fi

# Unshare the network if needed.
if [[ "$ALLOW_NET" -eq 0 ]]; then
  BWRAP+=( --unshare-net )
fi

# Create a fresh home directory.
# The username and the path is the same as on the host
# so that everything keeps working.
BWRAP+=( --setenv HOME "$HOME"
         --dir "$HOME" )

# --- Home read-only binds ---
HOME_RO_BINDS=(
  .cargo/bin
  .cargo/config.toml
  .local/bin
  .local/lib/node_modules
  .rustup
  .fonts
  .local/share/fonts
  .local/share/nvim/site/parser
  .gitconfig
  .config/git
  .config/tmux
  .cache/ms-playwright
  .cache/corepack
)
for rel in "${HOME_RO_BINDS[@]}"; do
  [[ -e "$HOME/$rel" ]] && BWRAP+=( --ro-bind "$HOME/$rel" "$HOME/$rel" )
done

# --- Home overlays ---
# The sandbox can write here, but the changes
# will not affect the host filesystem.
HOME_TMP_OVERLAYS=(
  .cache/fontconfig
  .cargo/registry
  .cargo/git
  .gradle
  .npm
  .cache/npm
  .local/share/pnpm/store
  .cache/yarn
  .cache/cpm
  .texlive2023
)
for rel in "${HOME_TMP_OVERLAYS[@]}"; do
  [[ -d "$HOME/$rel" ]] && BWRAP+=( --overlay-src "$HOME/$rel" --tmp-overlay "$HOME/$rel" )
done

# Set up $PATH with the paths that we have inside this sandbox.
BWRAP+=( --setenv PATH "$HOME/.cargo/bin:$HOME/.local/bin:/usr/local/bin:/usr/bin:/bin" )

# Execute our big commandline and pass it
# the rest of the arguments (the command to run).
CMD=( "${@:-bash}" )
exec "${BWRAP[@]}" "${CMD[@]}"

Many lines, but most of them are just listing directories to mount.

If you want to run GUI apps in the sandbox, you’ll need to create an XDG_RUNTIME_DIR and mount a Wayland socket:

# Export PASS_WAYLAND=1 to enable Wayland access.
# Warning: it is currently NOT SANDBOXED (e.g. with security-context protocol).
# See https://niri-wm.github.io/niri/Security-Model.html#unsandboxed-clients
# for an example of what that implies.
PASS_WAYLAND="${PASS_WAYLAND:-0}"

# Export PASS_DRI=1 to enable DRI (GPU) access for hardware acceleration.
PASS_DRI="${PASS_DRI:-0}"

# Export PASS_X11=1 to enable X11 (Xwayland) access.
PASS_X11="${PASS_X11:-0}"

if [[ "$PASS_DRI" -eq 1 && -d /dev/dri ]]; then
  BWRAP+=( --dev-bind /dev/dri /dev/dri )
fi

# EGL complains without this.
BWRAP+=( --ro-bind /sys /sys )

# Wayland: bind only the socket into a fresh runtime dir.
XDG_RT="${XDG_RUNTIME_DIR:-}"
WAYLAND_SOCK="${WAYLAND_DISPLAY:-wayland-0}"
if [[ "$PASS_WAYLAND" -eq 1 && -n "$XDG_RT" && -S "$XDG_RT/$WAYLAND_SOCK" ]]; then
  BWRAP+=( --dir /run/user
           --dir /run/user/1000-sbox
           --bind "$XDG_RT/$WAYLAND_SOCK" "/run/user/1000-sbox/$WAYLAND_SOCK"
           --setenv XDG_RUNTIME_DIR /run/user/1000-sbox
           --setenv WAYLAND_DISPLAY "$WAYLAND_SOCK" )
else
  BWRAP+=( --unsetenv WAYLAND_DISPLAY )
fi

# X11.
DISPLAY_VAR="${DISPLAY:-}"
if [[ "$PASS_X11" -eq 1 && -n "$DISPLAY_VAR" && -d /tmp/.X11-unix ]]; then
  BWRAP+=( --ro-bind /tmp/.X11-unix /tmp/.X11-unix
           --setenv DISPLAY "$DISPLAY_VAR" )
else
  # Make it harder for accidental X11: unset DISPLAY.
  BWRAP+=( --unsetenv DISPLAY )
fi

That’s about it for the script. If needed, it’s easy to mount more folders by adding them into one of the arrays. The script doesn’t require elevated privileges to run.

Just remember that the folder where you run it is mounted read-write with the sandbox. When I want to run a dangerous command without affecting the files in the repository I’m working on, I just make a temporary copy:

project > cd ..
> git clone project project2
> cd project2
project2 > box fish
project2@sandbox > ...some dangerous command...
...
project2@sandbox > ^D
project2 > cd ..
> rm -rf project2

Another trick I recently did: I created a read-only GitHub personal access token, and automatically put it into $GH_TOKEN in the sandbox. This way, commands like gh pr list work in the sandbox without having any write access.

Conclusion #

This is very much not a polished tool, but rather a script I’ve been adding on to here and there for several months. I wanted to share it because I think it’s fairly generic (works on both Fedora and AerynOS at least), and avoids a number of pain points with other sandboxing approaches:

• no extra setup required, just one command
• no separate distro installation, uses the host system binaries and libraries directly. As a corollary, anything you build inside this sandbox will work on the host
• no manual folder binding, passes through the current folder
• paths and UID match the host, no broken file permissions
• no sudo needed

One limitation is that I haven’t been able to make podman run inside this sandbox yet. I tried once briefly, but kept hitting weird errors. Maybe it needs some capabilities exposed; not sure.

This is also obviously not intended as a bulletproof sandbox for running fully untrusted code, in fact I wouldn’t be too surprised if I left some gaping holes by mistake (please let me know if I did).

Update on what happened across the GNOME project in the week from July 31 to August 7.

GNOME Core Apps and Libraries

File Previewer ↗

A previewer companion for GNOME Files.

Peter Eisenmann announces

Since its “revival”, sushi, the previewer companion for nautilus, has seen a lot of activity. This wouldn’t have been possible without the contributions and support of Tau Gärtli, who very recently also became a maintainer 🎉

Additional changes for version 51 since the last report:

• Revamped plugin API to easily expand sushi’s capabilities
• Smoother transitions between files, especially noticable for images
• Protected HTML previews with optional web content loading
• Simplified headerbar layout
• Reduced memory usage with fixed memory leaks
• Many additional bug fixes and added little niceties

You can test these changes in GNOME OS or by installing sushi and nautilus from the gnome-nightly Flatpak repository.

Peter’s work is funded by the GNOME Fellowship program. You can support the fellowship program via a donation.

Document Viewer (Papers) ↗

View, search or annotate documents in many different formats.

Lucas Baudin announces

With Papers 51.beta, it is now possible to add visual signatures to PDF documents! This was part of Malika’s internship, read more about it here.

GNOME Development Tools

Felipe Borges announces

A new implementation of GNOME Boxes (beta) is now available for general testing. It has been reworked from the ground up and has a bunch of new features in the works. You can find more about it on Felipe’s “Future of Boxes” blog post.

GNOME Fellowship

Sophie (she/her) reports

I have completed my first month of my GNOME Fellowship. You can read my full report for July 2026 on my blog.

Sovereign Tech Fellowship

Philipp Sauberzweig announces

I’ve started a blog about my design work in GNOME. Check out the introductory post, and follow the blog for regular updates on my activities during the Sovereign Tech Fellowship.

Third Party Projects

seja-arctic-fox says

Hello! This week, I released a new version of VidCom, a simple app for archiving and compressing videos.

Changes in version 0.83 include:

• Prevent logout/suspend while encoding
• Page for results reflects the encoding status better
• You can now select multiple videos in the queue by holding the Shift key
• ‘Select all’ button is no longer a toggle and can also deselect videos
• Added support for AVC (H264) encoding
• You can now open videos with VidCom. It will automatically import them into the queue upon doing so
• Custom default options can be set, such as the target size, export folder, all the exposed codec parameters and more
• bugfixes and improvements

Vidcom is currently available on Flathub and AUR. Detailed release notes can be seen here

Alexander Vanhee reports

Bazaar got its 0.9.2 update, mostly improving what happens when you’re not actively using the app. Instead of keeping the full app running, Bazaar now uses a lightweight background daemon process to handle the GNOME Shell search provider and the brand new auto-update system. This reduces the background memory footprint by at least 10 times!

Please donate to Kolunmi if you like these changes.

Ronnie Nissan reports

Hello. This week I updated two of my apps, Sitra to v0.1.3 and Embellish to v1.1.0.

Sitra:

• Installed fonts are now sorted first and have a badge indicating they are installed.
• Added Turkish translations thanks to episutv

Embellish:

Updated to NerdFonts v3.5.0, and as a consequence:

• Added two new fonts: Annotation Mono and Google Sans Code
• New icons like Obsidian and Zsh.

For now, you will have to reinstall all your fonts (expect custom fonts) to update them to the latest version, will think of a better mechanism for the next release.

Concessio is also being rewritten in Vala, making the code very clean and easier to add features and the app very fast.

See some other week hopefully 🤞

Tanay Bhomia reports

Whisp v1.4.0 - OCR Text Extraction and French Translation

Whisp is a frictionless, gesture-driven note-taking application designed natively for the GNOME desktop. It eliminates file management and save buttons entirely, acting as a rapid-capture scratchpad for passing thoughts, code snippets, and daily tasks.

This week, Whisp released version 1.4.0, introducing a powerful new feature called “Smart Paste”. By copying an image or taking a screenshot of unselectable text—like a paused video tutorial or a system dialog—and pasting it into Whisp, the app instantly extracts the embedded text. The on-device OCR engine not only grabs the words, but mathematically reconstructs the original indentation and paragraph spacing. The release also includes official French localization and several keyboard workflow refinements.

This update is perfect for developers, students, and researchers who frequently need to digitize structured text from YouTube videos, scanned PDFs, or locked interfaces without ever breaking their keyboard workflow.

github - https://github.com/tanaybhomia/Whisp website - https://tanaybhomia.github.io/Whisp/ donate - https://tanaybhomia.github.io/Whisp/donate.html

Shell Extensions

Disk_MTH reports

I’ve released Tailscale for GNOME 1.0.1, a Shell extension that brings the Tailscale VPN into the Quick Settings menu: connect and switch accounts, pick an exit node (with a panel warning when the node you picked stops routing), send and receive files over Taildrop, and publish local services with Funnel. It stays close to the platform: the file picker is the XDG portal, revealing a received file goes through org.freedesktop.FileManager1, and there’s a “Send with Taildrop” entry in the Nautilus right-click menu. With no tailscale installed it goes inert instead of breaking, and it comes back on its own once the package is there, with no reload. Available on extensions.gnome.org for GNOME Shell 49 and 50, in English, French, German and Italian. Source

Cleo Menezes Jr. says

A new version of Static Workspace Background extension is out, and now it’s even smoother. Fast switches between workspaces get a nice little bounce.

Get it on EGO: https://extensions.gnome.org/extension/8505/static-workspace-background

Events

Brage Fuglseth says

The talks from GUADEC 2026 are now available as individual clips on YouTube. Feel free to engage with the videos and share them with anyone who may find them interesting.

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!

On July 1st, the very first round of GNOME Fellowships started. This program finances contributors within the GNOME project through your donations. We, the fellows, will be giving you monthly updates about our work. This is the very first update from me.

Short Introduction

Hey, I’m Sophie. I have been working with GNOME technology for eight years. While I’m a physicist by trade, I have been programming for more than 20 years. You might have used apps like Pika Backup, Image Viewer, or Key Rack, which I developed, or used websites like apps.gnome.org or welcome.gnome.org that I created.

Among my goals for this fellowship are to get the image library glycin into the state that we can deprecate its predecessor gdk-pixbuf, establish new governance structures like an RFC process in the GNOME project, and explore better integration of Rust in the GNOME ecosystem.

Glycin

Glycin has already seen relatively fast adoption. One of the major reasons is that media processing code written in C is a major attack surface. In this year alone, five security issues have been reportedagainst the gdk-pixbuf project. In the future, glycin-exclusive features like higher color-depth support, proper color space management, and HDR support will become even more relevant.

Gdk-pixbuf has switched to using glycin as the default backend on Linux for a while. This way, the attack surface is already largely reduced. However, not all distributions have adopted the option yet, and on other platforms like Windows and macOS libglycin hasn’t been available to begin with.

One feature missing from glycin that is supported by gdk-pixbuf has been support for reading and writing pixel densities from images. This feature is now available for JPEG, PNG, and TIFF images. I have also created a merge request to support this feature in gdk-pixbuf via the glycin backend.

I already added basic support for macOS and Windows, as well as other operating systems, to glycin before the beginning of the fellowship. To address a few remaining build issues on Windows and macOS for libglycin, I explored fixing them by switching the complete build process from cargo to meson. However, it turns out that the meson main branch is still lacking features to make this work. Instead, I landed a patch by Felix to work around the issues. There are still some issues remaining on Windows with the GCC instead of the MSVC compiler. If someone has experience with that, fixes are very welcome.

Here is a quick list of all the smaller changes that have landed in glycin over the last month:

• • OpenEXR images that use half-precision floats now use the same memory format in glycin, saving half of the memory compared to the previously used single-precision floats.
  • Support for the Radiance HDR format has been added.
  • The lcms2 C-library has been dropped in favor of moxcms, which is written in safe Rust and improves the performance for images with ICC profiles noticeably.
  • Internally, there is now a mechanism for a loader to report if ICC profiles or CICP (HDR instructions) should be preferred, since this differs between image formats.
  • There is now an option to disable the glycin sandbox by setting the environment variable GLYCIN_DISABLE_SANDBOX=i-know-the-risks. There is now also a test_disable_sandbox meson option to disable the use of sandboxes when running tests for build servers that don’t support sandboxing.
  • Glycin’s seccomp filter now uses a blocklist instead of an allowlist. This simplifies the feature a lot and should be sufficient since the seccomp filters are only a second line of defense behind guards like namespaces. It should also fix an issue with 32-bit apps, like Steam, calling 64-bit loaders.
  • When creating new images, glycin now supports automatically converting the provided texture memory format to a format supported by the targeted image format. This feature can be controlled via Creator::set_transform_memory_format. As a result, glycin is now aware of the supported memory formats for all image formats. This information is now available via ImageEditorConfig::creator_memory_formats.
  • Metadata support has been extended by also loading XMP data for GIF, TIFF, and WebP images.
  • On request of the Inkscape project, a new API to disable the automatic conversion of textures to sRGB if an ICC profile is present has been added, along with a new API to fetch ICC profiles. This gives apps optional manual control over color management.

Image Viewer (Loupe)

The Image Viewer is showing some of the new information that is available via the new glycin features.

If pixel density metadata is available, it is shown in DPI, as well as the calculated physical size of the image. One example where this is particularly useful is scanned photos where the information is automatically added.

The used color profile, either ICC profile or CICP data, will also be shown.

RFC Proposal Draft

I have posted my first draft of a proposal for an RFC process within the GNOME project. Previously the document went through several iterations with the goal of striking a balance between making the decision process robust and avoiding stalls, while also not making it too complicated and bureaucratic. The initial discussion about the proposal is now taking place. For more information on why we are working towards better governance structures, I suggest reading Emmanuele’s original post.

Support the GNOME Project

The GNOME Fellowships are funded by our community. If you would like to help the GNOME project to stay sustainable, please consider donating.

C API and Introspection

I spent some time cleaning up the Rust C extension and the FFI layer to make it easier to consume from C and through GObject Introspection. One of the biggest changes was exposing the PitiviTimelineRuler instance type in the public headers instead of treating it as a generic GtkWidget. That gives GIR enough information to generate proper bindings automatically.

I also fixed an issue that only showed up in headless CI environments. The widget was previously relying on gtk::init() during type registration, which doesn't work well without a display server. Switching to set_initialized() solved the problem and made the test suite much more reliable.

Rendering Improvements

The rendering code also received a fairly large cleanup. Previously, the widget stored several pieces of drawing state separately, including adjustments, cached Pango layouts, and font descriptions. These have now been grouped into a single DrawingState struct protected by one RefCell.

Besides making the code easier to reason about, this reduces unnecessary borrow checks during rendering and avoids situations where only part of the drawing state could be updated while signals were being emitted.

I also introduced a labels_dirty flag so timeline labels are only recalculated when they're actually needed during the snapshot phase. That removes quite a bit of redundant layout work while scrolling and zooming.

Timeline Marker API

The custom layout manager is nearly finished, and with it comes a much simpler way to place widgets on the timeline.

I am currently wrapping up an add_marker() API that will allow attaching any GTK widget to the ruler at a specific timestamp. The PitiviTimelineLayoutChild now exposes the widget's timestamp as a GObject property.

I'm looking forward to getting this merged, as it should make timeline overlays and markers much easier to implement.

Stability Fixes

I also addressed a few smaller edge cases along the way. One of them involved enforcing a minimum value for min_tick_spacing_px, preventing potential divide-by-zero errors when calculating the tick spacing.

Week 28

This week's icon is for René Fouquet's project:
Stencil: "Rename batches of files"

Check out all weekly app icons created so far in the gallery and follow my icon creation adventures as they happen (including sketches) on the Fediverse.

Need icons?

I love designing icons and am happy to contribute them free of charge when your project is Free and Open Source. Funded by community sponsors (every little helps!).

Hey, I’m Philipp. I’m a GNOME Design Team member and I have been contributing to GNOME design as a volunteer for several years. I’m excited to share with you that I have joined the Sovereign Tech Agency as a fellow for GNOME Design & Community Management. Check out the other fellows in the official announcement.

Introduction

I originally started contributing to GNOME to improve the software I use myself. However, what motivates me to stay involved long-term are my political values. Our modern lives, from communication and education to political discourse, are shaped by digital tools, and I believe that it’s essential for a free and democratic society to ensure free and independent access to these technologies. To achieve this goal, end-user devices based on free and open-source software are key, and the GNOME desktop and its app ecosystem offer a powerful alternative to proprietary platforms.

In recent years, I have had the privilege of joining the exceptionally skilled and motivated GNOME community as a volunteer, and have experienced how rewarding it is to contribute to a project with such a broad societal impact. At the same time, it’s been a challenge to find a balance between my job, my contributions to GNOME, and my personal life. I’ve contributed to GNOME in my free time, in the evenings, and during vacations. This two-year fellowship is a great honor and marks a significant change in my life. It is a unique opportunity for me to devote my skills and experience entirely to a project I strongly believe in.

Activities

During my two-year fellowship, I will support GNOME maintainers and developers with design feedback and reviews, create mockups, and coordinate efforts to standardize design patterns. My other activities focus on lasting improvements through two strategic initiatives: expanding the design community to increase capacity and enhancing our design tooling to reduce overhead and simplify onboarding. The following activities may change over the course of the two-year fellowship, as I will adapt them to the needs of the community.

Community growth

I know from my own experience that it is hard to get started with GNOME design. While code contributions are often contained within the boundaries of a single app, design activities spread across multiple projects and often lack a clear entry point or primary contact. Also, not all tasks are newcomer friendly and many require cross‑project knowledge or historical context. I want to make design work more discoverable, simplify onboarding with clear contribution paths and approachable tasks, and retain contributors long term by integrating them into the community.

To attract new contributors, I will increase the visibility of design work by writing regular blog posts, giving presentations, and running workshops at conferences and hackathons. New contribution opportunities for newcomers will be created with clear instructions for independent activities such as collecting state‑of‑the‑art examples, running accessibility and user tests, and creating mockups. Design reviews will be used as mentorship opportunities, pairing regular design contributors with experienced designers for peer review and knowledge sharing. I plan to improve our team governance with clear membership criteria and focus areas, and integrate sustained contributors into the team and its processes. Finally, I want to provide grant writing support to enable contributors to sustain their contributions long-term.

Tooling improvements

User interface mockups are an important tool to communicate with developers. Outdated mockup templates, incomplete documentation, and non‑specialized software create unnecessary overhead, especially for newcomers. Therefore, I will extend and update the mockup templates for our current tool, Inkscape, and evaluate the open‑source UX design tool Penpot for managing our design system. If it proves suitable, I will build a component library to simplify mockup creation and keep assets synced with our stylesheet.

What’s next

I want to blog about my fellowship activities and design work in general, so expect regular updates here. If you’re interested in contributing to GNOME design, check out the Design Team page on the Welcome to GNOME website, familiarize yourself with the Human Interface Guidelines, and join our Matrix channel. If you’re a GNOME developer feel free to reach out to me via Matrix and involve me in design reviews.

Week 27

This week's icon is for Zach Leytus's project:
KawaiiFi: "Wi-Fi scanner and analyzer"

Check out all weekly app icons created so far in the gallery and follow my icon creation adventures as they happen (including sketches) on the Fediverse.

Need icons?

I love designing icons and am happy to contribute them free of charge when your project is Free and Open Source. Funded by community sponsors (every little helps!).

Week 26

This week's icon is for Sjoerd Stendahl's project:
Lockpicker: "Recover passwords from their hash"

Check out all weekly app icons created so far in the gallery and follow my icon creation adventures as they happen (including sketches) on the Fediverse.

Need icons?

I love designing icons and am happy to contribute them free of charge when your project is Free and Open Source. Funded by community sponsors (every little helps!).

I’m pleased to announce that NVIDIA is now supporting the LVFS as a premier sponsor.

The rollout of the NVIDIA DGX Spark firmware using fwupd is going very well indeed, with downloads continuing to increase every day.

This now takes us to 4 OEMs sponsoring LVFS, which means we’ve successfully reached the funding target we set for ourselves last year. More exciting announcements coming soon!

I have spent the last two years rebuilding GNOME Boxes from the ground up, driven by three main factors. I spoke extensively about this effort in my recent Linux App Summit, GUADEC 2025 and 2026 talks, but today I am excited to share the result for general testing.

First, shifting to a Flatpak-first (and only) model. As a solo developer, maintaining code paths for countless distributions isn’t sustainable. Since Boxes acts as a frontend for libvirt/qemu, its functionality relies heavily on the backend configuration. Flatpak lets me bundle the entire virtualization stack, giving me the control I need to fine-tune it for our specific use cases.

Second, migrating Boxes to GTK4 and Libadwaita. Beyond the obvious benefits (a modern UI, better responsiveness, and tighter desktop integration) this makes the codebase significantly easier to maintain. This transition required moving away from the GTK3-based SPICE display widget, which was too tightly coupled to older input and drawing methods. We’ve replaced it with Libmks, which has proven to be a solid alternative.

Lastly, modernizing the codebase to make it sustainable for new contributors. That meant adopting modern GNOME app design patterns and rethinking our underlying architecture.

I am now ready to share this work with a wider audience. However, please keep in mind that this is a Beta release meant for testing, not for production environments. If you plan to try it out, make sure to back up any important data in your virtual machines first.

If you want to test this new implementation of GNOME Boxes, you can set up the GNOME Nightly Flatpak Repository and install it with:

flatpak install org.gnome.Boxes.Devel

This new version already covers most of what the classic Boxes could do: creating virtual machines from ISO media and disk images (qcow2), configuring VM resources, sharing clipboard content, sending files to the guest, and more.

It can install Windows 11 without any manual workarounds. Boxes configures Secure Boot and a virtual TPM device automatically. Everything required to pass the Windows 11 hardware compatibility checks out of the box. This was the most requested feature for the classic version, so I am particularly glad it is fully functional in this rewrite.

As distributions shift toward image-based OSes, this Flatpak-only approach becomes even more valuable. Most other virtual machine managers rely on host services or privileged daemons that are difficult to configure on immutable systems. While hardware and host combinations vary, bundling the backend stack directly inside the Flatpak gives us a controlled baseline that we can actively support, configure, and refine over time.

Accessing VM contents used to be tricky due to Flatpak sandboxing. This version addresses that by introducing a VSOCK device to the box, allowing guests with systemd v256 or newer to be accessed directly over SSH. It also adds initial support for port forwarding, letting you reach services running inside the VM from your host.

All of this and more is detailed on our new website, nightly.gnomeboxes.org, where you can also learn how to help by testing and reporting issues.

Please keep in mind that I am working on this in my free time alongside maintaining GNOME Settings and my day-job responsibilities at Red Hat. I ask for your patience with issue responses, but I will do my best to address bugs and keep pushing feature development forward as time allows.

I love building GNOME Boxes, and I am constantly motivated by the positive feedback from our community. People appreciate Boxes because it lets them set up a VM quickly and get straight to work without needing deep knowledge of virtualization or operating system internals. That remains the core mission, and that is the user experience I want to continue building for.

A lot of this implementation will still change as I gather feedback and it matures. I have also drafted a series of follow-up blog posts to this one, which will describe and elaborate a bit more on the new features, explaining how to use them and how they have been implemented. Stay tuned!

Comments