Starling

An independent web browser, built from scratch — no Chromium, Gecko, or WebKit. Written in .NET.

_{netclaw.dev is shown only as a rendering target; Starling Browser has no direct affiliation with Netclaw.}

Why?

The conventional wisdom is that a browser engine has to be C++ or Rust, built by a large team over many years. Ladybird has already proven the hardest part: that a genuinely independent engine is viable. Starling shares that from-scratch spirit but asks the next question — do you still need a systems language? Arc and Dia build their browsers in Swift, even on Windows, so the C++-or-Rust assumption is already weaker than it looks. Starling pushes further: a managed-first .NET engine, built in the open, independent of any browser vendor.

The longer-term motivation is a specific frustration — how slowly the standards process has delivered things like first-class WASM/WASI access to the DOM. The plan is to earn parity on real-world sites first, then use the managed architecture to make WASM a first-class citizen, hitting the DOM directly rather than as a guest behind a JS bridge. And part of it, honestly, is just wanting to find out whether it can be done.

Read about our approach

Project Status

Last updated: 2026-05-25

Area	Status
Overall
Code coverage
ECMAScript
Web Platform
DOM
HTML Parser
CSS
Layout
Paint
Networking
JavaScript
Web APIs / DOM bindings
GUI shell
Multi-process / sandbox
Security

Each area name links to its design doc. Each badge links to the tests that back the number. See browser-plan/13_MILESTONES.md for the roadmap and tasks/INDEX.md for the work-package queue.

Quickstart

You'll need:

• The .NET SDK 10.0.100 or newer.
• A Six Labors license key for the paint backend — a free community license takes a couple of minutes. See Six Labors license below.

Clone the repo with its submodules. Starling pulls in the regular expression engine from a sibling repository under lib/, so a plain git clone will leave that directory empty and the build will fail. Use --recurse-submodules:

git clone --recurse-submodules https://github.com/starling-browser/starling.git
cd starling

If you already cloned without that flag, fetch the submodules now:

git submodule update --init --recursive

After a git pull that moves a submodule pointer, run the same command again to sync the working tree.

Build and test.

dotnet restore
dotnet build
dotnet test

Launch the browser. aspire run brings up the full app — the Avalonia GUI shell plus the headless renderer, orchestrated by Aspire (the dashboard URL prints on stdout, typically http://localhost:18888). This is the desktop browser pictured above.

aspire run

Choosing engines / backends. Pass selection flags after aspire run --:

# Defaults are --starling (JS VM) and --imagesharp-gpu (WebGPU paint).
aspire run -- --jint --imagesharp     # Jint JS engine + CPU paint backend

Agent access. Starling exposes a loopback Model Context Protocol server for local agent harnesses. The repo .mcp.json registers the AppHost endpoint at http://127.0.0.1:3078/mcp. See docs/mcp.md.

Render a live site from the CLI. The headless renderer fetches and paints a real URL straight to a PNG:

# The built CLI binary is named `starling`.
dotnet run --project src/Starling.Headless -- render https://example.com -o example.png

This is exercised in CI, and real-world bundles render end-to-end (netclaw.dev, pictured above). You can also point it at a local fixture — bare filesystem paths auto-normalize to file://:

dotnet run --project src/Starling.Headless -- render testdata/hello.html -o out.png

The CLI's full shape is documented in browser-plan/02_PROJECT_SETUP.md.

Six Labors license

The engine paints via ImageSharp.Drawing 3 — pure-managed, no native graphics shim to build — which is commercially licensed by Six Labors. The repo does not ship a license key (sixlabors.lic is gitignored), so each contributor supplies their own. Applying for a community license is quick and easy: https://licensing.sixlabors.com/. Save the key as sixlabors.lic in the repository root and the build picks it up automatically (CI uses the SIXLABORS_LICENSE_KEY secret instead).

Working on Starling

Each subsystem has a focused doc in browser-plan/. For agent-facing work packages with explicit inputs / outputs / acceptance, see 14_AGENT_TASKS.md.

New here? Start with the design spec (browser-plan/00_INDEX.md), the engineering conventions in AGENTS.md, and the contribution rules in CONTRIBUTING.md. Bug reports, questions, and proposals are welcome via GitHub issues.

Implementation agents: start with AGENTS.md and the queue at tasks/INDEX.md. Multiple agents can work in parallel — claim an unblocked package via ./tasks/lib/claim.sh, commit directly to main with the wp id in the subject, leave a handoff-log entry on stop, and mark complete via ./tasks/lib/claim.sh complete <wp-id>. The full workflow is in tasks/README.md.

Benchmarks: how to run the suite and read the numbers is in bench/README.md. The latest overview lives in bench/benchmarks.md.

License

Starling source code is licensed under Apache-2.0 — Copyright 2026 Cody Mullins.

Third-party code, data, fonts, and fixtures may use different licenses. See THIRD_PARTY_NOTICES.md. The current paint path also requires a separate Six Labors license key to build. See Six Labors license.

The Starling name, logo, icons, and branding are not licensed with the source code. See TRADEMARKS.md.