Aetheris Browserexperimental · C++20
Status: experimental

An experimental C++ browser,
engineered and honest.

Aetheris Browser is an experimental C++ browser project built on a Ladybird/SerenityOS-derived codebase. Its own core is a dependency-free rendering foundation — HTML and CSS parsing, style resolution, layout, paint and software rasterization — validated by a CTest regression suite.

Get started View source Releases
Status: experimental Language: C++20 Build: CMake + vcpkg Tests: CTest Upstream: Ladybird/SerenityOS core: AetherisRendering CTest suite not production-ready
What's inside

Subsystems, not slogans

Every item below maps to code in the repository. The Aetheris-specific half lives in src/rendering/; the rest is upstream-derived Ladybird/SerenityOS infrastructure, kept with its original licences.

Dependency-free rendering core

The AetherisRendering static library is standalone C++20 with zero third-party dependencies, so it builds, tests and reasons independently of the upstream tree.

HTML & CSS pipeline

An HTML tokenizer and tree builder feeding a DOM/document, plus a CSS tokenizer and parser producing stylesheets — composed into a style-resolution and cascade pass.

Layout foundations

Block and inline layout with Flex and Grid foundations, positioning, sizing constraints, geometry, viewport handling and text layout.

Paint & software rasterization

A paint executor with clipping and visual state emits paint commands that are executed onto a software surface, covering backgrounds, images, fonts and paint ordering.

Tabs, sessions & chrome

BrowserSession covers navigation, history, scroll and hit-testing; BrowserChrome holds multi-tab address-bar state and back/forward capability.

Test-driven, honestly scoped

The Aetheris suite is 39 regression test executables wired into CTest. The project states plainly that it is not production-ready and avoids unsupported performance claims.

Minimal footprint by design

The core links nothing at runtime, and a size-first profile (-Os, dead-section elimination, LTO, stripped) keeps the shipped binary tiny — a stripped aetheris executable lands around 1 MB, with HTML/CSS layout, anti-aliased bitmap-font text, PNG/JPEG/GIF/SVG/WebP images, HTTPS/TLS, an HTTP client and a small JavaScript engine all linked in.

How it works

From source to smoke test

Aetheris uses CMake. The full tree pulls vcpkg dependencies; the Aetheris-specific targets build through a dependency-light standalone profile that skips the upstream tree.

1

Configure

Point CMake at the repository and a build directory. Reconfigure whenever CMake files or build-registered sources change.

2

Build

Compile in Debug for a development workflow. The Windows path uses MSVC or clang-cl; see the Windows build doc.

3

Test

Run the registered CTest suite. The Aetheris suite covers tokenizer, DOM, CSS, cascade, box model, layout, text, painting, resource, security and chrome behaviour.

4

Smoke-run

In the standalone profile, the aetheris executable initializes every subsystem, runs a bounded frame loop and exits zero. It can also fetch and render: aetheris --fetch <url> and aetheris --render <url>.

build & test — general 
# configure, build, test
cmake -S . -B build
cmake --build build --config Debug
ctest --test-dir build --output-on-failure

# Aetheris suite only
ctest --test-dir build -R Aetheris --output-on-failure
standalone profile — no third-party deps 
cmake -S . -B build-standalone -G Ninja -DCMAKE_BUILD_TYPE=Debug \
  -DAETHERIS_STANDALONE_BUILD=ON \
  -DAETHERIS_ENABLE_TESTING=ON -DBUILD_TESTING=ON
cmake --build build-standalone --parallel
ctest --test-dir build-standalone --output-on-failure --no-tests=error
# headless smoke run (X11 optional)
./build-standalone/bin/aetheris --smoke-test
named presets — debug & minimum size 
# presets (no vcpkg toolchain needed)
cmake --preset Standalone          # fast Debug build
cmake --build --preset Standalone

# size-first Release: -Os, gc-sections, LTO, stripped
cmake --preset StandaloneSize
cmake --build --preset StandaloneSize
# -> ~0.35 MB stripped aetheris executable
Rendering pipeline

A document, stage by stage

This is an interactive diagram of the shipped pipeline in src/rendering/ — not a screenshot. Select a stage to see what each subsystem is responsible for.

HTML → DOM

Raw HTML bytes are tokenized and assembled into a tree, producing a DOM document object.

  • html_tokenizer — bytes to tokens
  • html_tree_builder — tokens to nodes
  • dom / document — Document::parse_html
src/rendering/
Get started

Clone it, build it, run the suite

No installer and no hosted download is promised by the project. Clone the repository and build from source — the Aetheris-specific targets need only a C++20 compiler.

shell
git clone https://github.com/drsamonline/The_Browser.git
cd The_Browser
cmake -S . -B build && cmake --build build --config Debug
ctest --test-dir build --output-on-failure
C++20 CMake ≥ 3.25 Windows · Linux
FAQ

Straight answers

Is Aetheris a complete browser?
No. It is an experimental rendering foundation plus an upstream-derived tree. The project does not claim complete HTML, CSS, DOM, JavaScript or browser-API compliance, and it is not a production-ready replacement for established browsers.
What is actually Aetheris-specific here?
The AetherisRendering foundation in src/rendering/ and its regression suite in Tests/AetherisRendering/. The AK, Libraries, Services, UI, Meta and Base trees are upstream-derived from the Ladybird/SerenityOS ecosystem and retain their original notices.
How do I build and test it?
Configure with cmake -S . -B build, build with cmake --build build --config Debug, and test with ctest --test-dir build --output-on-failure. The Aetheris-specific targets also build through the dependency-light Standalone preset (or -DAETHERIS_STANDALONE_BUILD=ON), and a size-first StandaloneSize preset builds them for minimum footprint.
Does the prototype runtime build?
Yes. The prototype runtime in src/main.cpp, src/cache/, src/network/, src/ui/ and include/aetheris/ is built into the AetherisRuntime library and the aetheris executable. Its external dependencies (LZ4, X11) are optional and fall back to bundled shims, so it is compile-checked on every standalone build — though it is not production-complete.
Can I relicense the repository?
Not without a file-level provenance and licensing audit. Upstream copyright notices and licence texts must be preserved, and upstream-derived code must not be presented as entirely Aetheris-authored.
Does it claim specific performance numbers?
No. The project explicitly does not claim fixed limits for binary size, idle memory or startup time. Performance work is framed as measurable engineering, and future public claims are expected to be reproducible with recorded environment details.