reticle. v9.0.0

Open a 26 MB chip layout in a browser tab.

Reticle is an editor and viewer for very large hierarchical 2D layout scenes, the kind IC physical design produces. It runs in the browser on WebGPU, and natively on the same Rust code. Nothing to install to try it, and nothing uploaded: your design is read in the tab it is dropped into.

Open the live demo Download the native build Source
The Reticle editor showing a SKY130 standard cell: a layer palette on the left, coloured mask geometry on the canvas, and a DRC panel on the right listing eleven real violations with their coordinates.
A SKY130 cell open in the editor. Layer palette left, design-rule results right, live frame time in the status bar.
what it is editor checker viewer one Rust workspace

Three things, one codebase

The same Rust compiles to a native window and to wasm32 for the browser. There is no separate web port to fall behind.

draw

An editor

Draw and edit shapes on a layer stack, with snapping, arrays, boolean operations and a full undo history. Every command is in one registry, reachable from the palette and the keyboard.

verify

A checker

Design-rule checking that re-checks only the neighbourhood you changed, plus netlist extraction to SPICE and a layout-versus-schematic comparison. The rule decks are sourced from published PDK rules.

stream

A viewer for very large scenes

Hierarchical scenes stream in rather than loading whole. A multi-gigabyte archive opens by fetching the small part the first view actually needs.

quick start no account no upload two ways to run it

Start in about a minute

The browser build is the fastest way to see it. The native build is the one to use for heavy work, because it reaches the GPU without a browser in the path.

  1. Open the live demo. A sample design loads on its own.
  2. Drag a .gds, .oas, .cif or .dxf file onto the canvas. It is parsed locally; nothing leaves the tab.
  3. Press Ctrl+P for the command palette, or use Verify › Run DRC.
Requires WebGPU where available. Reticle falls back to WebGL2 when WebGPU is not present, so it still runs, with a lower ceiling on scene size.
pipeline openinspectcheckextractexport

What a session actually looks like

Every stage below is a real surface in the product, and each one can be driven from the UI, the command palette, or headlessly from the CLI. 

flowchart LR
  A["GDSII / OASIS
CIF / DXF / LEF-DEF"] --> B["parse
capped, never panics"]
  B --> C["hierarchical scene
cells, arrays, layers"]
  C --> D["render
WebGPU or WebGL2"]
  C --> E["DRC
incremental"]
  C --> F["extract
devices + nets"]
  E --> G["violations
with coordinates"]
  F --> H["SPICE netlist"]
  F --> I["LVS compare"]
  C --> J["export
GDSII, OASIS, SVG, PNG, STL, glTF"]
  classDef src fill:#161d27,stroke:#4a90d9,color:#dbe2ec
  classDef chk fill:#161d27,stroke:#3fb950,color:#dbe2ec
  classDef out fill:#161d27,stroke:#e8a33d,color:#dbe2ec
  class A,B,C src
  class E,F,G,H,I chk
  class D,J out
Parsers treat every file as hostile. Each reader caps count-driven allocation against the bytes actually remaining, so a malformed or crafted file produces an error rather than a panic. In the browser a panic would kill the tab, which is why this is a hard rule rather than a preference.
what it does captured from the running app

The parts worth seeing

Each clip below is recorded from the real build, not mocked up.

Design-rule checking running and listing violations with coordinates.

Design-rule checking

Run a deck over the open design and get violations with real coordinates. Editing re-checks only the neighbourhood that changed rather than the whole scene.

Drawing and editing shapes on the layer stack.

Drawing and editing

Shapes, paths, arrays and booleans on the layer stack, with snapping and a full undo history.

Tracing a net through the layout.

Net tracing and queries

Follow a net through the stack, ask what is connected to what, and see the answer highlighted on the canvas.

The layer stack rendered in three dimensions.

The stack in 3D

Lift the mask layers into their real Z order to see how the stack is built, and export it as STL or glTF.

A parametric cell generating geometry from parameters.

Parametric cells

Generate geometry from parameters, with the parameters and their provenance visible in the inspector.

Sharing a session by link.

Share a session

Hand someone a link to a live session, or an immutable snapshot permalink that always opens the same revision.

architecture one workspace two targets ~320k lines of Rust

How it is put together

The engine crates know nothing about the UI, and nothing about which target they are compiled for. That is what lets the browser and the native app be the same program rather than two programs that drift. 

flowchart TB
  subgraph engine["engine crates, target agnostic"]
    G["geometry
exact integer predicates"]
    IO["io
GDSII, OASIS, CIF, DXF, LEF-DEF"]
    IX["index
spatial + streaming"]
    DRC["drc"]
    EX["extract"]
    RN["render
wgpu"]
  end
  subgraph shells["shells"]
    APP["app
egui UI"]
    CLI["cli
headless"]
    MCP["mcp server"]
  end
  G --> IO --> IX
  G --> DRC
  G --> EX
  IX --> RN
  engine --> APP
  engine --> CLI
  engine --> MCP
  APP --> NAT["native window
wgpu to DX12 / Vulkan"]
  APP --> WEB["wasm32 bundle
WebGPU, WebGL2 fallback"]
  classDef e fill:#161d27,stroke:#8b7ab8,color:#dbe2ec
  classDef s fill:#161d27,stroke:#e8a33d,color:#dbe2ec
  classDef t fill:#161d27,stroke:#3fbfa8,color:#dbe2ec
  class G,IO,IX,DRC,EX,RN e
  class APP,CLI,MCP s
  class NAT,WEB t

Exact integer geometry

Predicates cross-multiply squared quantities in wide integers rather than computing irrational lengths. No float, no epsilon, no tolerance to tune.

Incremental checking

An edit invalidates a neighbourhood, not the scene, so re-checking stays proportional to what changed rather than to design size.

Streaming by design

A scene is fetched in the pieces a view needs. Opening a multi-gigabyte archive does not mean downloading it.

formats read write round trip

What it reads and writes

Import and export both run in the browser build as well as natively.

formatreadwritenotes
GDSIIyesyesthe common interchange stream
OASISyesyesconformant subset, refuses output its own reader would reject
CIFyesno
DXFyesnoopen entities import as zero-width paths
LEF / DEFyesnocross-checked against OpenROAD
SPICE netlistyesyeswritten from extraction, read for LVS
SVG / PNGnoyespublication output
STL / glTFnoyesthe 3D layer stack as a mesh
verify every number has a command

Check the claims yourself

Nothing on this page is meant to be taken on trust. These are the commands that produce the numbers. 

# the whole gate: style, clippy, tests, doctests, docs, wasm, e2e
just ci

# rendering throughput on your own GPU
cargo run -p reticle-render --example fps_bench --release

# the agent leaderboard, byte-identical when run twice
cargo run -p reticle-bench -- leaderboard --out -

# the shipped binary's own version
reticle --version
There is no CI service. just ci is the entire gate and it runs locally, so the same command that guards the repository is the one you can run.
limits read this part

What it is not

The short version: this is a layout editor and a checker, not a signoff flow.

Not a production EDA tool. No synthesis, no timing analysis, no device-level LVS, no tape-out signoff. Passing the bundled rule decks is not tape-out clean; they are documented subsets of published PDK rules.
Very large designs pan slowly. A 26.75 MB design with 427,265 shapes loads and renders correctly, and panning it at fit zoom costs about 170 ms a frame, roughly 6 fps. Idle on the same design is 6.1 ms. The design is fine; dragging it is slow, and that cost is not yet attributed to a single cause.
Some surfaces are native only. The scripted parametric-cell producer, the real agent and plugin execution run in the desktop app. The browser build shows preview or predicted state behind a visible disclaimer and never fakes a run.

The complete roll-call of fixture-backed, native-only, parked and deferred surfaces lives in docs/honest-limits.md in the repository.