BoardRipper

What is this, and why self-host it?

Docker is a way to ship an application as a single image that runs the same on any machine: no installer, no per-OS binary, no dependency hell. You give Docker the image, point a port at it, and it runs. BoardRipper ships as a ~25 MB Docker image (~13 MB compressed); docker compose up -d and it's online.

Why run it on a NAS or shop server:

• One library, every workstation. Boards and schematics live in one place — open them from the bench laptop, the office desktop, or a tablet next to the microscope.
• No per-machine install. It's a web page. Send a coworker the URL and they're up.
• You own the data. Boards stay on your hardware, nothing leaves the network.
• Touch-friendly. Pinch-zoom on a shop tablet works the same as the mouse on a workstation.
• One-click container update from the toolbar.

Runs on

Server side — Docker on Linux, macOS, or Windows; or the standalone Go binary (Linux x86_64, macOS Intel/ARM, Windows x64). Runs happily on a Synology or QNAP NAS, a Raspberry Pi 5, an old laptop in a closet, or anything else that can run a container.

Client side — any modern browser (Chrome, Firefox, Safari, Edge) on any OS, including iPad and Android tablets. There’s no per-client install — you open the URL. Minimum versions and a list of iPads and iPhones by model: supported browsers and devices.

Old hardware — the rendering pipeline is GPU-accelerated WebGL, which leans on the integrated GPU rather than the CPU. Bench-tested on 3rd- and 4th-generation Intel laptops (HD 4000 / HD 4400 / HD 4600 era), frame rate sits in the 10–30 fps range depending on the board — usable but visibly slower than a modern GPU. On those machines you may want to lower the browser zoom or window size and turn off a few of the visual extras (label tier, glyph overlay) in the Settings panel; the Debug panel surfaces frame-time so you can see what’s slow.

Features

• GPU-accelerated rendering — 10,000+ components at 60 fps on a modern GPU (PixiJS / WebGL).
• Multi-board tabs — open several boards at once, switch between them.
• Multi-layer support — show / hide top, bottom, and inner layers independently. Butterfly mode shows top and bottom side by side.
• Net highlight — click a pin and the whole net lights up across the board. A chain-adjacent mode walks through neighbouring nets too.
• PDF schematic, in sync — pan, zoom, search, night mode. Right-click a net to search it in the schematic.
• Detached schematic window — pop the entire PDF group out into its own OS window with one toggle. Board lives on one display, schematic on another, click-board → jump-PDF link still works across windows. Mode is symmetric across browser and Electron desktop builds; persisted so the first PDF you open reopens in the popout automatically.
• Worklists — track repair lists of components per board: pin it, mark it done, jump between entries. Saves with the board so it's there when you re-open. Reachable from the sidebar tab and a keyboard shortcut.
• Part comparison — put one component’s pinout next to the same chip on another open board, pin by pin. Where the net names differ, BoardRipper checks what each net actually touches, and reads the naming conventions boards use — a pin marked unused, a rail written two ways — so a board that was only renamed does not read as a fault. Switch on “Highlight on board” to mark the differing pins on the board itself, and hover one to see what it differs to. Diode readings sit side by side where the boards carry them.
• Touch input — pinch-zoom, drag-pan, tap to select. Usable on a tablet at the bench.
• Customizable colors — per-net rules by name pattern (e.g. GND, VCC, PP*), per-component-type fills (R / C / L / U / Q / D / J), per-layer colors, label / pin / outline tuning. Live preview before applying.
• Multi-line search — each line is an extra AND-filter, useful when a component carries value and voltage on separate label lines:

  20uF
  10V
  C12*

  finds capacitors that match all of: 20µF, 10 V, designator starting with C12.
• Drag-and-drop import — drop a board file or a folder onto the window and it loads. To make dropped files persistent across container restarts, mount one writable folder at /library/incoming (see Docker setup). Without it, drops live only in the browser’s IndexedDB cache.
• Board library — scan folders, browse by board number or model. Filenames are auto-sorted: board numbers, manufacturers, and revisions are parsed automatically.
• Board database with heuristics — a bundled reference DB maps board numbers to manufacturer / ODM / laptop or phone model and groups boards by device.
• PDF auto-link — boards and their schematics get matched up automatically when both are present in the same library.
• IndexedDB cache — re-open without re-parsing.
• Self-update — one-click signed update from the toolbar. No GitHub token required; updates are signed with an offline key and verified by the running container before install.

Supported formats

.cad is shared by two formats and .brd by three — BoardRipper sniffs file content to pick the right parser.

When the auto-detected orientation is wrong (a handful of Apple X-fold MLBs need a 180° flip), rotate once with the toolbar button and the choice is saved per-file. Next time you open the same file, the override applies automatically.

Docker setup

Typical deployment on a NAS or small home server:

services:
  boardripper:
    image: ghcr.io/alexeyinwerp/boardripper:latest
    ports:
      - "8081:8080"
    volumes:
      - ./data:/data
      # Your library: mount EVERYTHING read-only (:ro) by default.
      - /path/to/MacBooks:/library/MacBooks:ro
      - /path/to/iPhones:/library/iPhones:ro
      # The ONLY writable mount the container should ever see:
      - /path/to/incoming:/library/incoming:rw
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - PORT=8080
    restart: unless-stopped

Then: docker compose up -d → open http://your-nas:8081

Mount your board folders as subdirectories of /library — each one shows up as a top-level folder in the Library panel.

Keep every other mount :ro. /library/incoming is the only path BoardRipper should be able to write to — that’s where dropped files land. The container does not need write access to your existing board folders, your schematics, or anything else.

Self-update needs the /var/run/docker.sock mount — that's what lets the container pull the new image and restart itself when you click "update" in the toolbar. Remove it if you'd rather update manually with docker compose pull && docker compose up -d.

Download

Pick the install style that fits how you work:

Run in the browser — no install

The lite build: the full BoardRipper viewer and inspector running entirely in your browser, with no server and no backend. Open your own boardview files and PDFs locally — nothing is uploaded, nothing leaves your machine. Point it at a folder of boards and schematics and it indexes them in the browser, so you get a library to browse and search without a server. There is no shared library across machines, board database, PDF full-text search, or self-update (those need the Docker build), but all rendering, inspection, net-highlight, layers, themes, and PDF viewing are there.

• Open it now — ripperdoc.de/boardripper/web. Loads in the browser; installable as an offline app (PWA).
• Offline single file — boardripper-lite.html (~7 MB). Save it and open it in any browser — works fully offline, no internet, no server. Put it on a USB stick and take it to the bench.

Everything runs client-side in your browser. Encrypted ASUS .fz files still need a key pasted or fetched in-app (same as the Docker build). The Offline copy button in the top-right of the web app downloads the same single file.

Desktop app

An Electron wrapper around the same web UI. One-click install, no Docker. Each platform ships as a portable .zip — unzip and run.

• macOS (Apple Silicon + Intel, universal) — BoardRipper-macOS-universal-latest.zip
• macOS (Intel-only, legacy 10.13–11) — BoardRipper-Legacy-macOS-x64-latest.zip
• Windows (x64) — BoardRipper-Windows-x64-latest.zip

Primary host is GitHub Releases — the links above are the failover mirror on ripperdoc.de in case GitHub Releases is unreachable. Same bytes either way. macOS apps are unsigned; first launch needs right-click → Open. Older versions live in the version archive.

Docker / self-hosted

For NAS, lab benches, and multi-user setups. Pulls a ~15 MB scratch-based image; self-updates from the running container.

• Container registry (recommended) — docker pull ghcr.io/alexeyinwerp/boardripper:latest. Public, no login.
• Tarball mirror — latest.tar.gz (OCI image archive, ~13 MB), shipped alongside a signed manifest.json. Use this if your network blocks container registries; load with docker load < latest.tar.gz.

Both downloads ship the same image. The running container verifies an Ed25519 signature against a key compiled into its own binary before installing any update — a hijacked mirror cannot deliver a forged update.

Drop-to-update fallback

For Docker installs that can’t reach the registry or the mirror (firewalled networks, air-gapped shops, or recovering from a broken self-update), download the bundle and drop it onto the BoardRipper window:

• latest-update.tar — signed bundle (manifest + signature + image), ~13 MB

Drag the file anywhere on the BoardRipper UI. A confirmation prompt appears; click OK and the running container verifies the signature, applies the update, and restarts. The browser reloads after ~30 s. Same trust envelope as the in-app updater — the manifest signature is what grants trust, the file itself is treated as untrusted bytes until verification passes.

Older versions and changelog

• Version archive — every release (tarball / drop-bundle / source links).
• Release notes — changelog.

Feedback

• Bugs and feature requests: open an issue on GitHub — templates for bug reports, feature requests, and new board formats.
• New format requests: there’s a dedicated format-request template. Real-world sample files are how new parsers get written — please attach what you can.
• Security disclosures: mail@ripperdoc.de rather than the public tracker — see SECURITY.md for the policy.
• Discord: @inwerp on the RipperDoc server — feature requests, quick questions about deployment or file formats, and a small repair community.
• Email: mail@ripperdoc.de for anything not bug-tracker shaped.

Support the project

Credits & references

BoardRipper exists because of the work the boardview community has already done. Each entry below was consulted during development; full attribution and license details live in THIRD_PARTY.md.

Parser references

• KiCad — GPL-3.0 — Cadence Allegro BRD reader (pcbnew/pcb_io/allegro/), transliterated to TypeScript. The reason BoardRipper as a whole is AGPL-3.0.
• OpenBoardView — MIT — reference implementations for BVR1 / BVR3, BRD (Apple), BDV plain-text, BDV ASC (Honhan / Tebo-ICT), FZ (ASUS), GenCAD, XZZ.
• eagleview by Pavel Kovalenko — MIT — TVW / Teboview parser source.
• brd_parser by Jeff Wheeler — MIT — cross-validation reference for Allegro block layout.
• piernov’s Honhan BDV gist and OpenBoardView issue #2 — identified the BDV ASC signature and line-key cipher.
• Mentor Boardstation Neutral — original reverse engineering, no third-party code or text incorporated.

Cryptographic standards

• RC6 by Rivest, Robshaw, Sidney, Yin — FZ format.
• DES (FIPS PUB 46-3) — XZZ format.
• GenCAD 1.4 specification — CAD format. (No canonical online reference; the format is documented in docs/formats/CAD_FORMAT.md.)

Rendering & runtime

• PixiJS — MIT — WebGL renderer.
• pixi-viewport — MIT — pan / zoom / culling.
• React — MIT — UI framework.
• Vite — MIT — build pipeline and dev server.
• TypeScript — Apache-2.0 — type system.
• Dockview — MIT — dockable / floating / popout panels.
• pdf.js — Apache-2.0 — PDF rendering and text extraction.
• pdf-lib — MIT — PDF manipulation.
• opentype.js — MIT — font glyph extraction.
• Tabler Icons — MIT — icon set.

Backend

• Go standard library — BSD-3-Clause — HTTP server, crypto, encoding.
• modernc.org/sqlite — BSD-3-Clause — pure-Go SQLite driver, used by the board reference database.
• rsc.io/pdf — BSD-3-Clause — PDF text extraction for the databank indexer.

Desktop wrapper

• Electron — MIT
• @electron/packager — MIT
• @electron/universal — MIT — macOS universal binary.

Corrections and missing attributions welcome — email me.

About this software

I have a programming background, but BoardRipper is not hand-written. The whole codebase — parsers, renderer, panels, backend — was generated with Claude Code, working from format specs and reference implementations from the boardview community. I review, test, and direct it; the lines of code came out of an LLM.

For context: I’m a father of two and I work 50–60 hours a week. Hand-writing a project of this scope was never going to happen — this was the only way it was ever going to exist. Sceptics will dismiss anything in this category as “AI slop”; I think BoardRipper is a fair counterexample. Eleven boardview parsers, ten thousand components rendered at 60 fps, and not one line of code written by hand. It works on real boards in real shops. That’s the answer I have for the slop critique — not arguing about it, just shipping something useful.

Treat that as you would any AI-assisted software: it works on the boards I’ve tested, it has bugs I haven’t found yet, and the right level of trust is “a useful viewer, not a forensic tool.” Bug reports welcome.

Thanks to Maksim Shevelev and Joseph Hughes for testing and bug reports.