gosub-engine: Open Source Browsers & Extensions

What is gosub-engine?

Gosub is an embeddable, asynchronous browser engine written in Rust, aimed at developers who want to build browsing capability into their own application by supplying a render backend and compositor rather than embedding a full browser.

What it is

Gosub is a modular, embeddable browser engine whose primary entry point is GosubEngine in the gosub_engine crate. An embedder supplies a render backend and a compositor, and the engine owns the multi-zone and multi-tab model, an asynchronous networking stack, cookie and storage isolation per zone, and an event bus; the user-agent layer drives it with TabCommand and reacts to EngineEvent. The project is split across a workspace of crates, including gosub_html5 and gosub_css3 for the HTML5 and CSS3 tokenizers and parsers, gosub-sonar for the external networking stack, gosub_lattice for CSS table layout, gosub_render_pipeline for layout, tiling and compositing, gosub_fontmanager for text shaping, and gosub_jsapi and gosub_v8 for Web APIs and V8 bindings.

It solves the problem of standing up a browser core inside a Rust application without wiring a tokenizer, CSS parser, networking layer, resource fetcher, storage isolation and rendering path together by hand. Rather than assembling those parts from separate libraries, an embedder adopts one engine that coordinates parsing, layout, paint and per-zone isolation, then decides how to present the result. It lives in the Rust ecosystem and targets hosts needing a browser core they can embed, control and observe through a defined API.

Key capabilities

Multi-zone and multi-tab model, with cookies and storage isolated per zone and tabs controlled through TabCommand.
Asynchronous networking via the external gosub-sonar crate, offering a streaming HTTP fetcher, priority queues, inflight coalescing, redirect handling and per-zone cookie isolation.
Event-driven user-agent interface, where navigation, resource and redraw signals leave as EngineEvent and input arrives as TabCommand and EngineCommand.
HTML5 and CSS3 parsing through spec-compliant parsers, including shadow DOM parsing, flat-tree traversal and CSS scoping.
Resource pipeline driven by parser sub-resource discovery, fetching stylesheets, images, web fonts and data URLs through one fetcher with hierarchical cancellation.
Layout and paint covering block, inline, flex and grid via Taffy, floats, absolute and fixed positioning, and CSS tables through gosub_lattice, plus form controls with colour, date and time pickers opened via EngineEvent::PickerRequested.
Pluggable render backends — Null for headless use, Cairo for GTK4, Skia for CPU and GPU, and Vello on wgpu — with conformance measured by a gated web-platform-tests run and a reftest runner.

Who uses it and how

Rust developers embedding a browser core into a larger application, supplying a render backend and compositor while the engine handles zones, tabs, networking and storage isolation.
Teams rendering real pages without a window, using the Null backend and the headless workflow in docs/headless.md.
GUI builders using the examples for winit, GTK4 and egui described in docs/examples.md.
Projects compiling and running the engine in the browser under WebAssembly, as covered in docs/webassembly.md.
Conformance-focused teams relying on the gated web-platform-tests run and reftest runner, with numbers tracked in docs/wpt.md.

Getting started

The engine is consumed as the gosub_engine crate and built from the source workspace rather than installed as a standalone binary. The tutorial at docs/tutorial.md covers starting the engine, opening a tab, navigating and handling events, and docs/configuration.md covers choosing a render backend and font system.

How it compares

No comparable browser engine is named in the facts for this registry, so Gosub stands alone here. No paid products are listed for contrast, so there is no licence, hosting or cost comparison to draw.

When to use it — and when not

The engine is under active development, and the clearest limitation is that scripting is not wired in: the V8 and Web API crates build, but no page runs JavaScript, and the DOM is driven during tests only through a separate QuickJS binding, gosub_domjs. Embedders must supply their own render backend, compositor and user-agent layer, so it suits teams willing to build around an engine core rather than those wanting a finished, JavaScript-capable browser. Detailed per-component status, including what does not yet work, is tracked in docs/status.md.

project readme (upstream, from github) — read inline

Gosub Browser Engine

An embeddable, async browser engine written in Rust.

Join us on our development Zulip chat, or our Discord server for general chat. If you'd like to contribute, start with the contribution guide.

About

Gosub is a modular, embeddable browser engine. The primary entry point is GosubEngine in the gosub_engine crate. You provide a render backend and a compositor; the engine owns a multi-zone/tab model, an async networking stack, cookie and storage isolation per zone, and an event bus. Your user-agent (UA) drives everything via TabCommand and reacts to EngineEvent.

Core components:

Crate	Role
`gosub_engine`	`GosubEngine` — the unified entry point
`gosub_interface`	Shared traits wiring the components together (the config system)
`gosub_html5`	HTML5 tokenizer / parser
`gosub_css3`	CSS3 tokenizer / parser
`gosub-sonar`	Networking stack (async, streaming, priority-scheduled) — external crate
`gosub_lattice`	CSS table layout
`gosub_render_pipeline`	Render pipeline — layout (Taffy), stages, tiling, compositor
`gosub_renderer_cairo`	Cairo render backend (CPU)
`gosub_renderer_skia`	Skia render backend (CPU / GPU)
`gosub_renderer_vello`	Vello / wgpu render backend (GPU)
`gosub_fontmanager`	Font system — text shaping and measurement
`gosub_jsapi`	Browser Web API implementations (console, fetch, DOM, …)
`gosub_v8`	V8 JavaScript engine bindings
`gosub_config`	Configuration store

For the full crate listing see docs/crates.md.

Status

The engine is under active development. What works today:

Multi-zone / multi-tab model — zones isolate cookies and storage; tabs are controlled via TabCommand
Async networking — streaming HTTP fetcher with priority queues, inflight coalescing, redirect handling, and per-zone cookie isolation
Event-driven UA interface — EngineEvent (navigation, resource, redraw) flows out; TabCommand / EngineCommand flow in
HTML5 and CSS3 parsing — spec-compliant parsers for both, including shadow DOM (parsing, flat-tree traversal, CSS scoping)
Resource pipeline — parser-driven sub-resource discovery; stylesheets, images, web fonts and data URLs all fetched through one fetcher, with hierarchical cancellation
Layout and paint — block, inline, flex and grid via Taffy, floats, absolute and fixed positioning, and CSS tables via gosub_lattice
Form controls — text editing, and colour / date / time pickers opened by the embedder through EngineEvent::PickerRequested
Pluggable render backends — Null (headless), Cairo (GTK4), Skia (CPU / GPU), Vello (wgpu)
Conformance measurement — a gated web-platform-tests run in CI, plus a reftest runner; see docs/wpt.md for where the numbers stand

docs/status.md is the detailed version of this list — per component, what works and what does not, with the numbers.

Not there yet: scripting is not wired into the engine. The V8 and web-API crates exist and build, but no page runs JavaScript — see docs/javascript.md. WPT drives the DOM through a separate test-only QuickJS binding (gosub_domjs).

Documentation

docs/README.md indexes every page under /docs. The pages below are the ones worth reading first.

Getting started

Tutorial — start the engine, open a tab, navigate, handle events
Configuration — choosing a render backend and font system
Running the examples — headless, GUI (winit / GTK4 / egui), and component tools
Headless usage — rendering real pages without a window
WebAssembly — compile and run the engine in the browser
Development — tests and benchmarks

Reference

What the engine can do today — per-component capability and gaps
Crates — the workspace crate layout, and where to find anything
Component tools — the standalone cargo run --bin … tools

Architecture

The two worlds — the two parallel document/style models and the seam that joins them. Read this before diving into either.
Interface trait families — ModuleConfiguration and the Has* traits that wire the workspace together
Module configuration — the same picture from an embedder's side: what DefaultRenderConfig wires for you and how to go fully custom
Zones and tabs — zones as isolated profiles, tabs as independent worker tasks, and the command/event flow between them
Resource pipelines — how fetched bytes become typed assets
CSS internals — gosub_css3 from text to computed value
HTML5 parsing — tokenizer, tree builder, arena DOM
Render pipeline
Lattice table layout · Fonts · JavaScript stack
Networking — architecture and design notes
Cookies
Storage (local / session)
Pump — moving HTTP stream data to targets

Conformance

WPT quickstart — clone to a fixed test in about ten minutes. The fastest way to make a first contribution.
Web-platform-tests — the harness in full: what is bound, the expectations format, the reftest runner, and what CI does

Contributing

We welcome contributions. Because the engine is still taking shape, a lot of work is exploratory — building proofs-of-concept, reading specs, and making architectural decisions — rather than pure coding.

Join us on Zulip or Discord before diving in; it will save you time and help us keep things coordinated. See CONTRIBUTING.md for the details.

Frequently asked questions

Is gosub-engine free to use?

gosub-engine is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does gosub-engine do?

The Gosub browser engine

What is gosub-engine written in?

gosub-engine is primarily written in Rust. Its source is publicly available at https://github.com/gosub-io/gosub-engine, and it has 3,685 GitHub stars.