Browser logic, without the rendering pipeline.
Execute website JavaScript and work with Chrome-visible browser state in a lightweight Go runtime.

Quick start · Benchmarks · CDP support · Product vision · Architecture

Let the website do the work

The website's JavaScript. Browser state. A lighter runtime.

Mimic runs website logic without launching Chromium or rendering pixels. Extract data, automate flows, and run concurrent pages through familiar CDP tools.

Our ambition: direct HTTP lightness with browser compatibility. One environment profile. Native SOCKS5, HTTP, and HTTPS proxies. Less setup between you and the workflow you want to automate.

Public Beta · Windows & Linux. Visit the Mimic website → · Download the latest release → DM moreveal on Discord for feedback and workflow help.

Built for execution

Website logic	Observable browser state	Automation & capture
V8 executes JavaScript alongside the resource loader and browser scheduler.	DOM, navigation, and CDP share canonical state, with separate document, frame, and Worker realms.	Connect over the supported CDP surface, evaluate JavaScript, navigate, and export static DOM snapshots.

Each Page owns its event loop. Independent Pages can execute concurrently, while callbacks and microtasks remain ordered within each Page. See architecture and compatibility boundaries.

Measured, not assumed

Fresh-build results from September 14, 2026, against Chrome 152.0.7977.82 in headless mode, on Windows 11 x64 (Intel i7-14700KF, 31.83 GiB RAM).

92% lower ready RSS. 62% less active RAM and 3.32× throughput at 50 static pages. Measured on these fixtures and this machine; startup RSS is not per-page memory.

Mimic is actively evolving toward direct HTTP lightness with browser compatibility. These are selected strengths from an early checkpoint; see Known limitations and the complete benchmark report for the current tradeoffs.

Full results, concurrency, CPU, memory, and methodology →

Full measured report and raw data · Performance history · Reproduce

Quick start

Windows amd64 and Linux amd64, Go 1.26.4+, CGO, and a C compiler. The packaged Linux engine requires glibc 2.39+ (Ubuntu 24.04 or newer); Alpine/musl and ARM64 are not supported. V8 is bundled for both platforms. See complete setup for requirements and native rebuilds.

1. Build and start

Linux:

git clone https://github.com/moreveal/mimic.git
cd mimic
python tools/build_native_layout.py
go build -o .build/mimic ./cmd/mimic
./.build/mimic -listen 127.0.0.1:9222 -chrome 152

Windows (PowerShell):

git clone https://github.com/moreveal/mimic.git
cd mimic
python tools/build_native_layout.py
go build -o .build/mimic.exe ./cmd/mimic
./.build/mimic.exe -listen 127.0.0.1:9222 -chrome 152

Keep the local third_party dependencies in the checkout. The first build needs module dependencies available; Go can download the pinned toolchain automatically. V8 is the default. No separate Chromium installation, GPU, or .env file is required to run Mimic. Stop the server with Ctrl+C.

For a live visual mirror of a CDP target, start with -dev-preview and open http://127.0.0.1:9222/debug/preview/. See preview behavior and limits.

2. Connect over CDP

In another terminal, discover the available targets:

# Linux
curl http://127.0.0.1:9222/json/list

Invoke-RestMethod http://127.0.0.1:9222/json/list

Connect a WebSocket client to a returned webSocketDebuggerUrl and send:

{"id":1,"method":"Runtime.evaluate","params":{"expression":"1 + 2"}}

Page.navigate starts navigation; wait for lifecycle events or an application readiness marker before consuming the result. Check the CDP matrix for supported commands and behavior.

3. Capture a page

With the server running, use another terminal in the same checkout.

Linux:

python3 -m venv .venv
./.venv/bin/python -m pip install pyppeteer==2.0.0
./.venv/bin/python tools/mimic_snapshot.py "https://example.com/" snapshots/example --settle-ms 2500

Windows:

python -m venv .venv
./.venv/Scripts/python.exe -m pip install pyppeteer==2.0.0
./.venv/Scripts/python.exe tools/mimic_snapshot.py "https://example.com/" snapshots/example --settle-ms 2500

The tool exports a static DOM snapshot and available assets, with progress and diagnostics. Use a new output directory for each capture. Readiness is a heuristic; exports exclude scripts, embedded frames, and canvas pixels. See the complete setup and capture guide for wait controls, partial captures, engine fallbacks, and troubleshooting details.

Platforms and browser targets

Mimic runs on Windows and Linux. The host OS and the browser compatibility profile are separate: Linux execution also uses the frozen Chrome 152 profile.

Area	Available today	Direction
Platforms	Windows amd64 and Linux amd64 (glibc 2.39+), with bundled V8.	Additional architectures and libc variants require native engine builds and validation.
Browser behavior	Frozen Chrome 152.0.7977.82 as the measured reference.	Additional Chrome versions through the version-neutral compatibility registry, backed by version-specific observations and tests.

Fonts and OS services depend on the host. Linux uses installed Liberation, DejaVu or Noto fonts when reference families are absent; exact Windows text metrics require the reference fonts. Native speech synthesis uses Windows SAPI. See host-dependent behavior.

The -chrome 152 flag selects the current compatibility target. It does not install or launch Chrome. See the target manifest and oracle policy for the exact behavioral reference.

Known limitations

Warm execution is faster in two of six fixtures and still trails Chrome most sharply for DOM mutations. The Windows host stopped Mimic's 100-page levels at its memory-pressure guard. On Linux, allocator arenas are reclaimed after Page teardown, but active memory per concurrent Page remains higher than Chrome because each Page owns an independent V8 isolate.

Current boundaries

Mimic models what scripts can observe; it does not render pages. Full CSS layout, Canvas/WebGL pixels, media playback, and complete Web API/CDP compatibility remain outside the current implementation. Generated API names are not proof of working semantics. Follow the compatibility notes when evaluating a workload.

CDP has no authentication and is intended for trusted local clients. Mimic is not a security sandbox for hostile code. Navigation has no deadline by default; configure -navigation-timeout 30s when your workflow needs one.

Go deeper

Guide	What you’ll find
Setup & automation	Build requirements, engine choices, snapshots, and verification commands.
Product vision	Why Mimic exists and where it is going.
Architecture	State ownership, Page isolation, scheduling, and the graphics observation boundary.
CDP compatibility	The supported automation contract.
Behavioral oracle	How frozen headful Chrome defines correctness.
Performance work	Measured improvements, tradeoffs, and unresolved costs.

Contributing? Start with AGENTS.md and the verification guide. Compatibility changes should be backed by focused regression tests and Chrome observations.

License

Mimic is source-available under the Prosperity Public License 3.0.0. Noncommercial use is free; commercial use has a 30-day trial, after which a separate commercial license is required. LICENSE is the authoritative text. Third-party components retain their own licenses.

Contributions require acceptance of the Mimic CLA; see CONTRIBUTING.md.