CAD & 3D changelog

New tool: photograph an electronics board, from a TV, a power supply, a radio or a computer, and its markings are read at any angle. Parts get their type, chips get their part number and datasheet search links, and resistor codes and capacitor values are decoded with the working shown.

What it does

• Markings at any angle: each chip is straightened from the full-size photo and read four ways up, so rotated and upside-down print still reads.
• Parts by type: a part detector trained on public datasets and our own labelled board photos finds the chips, capacitors, resistors, transistors and the rest, and groups the list by type.
• Part numbers and short codes: full part numbers come with the maker and datasheet search links. Short SMD codes are looked up in marking tables built from makers' datasheets, with ranked candidates and the datasheet each comes from. A code no table lists says Not identified, with a search for the code as printed.
• Values decoded: 3-digit, 4-digit, EIA-96 and R-notation resistor codes, printed electrolytic capacitor values, crystal frequencies and date codes.
• Check against the design: add the board's Gerber, ODB++, IPC-2581 or BOM and placement files, and each designator is matched to its part, with BOM lines that disagree flagged.
• Export: an annotated full-size photo and a parts table.

How accurate it is

We tested it on photos it never saw:

• Full part numbers: the right part for 27 of 35 legible chips, about three in four.
• Short codes: often not identified yet (3 of 19), because most makers' code tables are not in it yet. Those rows say so instead of guessing.
• Part types: of the parts it found, 24 of 27 chips, 70 of 84 electrolytic capacitors, 82 of 82 resistors and 89 of 165 other parts were typed correctly.
• Sure answers we could check: every sure answer we could check against a known answer was right. On photos it never saw: 6 part numbers, 2 resistor values and 2 crystal frequencies. On the photos we tuned it on: 23 part numbers, 13 resistor values, 1 capacitor value and 3 crystal frequencies. Sure values with no known answer to check against are not counted here. When it is unsure, a row says Check, Can't read, Can't tell or Not identified.

Good to know

• Light from the side, no flash: laser-etched markings read best that way, and a close-up reads small parts a whole-board photo can't.
• One download: about 47 MB on first use (the text reader and the part detector; about 15 MB if another Loft reading tool already has the text reader), kept for later visits. After that it works offline; datasheet search links need a connection.

Drop an IPC-2581 .xml or an ODB++ .tgz and the Gerber Viewer opens it the way it opens a Gerber bundle — copper, drill, soldermask, silkscreen and the board outline on one canvas, with every existing feature working on it. Flex and rigid-flex boards are read properly, not flattened into a rigid one.

What's new

• IPC-2581: layer names, sides and functions come from the file's own layer table, so there is no mapping dialog to confirm. Net names come with them, so the netlist panel fills itself — 514 nets on a typical reference board.
• ODB++: the full job, read from the layer matrix. A four-copper board usually exports twenty-plus layers because ODB++ carries the whole CAD stack, mechanical and assembly sheets included; those are separated from the fabrication layers instead of cluttering the rail.
• Flex and rigid-flex: coverlay, stiffener and the bend, flex and rigid regions are identified and drawn, with the regions tinted so you can see which part of the board bends without hiding the artwork underneath. The board reports itself as flex or rigid-flex on its own.
• Custom pad shapes: jobs that define their own pads — odd connector lands, joined 0201 pairs, spark gaps — are read rather than skipped.
• Blind and buried vias: each drill layer is labelled with the span it drills, so a board with seven of them is readable.
• Everything else still works: measurement, DRC against the fab presets, layer compare, net tracing, the 3D view, and PNG / SVG / DXF export all run on an imported board with no extra steps.

Fixed

• Inch boards measured wrong. A board 4 inches across reported 0.16 inches, and min trace, min drill, cursor position and the fab-readiness figures were all off by the same factor. Every file is now converted to one unit as it is read. A bundle whose drill file uses a different unit from its Gerbers now lines up too, instead of dropping the holes in a cluster near the corner.
• The mm / in toggle changed DRC results. Switching units altered what the design-rule checks were comparing against, which could invent violations on a board that passes or hide real ones. The toggle now changes what you read and nothing else, and a report no longer mixes mils and millimetres in the same list.
• Pick-and-place files in other units. A CPL exported in mils or inches placed its parts in the wrong spot. The unit is now read from the value, the column heading or the file's own header, whichever states it.

Everything runs in your browser. Your board files never leave your device.

Open a part in any of the 3D/CAD viewers and it now inspects itself for how hard it is to make — holes, corners, draft, undercuts, wall thickness, plus a process-aware cost and difficulty estimate. A fast first look at manufacturability without opening a CAD seat or a DFM tool.

What it checks

• Holes and fasteners — deep holes (depth-to-diameter past the drilling limit), countersinks and counterbores, and bolt circles read straight off the geometry with their pitch-circle diameter (PCD).
• Sharp internal corners — inside corners too tight for a standard end-mill radius, the classic "this can't be milled as drawn" flag.
• Draft angle — faces with too little draft for molding or casting to release cleanly.
• Undercuts — pick a pull direction and the viewer finds the regions a mold or a 3-axis tool can't reach. Reported by area, not by raw triangle count, so the number means something.
• Thin walls — minimum wall thickness, with coincident-face artifacts filtered out so a flat plate no longer reads as 0.00 mm.

Cost and difficulty

• Process-aware — CNC machining, 3D printing (FDM/SLA), sheet metal, and casting/molding each score the same part differently.
• Difficulty score 0–100 with the drivers spelled out, so you see why a part is hard, not just that it is.
• Cost estimate is opt-in — turn it on when you want a number; it stays off by default.

Click a finding to find it

• Every issue in the panel is clickable — select it and the exact geometry lights up in 3D, so "deep hole" points at which hole.

Works across the whole viewer family

• Live on all the mesh viewers — STEP, STL, OBJ, PLY, 3MF, and GLB.

For agents

• Exposed on the in-page agent surface: window.loft.tools gains analyzeDfm and analyzeCost, so an assistant driving the viewer can pull the same manufacturability and cost read-out as a structured result.

It's a fast first look, not a replacement for a full DFM package or a quote from your shop. Everything runs in your browser — the part never leaves your device.

Big polish pass across the seven CAD viewers. The measure tool stops feeling like a prototype and starts feeling like Onshape; the navigation chrome finally has the standard buttons every desktop CAD user expects; and the editor template that powers all our viewers got the canonical primitives extracted so new tools won't reinvent them.

What's new

• Top-floating measure rail replaces the right-rail accordion. Mode chips for Distance / Angle / Radius / Area / Bbox, a Straight ↔ Along-surface path toggle, units + precision selectors, an entry-count badge, and Undo / Copy / Clear actions — all in one cursor-aware row that drops over the canvas only when measure mode is on.
• Inline canvas labels float at each committed measurement's midpoint with a leader line back to the part. Click the label to delete the entry. Labels track the camera in real time as you orbit.
• Cursor coach chip follows the pointer during a pick. Three lines: what the next click does ("Click 2nd point"), the running provisional value (running distance, or polygon area in area mode), and the keyboard hints ("Backspace = undo · Esc = cancel").
• Four measurement kinds were two before. Radius picks three points on an arc and draws the circumscribed circle + centre marker. Area picks 3+ polygon vertices; double-click or Enter to commit. Distance + Angle stay.
• Along-surface (geodesic) mode for distance + area. Samples the segment, raycasts onto the mesh, sums the actual surface walk instead of straight-line distance. Useful for cable-length and seam estimates on STEP / STL parts.
• In-progress polygon ghost — a dashed cyan outline tracks the polygon you're building, and a pulsing yellow ring appears over the first vertex when you hover close enough to close. No more "where do I click to finish?".
• Per-snap-type glyphs — the snap badge under the cursor now correctly labels vertex / edge-midpoint / face-centroid targets instead of always saying "vertex". Built from a new half-edge adjacency cache that runs once per file load.

Navigation toolset

• Pan / Hand tool button on every viewer. Left-drag pans while it's active; right-drag still orbits. Trackpad users no longer have to learn that right-drag pans.
• Zoom Window marquee. Click the chip, drag a rectangle, and the camera tweens to fit that screen region.
• Home button captures the framing you saw on first load — so "home" actually returns to your default view, not a generic iso angle.
• Views popover — every viewer now exposes the 7 standard cube views (front / back / top / bottom / left / right / iso-home) plus 5 saved-bookmark slots with rename / overwrite / clear actions. Saved per-tool, persisted across sessions.
• Smooth camera tweens on every view jump, bookmark restore, fly-to-feature, cube click, fit-to-selection. Quadratic ease over 300ms. Respects prefers-reduced-motion.
• Right-click context menu on the canvas. Click a face to select it (flood-fills the connected co-planar region with a translucent overlay), then right-click for Fit to selection / Home / Start measure / Clear selection.

STEP improvements

• STEP explode view — drag the slider in the Explode popover or hit E to spread an assembly's shells along the Z axis. Same UX as the existing 3MF explode; works on any multi-shell STEP.
• Section view in box mode no longer renders a stippling z-fight pattern on bbox-aligned faces at default 0/100% bounds.

Display + render controls

• Background presets — theme, dark, light, gradient. (UI surface lands next; the engine hooks are live.)
• Lighting presets — studio / outdoor / 3-point / soft. Modulates the three scene lights in place.
• Render quality slider — low / auto / high. High enables ACES filmic tonemap for PBR-textured GLB / glTF models.

Tree search

• Search above the assembly tree in STEP / 3MF / OBJ / GLB viewers. Renders only when the tree has more than 5 nodes — simple files stay clean.

Under the hood

The editor template that powers every viewer + editor (PDF Editor, Gerber Viewer, CAD viewers) now ships canonical primitives so future tools won't rebuild them:

• useEditorHistory — generic event-sourced undo/redo + jump-history hook. PDF Editor + Gerber already migrated.
• ContextMenu, MeasureRail, MeasureToolbar, MeasureCoach, MeasureCanvasOverlay, PanToolButton, HomeButton, BookmarksMenu, ZoomWindowButton, TreeSearch — drop-in primitives in src/components/editor.
• measure-math.ts — pure-math kernel (distance / angle / circumscribed circle / polygon area) shared across 2D + 3D viewers.
• edge-adjacency.ts — half-edge cache with floodFillCoplanarFace powering face selection + per-snap-type glyphs.

Try it on STEP viewer, STL, 3MF, OBJ, PLY, or GLB.

Every CAD viewer's top bar is now organised the same way. Open one viewer, you know where every button lives in the other seven. Web-first means no hidden popovers — every action stays visible — but grouped so your eye finds the right cluster instantly.

Canonical group order

FILE | MODE | NAV | DISPLAY | ACTIONS | ⌘K

• FILE — open the file picker.
• MODE — Measure, Section (the two stateful tools).
• NAV — Pan, Zoom Window, Fit, Home, Bookmarks (the camera controls; Onshape/Fusion users will feel at home).
• DISPLAY — Explode, Bbox, axis re-orient — whatever toggles how the geometry is shown.
• ACTIONS — Screenshot, Share, AR, Compare — one-shot commands.
• ⌘K — the command palette, always at the far right (matches PDF Editor).

Groups are separated by 1px dividers. The trailing Commands button is pushed to the right edge with a flex spacer, so it sits exactly where Adobe / Affinity / Figma users expect.

Naming fixes

• "Dims" → "Bbox" everywhere. The old label was ambiguous (dimensions of what?). Bbox tells you it toggles the bounding-box overlay.
• "PNG" → "Screenshot". We render screenshots as PNG, but the user-facing action is "take a screenshot." The verb belongs on the button, not the file format.

Per-viewer specifics

• STEP — full 6-group layout including Compare deep-link in ACTIONS.
• STL — adds a 3D-print group between MODE and NAV: Plate (build-plate ghost) · Printer (profile select) · Drop-to-plate.
• 3MF — Explode lives in DISPLAY (only meaningful for multi-part files).
• OBJ — axis re-orient (Y-up ↔ Z-up) in DISPLAY.
• PLY / GLB — standard 6-group layout.
• DXF — pared-down 2D layout: no Section/AR/Bookmarks/Explode (none apply to 2D).

Why this matters

Inconsistent toolbars cost users milliseconds on every action. Multiply by a CAD review session that takes 20 minutes and you've burned attention on layout-hunting that should go to the part. Canonical order makes muscle memory transfer between formats — open a STEP today, an OBJ tomorrow, the buttons are in the same place.

The new layout primitives (Divider, TopBarSpacer) live in src/components/editor/primitives/ and are exported from the editor barrel, ready for future tier-1 editor tools (audio, video, RAW).

Seven viewers ship together on the same Rust→WebAssembly substrate. Drop a part, see the geometry, measure it, save a PNG. Nothing leaves your machine — every byte stays in the tab.

• STEP viewer opens AP203 / AP214 / AP242 files (.step / .stp) and tessellates them in the browser via a vendored fork of the Apache-2.0 ricosjp/truck Rust CAD kernel. We carry local patches for the bugs we hit on Schneider Electric J-frame breakers (silent B-spline drop on Inventor exports) and Elgin EG-Frame mechanisms (sphere-radius panic on sub-tolerance fillets). The trimmed mesh streams across a Web Worker so the main thread stays responsive on 17 MB assemblies — verified end-to-end on a Schneider PowerPact JDC3 + an Elgin breaker mech (126,000 triangles, 16 MB file, no UI freeze).
• DXF viewer opens AutoCAD drawings and renders them as SVG in the browser. Line, arc, circle, polyline, lightweight polyline, spline, and ellipse are all supported. Block-reference (INSERT) entities recursively expand the block definition with translation + rotation + scale, depth-capped at 16 nestings — a typical mechanical drawing's title block, branding, and section markers all light up correctly.
• STL / OBJ / PLY / GLB / glTF / 3MF viewers — the same React shell with format-specific loaders. Each viewer auto-detects format by magic bytes when the extension is missing, so users who drop a .bin exported from Fusion 360 still get sensible behaviour.
• Section view — three dual-knob sliders carve away the bounding box on the X / Y / Z axes via Three.js per-material clipping planes. Useful for hiding bundled accessories (rotary handles, mounting kits) on Schneider J-frame STEP exports without touching the source file.
• Assembly tree — STEP files with multiple shells render as a THREE.Group of sub-meshes; the toolbar exposes per-shell visibility checkboxes. Single-shell parts get the existing single-mesh fast path.
• Measure — the classic point-to-point ruler with raycast snap. Click two points, read the distance in the status bar.
• Section view, render mode (shaded / wireframe / shaded + edges), screenshot, reset view — every viewer carries the same toolbar.

Numbers under the hood: 379 KB gzipped WASM, 200 MB hard file ceiling, ISO 10303-21 comment + empty-list preprocessor for Shapr3D / HOOPS Exchange compat (their STEP files were rejected by ruststep's strict tokenizer), 41 cargo tests, 14 lib tests, 7 property tests, ClusterFuzzLite fuzz harness. All vendored dependencies are MIT / Apache-2.0 / BSD / MPL — cargo deny check is enforced in CI.

Try the viewers at STEP, DXF, STL, OBJ, PLY, GLB, 3MF.

Hardware engineers asked for tighter feedback loops between the right-pane panels and the canvas. This release makes every panel row do something useful.

• Aperture highlight — click any row in the aperture table and every flash of that D-code on the layer lights up in cyan. The viewport recenters on the first flash so you can see what just lit up. Click the same row again to clear. The row gets a cyan tint that matches the on-canvas glow so panel + viewport read as the same control. Standard CAM350 / GerbView gesture, missing from v1.
• Click-to-pin trace width — in Inspect mode, click any copper trace where there isn't a pad under the cursor. A perpendicular dimension line drops across the trace at the cursor point, labeled with the conductor width. Sticks around like any other measurement, exports in the TSV / Markdown copy of the Measurements panel. Trace-edge endpoints get a new ┼ snap glyph so they're visually distinct from pad-edge ones.
• Trace-width probe is now always on — previously gated to Inspect mode; the spec promised always-on. Hover any copper conductor in the default Select mode and the status bar reports its width.
• Drill row click → recenter on first hole — same pattern as aperture rows. The drill table is no longer a passive list.
• Aperture sort columns get screen-reader semantics — aria-sort on every header, data-sid on every sort button so the agent harness can drive sorting too. Same treatment for the DRC group-head accordion.
• PNG export failure shows a toast instead of a blocking alert() dialog. SVG and DXF export gain catch-and-toast as well, so any future parse failure surfaces inline instead of as an uncaught console error.

Under the hood the 1995-line GerberPanels.tsx was split into 10 panel modules plus a shared helpers file. No behaviour change from the split, but every panel is now its own file you can read top-to-bottom in one screen.

Two hardcoded rgb() values in the readiness-score colouring were swapped for the --color-error / --color-success semantic tokens — they were the last raw colour leaks in the viewer's CSS.

Lives at /tools/open-tools/gerber-viewer.

Three days after launch, the Gerber Viewer gets the features hardware engineers asked for first: compare two boards, run design-rule checks, see the board in 3D, and handle flex / rigid-flex stackups.

• Diff mode — drop a second archive to compare two revisions. Slider mode reveals A vs B by dragging a vertical divider. XOR mode tints A in cyan + B in magenta so deltas pop while shared geometry reads white. Industry pattern from gerbv compare + KiCad ROOT plot.
• DRC — click DRC in the right pane and pick a fab preset (JLCPCB 2-layer, OSH Park 4-layer, IPC Class 2). Checks: min trace width, min drill, min annular ring, copper-to-edge clearance, real trace-to-trace clearance, copper shorts, and pour-to-trace clearance. Click any violation → viewport recenters on the exact location.
• Trace pick — click any pad or trace → BFS-walk the connected copper, highlight the entire net across all visible layers, with cross-layer hops via drill correlation. Works on copper pours.
• 3D board preview — open 3D in the toolbar to see your board extruded as a real PCB. Drill cuts are CSG-subtracted from the substrate. Layer textures render at 8 px/mm. Orbit / pan / zoom via mouse + trackpad.
• Flex / rigid-flex — when the .gbrjob declares Polyimide or Coverlay materials, the viewer auto-detects the board kind, surfaces a stackup table with IPC-2223 bend-radius calculation (5× / 8× / 15× rules), and unlocks a vertical bend slider in 3D mode that folds the back half around the centre axis using a vertex-shader bend. Coverlay layers render with the same bbox-evenodd technique as soldermask.
• GPU renderer — toggle the GPU button in the toolbar to switch from Canvas2D to a WebGL2 polygon-mesh backend. ~3× pan/zoom perf on boards over 10k chunks. Falls back automatically when the browser blocklists WebGL2 — and the toolbar pill stops lying about it (a silent fallback was the previous behaviour).
• Step-and-repeat parsing, X3 layer-state transforms (%LM mirror / %LR rotation / %LS scale), Eagle vector-paint coalesce, and a proper thermal pinwheel for AMTHERM primitive 7 — Eagle and Altium boards that previously looked off (rotated silk, fat copper pours, broken thermal pads) now render correctly.
• Silk masking — silk text is suppressed where ink physically wouldn't sit: over drill holes, over soldermask openings, and past the board outline. Matches inked-board appearance without fighting the file's chunk stream.
• Apple-style spinner during file load + parse, with brand colours and reduced-motion fallback.
• Pan as default mode, focus-blur on Space-down so toolbar buttons don't intercept pan, distinct on/off contrast for layer eye toggles.
• Two demo boards out of the box: Stickhub (KiCad reference 2-layer with X3 attributes, drill, paste, silk + .gbrjob) and Flex demo (60 × 17 mm flex strip with coverlay + polyimide stackup). Replaces the v1 placeholder samples.
• Empty / blocked states — drop an archive with no Gerber files → clear error. Hide every layer → "All layers hidden — toggle a layer in the rail" overlay. Browser blocks the print popup → toast tells the user. PNG export hits browser canvas-size limits → explains and suggests zooming out.

Parser worker prewarms on tool mount so the very first drop doesn't race the cold-compile. Bus auto-recovers if the worker dies. WebGL context-loss listener invalidates GPU caches and forces a redraw when the driver flakes.

Bottom-side layers default to hidden (Eagle stamps both sides at the same world coordinates without a per-layer mirror — showing both gives ghost-overlap; one toggle in the layer rail brings the bottom back).

Lives at /tools/open-tools/gerber-viewer.

First entry in the Open Anything category. Drop a fab archive (.zip / .tar / .tar.gz / loose .gbr / .drl), inspect every layer, measure traces — without installing CAM software.

• Archives: zip, tar, and tar.gz auto-detected by magic bytes, extracted client-side via fflate + nanotar. Loose Gerber and Excellon files land directly.
• Layer auto-detection: whats-that-gerber classifies each file (top copper, bottom copper, soldermask, silkscreen, drill, outline). Manual override lives on each layer row when the heuristic guesses wrong.
• Realistic PCB palette: green soldermask, copper-tone traces, white silkscreen, dark drill — the colours hardware engineers expect, applied via composite blend so soldermask actually tints copper underneath. Per-layer color overrides via inline swatch picker.
• Three-pane CAM350 layout: layer rail left (drag-reorder, visibility, color, kind), canvas center, inspector accordion right (Job info, Layer properties, Aperture table, Measurements, View, About).
• Measure tool: two clicks → distance with snap-to-pad. Live preview line shows running distance before commit. Pad-center snap powered by an rbush spatial index per layer, built lazily on first hover.
• Status bar (CAM350 / GerbView convention): cursor X/Y leftmost, mode + active layer center, scale (px/mm) and "Local" trust pill right.
• Aperture table: sorted by D-code with shape, size, and pad-flash hit count — matches Altium / KiCad GerbView.
• Pan + zoom: wheel zoom, drag pan, fit-to-window, 1:1, mirror (bottom-side flip), 90° rotation. Auto-fit on first load using actual canvas dimensions.
• Export: PNG snapshot, SVG (per-layer vector groups, opens in Illustrator / Figma / Inkscape), DXF (LINE / ARC entities for mechanical CAD).
• URL fragment encoding: viewport, layer visibility, and tool mode round-trip through the hash so a snapshot is one copy-paste away. Nothing leaves the device.
• Sample board bundled (CC0): one-click Try Demo to verify the pipeline before dropping a real fab output.

Phase C (CAM350 parity) shipped same day:

• World View minimap floating in the canvas bottom-right with click-to-recenter — CAM350 / GerbView convention.
• Test panel with Fab-readiness score (0..100, R/Y/G band) aggregating layer completeness, DRC violations, board-size sanity. Downloadable Drill CSV + Aperture CSV for fab quote requests. Layer-completeness checklist (top/bottom copper + soldermask both sides + top silk + outline + drill).
• Drill table panel (separate from Aperture table — CAM350 / KiCad convention): Tool / Diameter / Hits sorted by tool number ascending.
• Stack-up visualiser as a left-rail tab alongside Layers — vertical layer-order display with kind + side labels.
• Command palette (⌘+/) with 20+ commands, fuzzy search, ↑↓ navigation, Enter-to-run. Industry-convention shortcut (Figma / Notion / Slack) — no browser conflict.
• Find modal (⌘+F) accepting D-code (D11), refdes (U1), or coords (10, 12) in a single field — recenters viewport on the first hit.
• Print snapshot — opens a fresh window with canvas + caption + auto-print + auto-close.
• Job info enrichment: Perimeter (bbox-based) + Area + Copper area (sum of stroke length × width + pad bbox area) alongside existing Width / Height / Units.

v2 features shipped same day:

• Realistic substrate: board area paints in soldermask green so bare-FR4 between traces reads as a real PCB. White drill holes punch through copper pads — JLCPCB / GC-Prevue rendering convention.
• Industry-standard layer rail: top toolbar (All / Top / Bot / hide-all), per-row up/down reorder arrows, alt-click eye = solo, right-click for "Move to top / bottom" + Kind + Side override menus. Drag a file onto the rail itself = swap doc.
• Trace-width probe: hover over a copper trace in Inspect mode → status bar reports the exact width.
• DRC-lite with three fab presets (JLCPCB 2-layer, OSH Park 4-layer, IPC Class 2). Checks min trace width, min drill, min annular ring, copper-to-edge clearance. Click a violation row → viewport recenters on that location.
• Pick-and-place / CPL overlay: drop a KiCad .pos, JLCPCB CPL, or Altium PnP CSV; component centroids render as cyan dots with rotation ticks + designator labels.
• CAM350-style status bar: cursor X/Y leftmost, Mode + per-mode hint, active layer, scale (px/mm), Local trust pill right.
• Industry-standard cursors: default (Select), grab (Pan / Space-down), crosshair (Measure), help (Inspect).
• Cmd / Ctrl + wheel zoom (Figma / Acrobat / Altium convention) anchored on cursor position. Plain wheel no-op so accidental scrolls don't reframe the board. F or ⌘+0 fits to window. V / H / M / I switch modes.

Parser sits in a Web Worker — the main thread never blocks during a parse, and the heavy tracespace v4 + Node-stream shim load only on first drop. Lives at /tools/open-tools/gerber-viewer.

Gerber is a registered trademark of Ucamco NV. Loft Tools is an independent third-party viewer and is not affiliated with or endorsed by Ucamco.

First entry in the Open Anything category. Drop a fab archive, inspect every layer, measure traces, run DRC — without installing CAM software.

Core viewer

• Archives: zip, tar, tar.gz auto-detected by magic bytes; loose .gbr and .drl files also work. Everything extracts client-side.
• Layer auto-detection classifies each file (top copper, bottom copper, soldermask, silkscreen, drill, outline). Manual override on each row when the heuristic guesses wrong.
• Realistic PCB palette: green soldermask, copper-tone traces, white silkscreen, bright drill holes — the colours hardware engineers expect.
• Three-pane CAM350 layout: layer rail left, canvas center, inspector accordion right with Job info, Layer properties, Aperture table, Measurements, View, About.
• Measure tool: two clicks, distance with pad-center snap, live preview line.
• Pan + zoom: ⌘/Ctrl + wheel zoom anchored on cursor (Figma / Acrobat convention), drag pan, fit-to-window, 1:1, mirror, 90° rotate.
• Export: PNG, SVG (per-layer vector groups for Illustrator / Figma / Inkscape), DXF (LINE / ARC for mechanical CAD), Print.
• URL fragment sharing: viewport + layer visibility round-trip through the hash — share a deep-linked inspection view.
• Sample boards bundled (CC0): a four-pad smoke test plus a richer DIP-8 breakout with multi-layer routing and vias.

Same-day v2 (CAM350 parity)

• Industry-standard layer rail: top toolbar (All / Top / Bot / hide-all), per-row reorder arrows, alt-click eye = solo, right-click for "Move to top / bottom" plus Kind and Side overrides. Drag a file onto the rail = swap doc.
• Trace-width probe: hover over a copper trace in Inspect mode → status bar shows the exact width.
• DRC-lite with three fab presets (JLCPCB 2-layer, OSH Park 4-layer, IPC Class 2). Click any violation to recenter on it.
• Pick-and-place overlay: drop a KiCad .pos, JLCPCB CPL, or Altium PnP CSV — components render with rotation ticks and designator labels.
• World View minimap in the bottom-right with click-to-recenter.
• Test panel with a 0–100 fab-readiness score (R/Y/G band), downloadable Drill and Aperture CSVs, layer-completeness checklist.
• Drill table separate from the aperture table (CAM350 / KiCad convention).
• Stack-up visualiser as a left-rail tab.
• Command palette (⌘+/) with 20+ commands, fuzzy search.
• Find (⌘F): D-code (D11), refdes (U1), or coordinate (10, 12) in a single field.
• Editor groundwork: click a pad in Select mode to inspect or delete it; Delete / Backspace key wired.
• Geometric netlist extraction with CSV export and click-to-recenter per net; vias automatically union nets across copper layers.
• DRC expansion: silk-to-copper, mask-expansion, drill-to-drill spacing (7 rules total). Tree-grouped error explorer with click-to-recenter.
• Cross-probe: selecting a pad highlights matching coordinates on every other copper layer + drill.
• IPC-2581 detection: recognises the format and gives a clear "use Gerber export from your CAD tool" message instead of failing with a confusing parser error.

Lives at /tools/open-tools/gerber-viewer. Parser runs entirely in a Web Worker — the main thread never blocks during a parse.

Gerber is a registered trademark of Ucamco NV. Loft Tools is an independent third-party viewer.