BlinkGTK 1.2.5-build2 Release Notes

Release date: 2026-10-27 / Chromium: 156.0.8078.47 / Language: 日本語 | English

The rendering engine is updated to Chromium 156. BlinkGTK can now be used from Python (PyGObject).

Upgrading from an earlier version

Check the rows that match how you use BlinkGTK. Each row links to the details.

If you upgrade from 1.2.5-build1, check the "Apps that use a dark GTK theme" row (the change in build2). The other rows are for upgrades from 1.2.4.

This table is for Linux. For BlinkGTK for Windows, see Upgrading from an earlier version in the Windows guide.

How you use it	What changes	What to do
From Python (PyGObject)	It starts (up to 1.2.4 it could not start)	Run it as `blinkgtk-run python3 app.py` and use the new initialization and main loop (details)
Receiving `load-failed` from Python or other bindings	The handler is called; the error code arrives as an int	Nothing (details)
Shipping BlinkGTK in your own form (not the RPM, DEB or tarball as is)	New files `blinkgtk-subprocess` and `blinkgtk-run` are needed	Ship both from `libexec/blinkgtk-0.1/`. If you put `blinkgtk-subprocess` elsewhere, set `BLINKGTK_SUBPROCESS_PATH`. `blinkgtk-run` looks for the allocator shim in `lib64/blinkgtk-0.1/chromium/` relative to itself (`lib/<multiarch>/blinkgtk-0.1/chromium/` for DEB); if you change the layout, set `BLINKGTK_SHIM` to the shim (details)
Using the introspection data (typelib) from Python and others	More APIs can be called (functions, methods and constructors: 93 → 148)	Just update the package (details)
Apps that use a dark GTK theme	From build2, the color scheme reported to pages (`prefers-color-scheme`) becomes dark (up to build1, it was always light). Pages that support dark (for example, pages that set `color-scheme`) get a dark background, form controls and scrollbars; pages that do not set `color-scheme` keep a white background. Switching the theme between light and dark while the app runs also switches the page	To keep pages always light, set `BLINKGTK_FOLLOW_GTK_THEME=0` (details)
Using `set_user_agent()`	Applied to pages opened with `load_uri()` and on `reload()` too (up to 1.2.4 only `load_html()`)	Nothing (details)
Using `set_zoom_level()` / `zoom-level`	The value is treated as a factor (1.0 = 100%); up to 1.2.4, 1.5 gave about 131% and 0.0 was returned at 100%	Review any compensation for the old behavior and any stored values (details)
Switching a loading indicator on `notify::is-loading`	A notification with `False` now arrives when loading ends	Nothing (details)
Pages with `text-decoration` over leading or trailing spaces	The line is drawn over the spaces too (as up to 1.2.3)	Nothing (details)
Pages that set `text-decoration-skip-spaces`	The property has no effect	Nothing (details)
Elements with `overflow: clip` on one axis and scrolling on the other	The `clip` axis does not scroll	Nothing (details)

BlinkGTK can now be used from Python

Up to 1.2.4, BlinkGTK could not start when used from Python. Chromium starts its child processes with "its own executable". A C application's executable can serve as the child process, but for a Python program the executable is python3, which cannot, so it aborted.
From 1.2.5, when BlinkGTK is used from a program that does not link it directly (such as Python), it starts the child processes with the bundled blinkgtk-subprocess. The RPM, DEB and tarball all install it at /usr/libexec/blinkgtk-0.1/blinkgtk-subprocess. The sandbox stays enabled.
- If you ship it in a different place, set its path in BLINKGTK_SUBPROCESS_PATH. Setting 0 restores the 1.2.4 behavior.
- C applications are unchanged: their own executable still serves as the child process.
Requirements: BlinkGTK 1.2.5 or later, a Wayland desktop, PyGObject (Fedora: python3-gobject / Debian, Ubuntu: python3-gi), and the GTK 4 and BlinkGTK introspection data (Fedora: gtk4 and blinkgtk-bin-gir / Debian, Ubuntu: gir1.2-gtk-4.0 and gir1.2-blinkgtk-0.1). Setup steps are in the Python tutorial.
Run Python programs through blinkgtk-run: blinkgtk-run python3 app.py. BlinkGTK (Chromium) needs its memory allocator to be loaded from the very start of the process. In Python, BlinkGTK is loaded later, so without blinkgtk-run the program aborts when it opens an HTTPS page (this did not happen with data URLs or local files). blinkgtk-run preloads the allocator with the LD_PRELOAD environment variable and then runs the given program. It is /usr/bin/blinkgtk-run in the RPM and DEB packages, and usr/bin/blinkgtk-run where you extracted the tarball.
Write Python programs this way. Initialize with BlinkGTK.gtk_init() and run with BlinkGTK.gtk_application_run() instead of app.run() (with app.run() the Chromium loop does not run and pages do not load). It returns when the last window is closed; call BlinkGTK.gtk_shutdown() after it.

import sys
import gi
gi.require_version('Gtk', '4.0')
gi.require_version('BlinkGTK', '0.1')
from gi.repository import BlinkGTK, Gtk

BlinkGTK.gtk_init(sys.argv[:1])

def on_activate(app):
    win = Gtk.ApplicationWindow(application=app, default_width=800, default_height=600)
    view = BlinkGTK.WebView.new()
    win.set_child(view)
    win.present()
    view.load_uri('https://example.com/')

app = Gtk.Application(application_id='org.example.Hello')
app.connect('activate', on_activate)
rc = BlinkGTK.gtk_application_run(app)
BlinkGTK.gtk_shutdown()
sys.exit(rc)

load-failed can now be received from Python and other bindings. Since 1.1.0 the signal's argument was registered as the enum BlinkLoadError, while the value actually passed was the Chromium net error code (-3 for an aborted load). Python could not convert it, so the handler was never called. From 1.2.5 it arrives as an int, as documented. C callers are unaffected.
The introspection data (typelib) used from Python and other languages is regenerated. The data shipped until now dated from 16 August 2026, and APIs missing from it could not be called from Python and other languages. The number of functions, methods and constructors went from 93 to 148.
The Python tutorials (getting started, events, settings) and the example programs are rewritten in this form.
What we checked: a minimal Python program run through blinkgtk-run loads an HTTPS page (https://example.com/) and a data URL, closes its window and exits normally (packaged layout, headless weston, sandbox enabled). The 20 complete programs in the tutorials were also run against the built library with the allocator preloaded the same way. Languages other than Python, such as GJS, have not been tried.

Japanese typesetting changes (Chromium 156)

Upstream moved text-decoration-skip-spaces back to experimental. In 1.2.4 (Chromium 155) it was enabled by default, so decorations such as underlines were not drawn over leading and trailing spaces (including full-width spaces). In 1.2.5 the line is drawn over those spaces again, as up to 1.2.3, and text-decoration-skip-spaces has no effect. This is based on reading the code; the rendering was not measured.
Emphasis marks are normally not placed on punctuation, but # % & @ and a few others are exceptions that do receive them; this exception list, enabled since Chromium 155, is now permanent. The behavior does not change.

New in Chromium 156

Features enabled by default that matter to page authors:

The CSS random() function: random values inside calculations.
The value pair for scroll-snap-type.
Elements that scroll on one axis only: with overflow: clip on one axis and scrolling (auto and so on) on the other, clip used to be replaced by hidden, making the element scroll on both axes. From 156 clip is kept and that axis does not scroll.
JavaScript import ... with { type: "text" }: loads a file's contents as a string.

Changed in build2

The page color scheme now follows the GTK theme. Up to build1, pages were always light even when GTK used a dark theme. From build2, the page's prefers-color-scheme, form controls and scrollbars match whether the GTK theme is light or dark. Switching between light and dark while the app runs switches the page without reloading it. To get the previous behavior (pages always light), set BLINKGTK_FOLLOW_GTK_THEME=0. The accent color and the selection color do not follow the GTK theme yet.
Faster startup. Four changes:
- Startup no longer waits for the helper process that starts child processes (BLINKGTK_DEFER_ZYGOTE=0 restores the old order)
- Fewer symbol lookups when the shared libraries are loaded (a linker setting; RPM packages also order the libraries to reduce lookups)
- On the software rendering path, the check of GPU devices that are not used is skipped (BLINKGTK_FAST_RENDER_NODE=0 restores it)
- When the window is created, only the Vulkan drivers for the GPUs on the machine are loaded (BLINKGTK_VK_DRIVER_SELECT=0 restores loading all of them)

Fixed in build1

The User-Agent set with set_user_agent() did not reach pages opened with load_uri() (it did with load_html()). It now also applies to pages reloaded with reload().
Zoom (set_zoom_level() / get_zoom_level() / zoom-level) is now treated as a factor (1.0 = 100%), as documented. Up to 1.2.4 the value was passed as Chromium's logarithmic level, so 1.5 gave about 131% and get_zoom_level() returned 0.0 at 100%.
The three items under "BlinkGTK can now be used from Python" (could not start, load-failed could not be received, outdated introspection data).
notify::is-loading never reported False when loading ended. It was notified only once, at onload (while still loading), so applications that switch a loading indicator on this property never stopped it. From 1.2.5 it is notified each time loading starts and ends. Both notifications also arrive for operations where load-changed does not emit STARTED (checked with back and reload) and for responses that do not emit FINISHED (an HTTP 204 opened with load_uri(); load-failed then delivers -3, aborted). Navigations that turn into downloads were not tried.