soldermaskdocs

Everything soldermask does

This page lists every feature in one line, grouped by where it lives. Each line links to the page that explains it.

Three other lists cover the same ground from other angles:

A board starts from

  • A sentence. Type a prompt on the home page, run soldermask "<prompt>", or call POST /api/projects. See Projects and CLI.
  • A design.json. The model's format, built without a model call. See Projects and design.json.
  • A finished .kicad_pcb. Parts, positions and nets come across; traces do not. A board this pipeline cannot build is refused with the reason. See Projects.
  • A board from a file keeps what it draws. Its pad shapes, holes, outline, mask windows and rule areas bind the router. The placer keeps parts off its holes and copper. See Routers.
  • A project .zip from another machine. Every version, the draft and the conversation arrive as one project. See Exports.
  • A pinned microcontroller. @ on the home page lists five modules with live price and stock. See Projects.
  • A blank project. Its first message builds v001. See Projects.
  • A fork of any version of any project, with its parent recorded. See Versions.
  • Five seed prompts on an empty project, each known to build clean. See Chat.

Design: the model

  • Five backends. Claude Code (the default, on a claude.ai login), Gemini, Claude, Groq and Mercury, chosen with SOLDERMASK_BACKEND or --backend. Token use and cost are recorded. See Design.
  • A designer that looks things up. The Claude Code backend searches the catalogue, reads pin names and checks its design before it answers. Each step shows live, in the build log and on the command line. See Design.
  • A closed JSON schema. The model states intent, never footprints. Its search field says what to buy. Only the Claude Code backend may pin a part number, and only one it looked up. See Design.
  • Pins by function name, never by number. Two-terminal parts use 1 and 2. Modules are kind: module with package FROM_PART. See Design.
  • Priors from real boards. The system prompt ends with block idioms measured on 144 schematics: what gets drawn beside a part. See Design.
  • Current and voltage on nets (current_a, voltage_v). They size the copper and enable Ohm's-law checks. The model leaves a null rather than guessing. See Design.
  • unsupported, assumptions and decisions. What the model could not carry is published as written. A real design fork becomes two or three options, one built. See Design and Chat.
  • Schema relaxation is reported when a backend rejects a keyword. See Design.
  • Conversation turns. A question is answered without a build. A change returns the full revised design, keeping the surviving reference designators. See Chat.

Parts

  • A parametric index. A value part such as 100nF 0603 resolves in 3.6 ms, 99 % correct at the first pick. Text search managed 61 %. See Parts.
  • Part numbers written from memory still match. Punctuation and packaging suffixes are matched on a prefix. See Parts.
  • JLCPCB's catalogue on disk. soldermask setup --parts fetches the 7.25 M-record dump through their Parts API. The jlcparts mirror and jlcsearch are fallbacks. See Parts and CLI.
  • An empty local answer is final. No network call repeats a question the local catalogue already answered. See Parts.
  • The query ladder. It tries the phrase, then the part-number word, the value, a trimmed suffix and a generic term. It checks package fit, pin count and category. See Parts.
  • The ladder's preference order: in stock, category confirmed, pin count confirmed, basic before extended, more stock, lower price. See Parts.
  • An unresolved part is a gap, and an outage is an outage. Neither is reported as a missing part. See Parts.
  • Basic and extended parts. Each extended part adds a $3 setup fee, and the model is asked to prefer basic ones. See Parts.
  • Supported packages. 24 built-in IPC footprints, plus standard-named footprints from the KiCad corpus up to 48 pins. Each has pads, body, courtyard and a 3D profile. See Parts.
  • FROM_PART footprints. A module, radio or radar uses the vendor's own footprint from EasyEDA, cached. Pads over 0.35 mm off nominal are reported. See Parts.
  • Alternates for a part that did not resolve, drawn from parts with the exact same KiCad pinout. One is marked safe only when its rating matches. See Parts.
  • A chosen code is kept. A component carrying lcsc is ordered as chosen and never searched again. See MCP.
  • Datasheet records. A chip's record holds the external parts it requires and its voltage limits. soldermask parts show prints one; parts read and the MCP's read_datasheet read a sheet with two Azure models, opt-in. See Reading a datasheet.

Symbols and pins

  • The KiCad symbol library, 203 libraries vendored and indexed once, turns pin names into pad numbers. See Symbols.
  • Symbol matching by exact name, or by a five-character prefix with a pin count within two. ICs and transistors are matched; passives are positional. See Symbols.
  • Two reported fallbacks. A pinout borrowed from a pin-compatible family, or the part's own EasyEDA symbol. No symbol at all is a gap. See Symbols.
  • Aliases and spellings. VIN, VI and VCC, inversion markers, dashes, decorated vendor names, the datasheet's names and USB-C by position all resolve. See Symbols.
  • A raw pin number is refused on a part with a known pinout, because it cannot be checked. Multi-unit pins are written like A.OUT. See Symbols.
  • Symbol drawings for the schematic come from the same library, with stock symbols for parts that have none. See Symbols.

Checks before anything is placed

  • ERC, from duplicate reference designators to undriven-rail and led-no-resistor. Errors set the exit status; warnings do not. Nothing is silently fixed. See ERC.
  • A design check against the parts' datasheets. A pin over its absolute maximum, an enable tied off, a USB-C port with open CC pins, a diode wired backwards. Its errors are ERC errors. See The design check.
  • Ohm's-law rules. LED current, resistor and regulator dissipation, and capacitor voltage are checked. Each stays silent when the voltage is undeclared, and the notes say so. See ERC.
  • Carrier notes. A net routed narrower than its parts can drive gets a note. One example is a 5.7 A MOSFET on a 0.127 mm track that carries 0.54 A. See ERC.
  • SPICE simulation in ngspice. Rails switch on from zero, and each rail is compared with its declaration. It reports and never fails a board. See Simulation.

Placement

  • Simulated annealing on wirelength, courtyard overlap and an edge pull for connectors. It is seeded, so a board regenerates exactly. See Placement.
  • Six candidates a build. With Lightcycle first, they are ordered by how each one routes; otherwise by the routability model. The full route tries up to three. See Placement.
  • Air between parts. The placer keeps 0.5 mm between courtyards, and pulls ESD and TVS parts to the connector they guard. See Configuration.
  • Pinned parts. A placement can be an input, whole or in part. A pinned part never moves, but it stays in the cost. See Placement.
  • Antenna keepouts from a module's footprint. They are written for the routers and KiCad, and the placer keeps parts out of them on both sides. See Placement.
  • Both sides. Surface-mount parts may go on the back when the front is full. Connectors, switches, LEDs and antennas stay on top. board.sides = 1 forbids it. See Placement.
  • A precedent. A corpus board with the same parts can start one anneal. It is listed on the board with its repository and licence. See Placement.
  • The board is sized to its parts. It grows when they do not fit, and a board the design guessed too big is cut down. board.fixed holds the outline. See When the board is too big.
  • Mounting holes, drilled at the corners when the prompt or board.mounting_holes asks. See Mounting holes.
  • Edges and areas you choose. constraints.edges puts a part at a named edge, and constraints.keepouts keeps an area clear. See Parts at an edge you choose.
  • A physics review on every build. Each part's role is read off its wiring, and loops such as a decoupling capacitor's are measured on the copper. It is advice and never fails a board.
  • A geometry rubric. It grades the reviewer's rules this pipeline can measure, such as decoupling distance and connectors at the edge. See The rubric.

Routing

  • Two routers. Lightcycle goes first by default, and the A* router when a board names it. Both route a generated board at 0.127/0.127 mm. rules.router chooses. See Routers.
  • Lightcycle, this tree's own router. It routes every net at once by negotiated congestion and takes hand-drawn copper. It stops on a fixed amount of work, so a board routes the same on any machine. See Routers.
  • Placing and routing in one loop. Lightcycle routes all six placements at once and ranks them by result. If none routes, three more are annealed and ranked with them. See Routers.
  • Placements raced on a big machine. On 32 cores or more, three placements are routed at once in processes, and the first clean one stops the rest. See Configuration.
  • Retries for a board left short. A finer grid, then three other search settings for a board one or two pins short. A wide net narrows into a pad it cannot end on. See The rule on a grid.
  • Escape stubs. Before Lightcycle routes, each pad its grid cannot end on gets a straight stub of its net. See Configuration.
  • Signals before ground sites. Where the ground vias laid before routing wall a signal in, the board is also routed signals first, and the better pour is kept. See Configuration.
  • Differential pairs laid as pairs. A USB, CAN or other pair runs side by side at a fixed gap, its two sides matched in length. See Differential pairs.
  • The other router when one is missing. If the router named is not installed, the other routes the board and the gaps say so. See Routers.
  • The board's own clearance, read off the closest pad pair, never below the fab's 0.127 mm. One test holds the router rules and the .kicad_pro equal. See Placement and Routers.
  • Track width per net to IPC-2221 from the declared current, never below the board's track (0.127 mm on a generated board). rules.min_track_mm can only widen it. See Placement.
  • Thin, then widened. A board whose wide nets wall each other in is routed again thin, and its tracks are widened back where there is room. See Wide nets that will not fit.
  • A connectivity walk names the pins a net never reaches. The build keeps the least bad of up to three placements. See Placement.
  • Via and width reports. Vias are checked against the current they carry, and wires against their net's width. See Placement and Routers.
  • Exact sizes for the A* router, with no via in a pad. See Routers.
  • A missing router is reported. With neither router installed, the board is placed and not routed, and the gaps say so. See Placement.
  • Deterministic. With Lightcycle, --route-only or Route again on an unchanged version reproduces the copper. A route stopped by its 300 s backstop or 600 s wall is the exception, and the board says so. See CLI.

Copper

  • A ground pour on both outer layers of every board with a ground net. KiCad fills it, and islands are stitched with vias. When it cannot fill, ground is routed and the build says so. See Placement.
  • Four layers on request: signal, a ground plane, signal and signal. SOLDERMASK_PLANES=gnd+power makes the third a power plane. Every surface pad of a plane net gets a via to its plane before routing. See Four layers.
  • A via in an exposed pad. A QFN's or DFN's exposed ground pad gets a via at its centre before routing, so the pour reaches it. Another net's exposed pad gets one when the route leaves it short. See Configuration.
  • Power poured when tracks fail. A board whose copper alone fails is built again with its power nets poured, and the better build is kept. See Power pours.
  • Copper judged for heat. Each narrow run is checked against its net's current. A 20 °C rise is a gap, and 100 °C fails the verdict. See Copper too narrow for its current.
  • The fill KiCad computed is the copper the fab gets. It is read back into the Gerbers, the picture and the page. See Placement.
  • Rounded corners. Each 45° corner becomes a tangent arc, checked against its neighbours. The arcs are real in the .kicad_pcb and the Gerbers. See Placement.
  • Hand copper as a constraint. Lightcycle keeps the tracks you draw and routes around them. The build says which of yours came back. See Placement.
  • KiCad's DRC judges the copper, with zones filled. Cosmetic findings are counted separately, by kind. See Placement.

The verdict and the report

  • One pass rule everywhere, repair.passes(). The CLI's VERDICT, the workbench's go/no-go poll, the evaluator's pass@1 and the MCP's verdict all use it. See CLI and Evaluation.
  • What the rule needs: every part resolved, and every requested net and connection present. It also needs no ERC errors, a full route, clean copper and no track too hot for its current. A check that did not run leaves the board unjudged, not passed. See Evaluation.
  • Four reporting channels. unsupported and assumptions on the design, gaps and notes on the board, all published beside the result. See Caveats.
  • Every stage reports what it could not do, in the CLI, the workbench's chain and the MCP's result. See Pipeline.
  • projects rejudge runs KiCad's DRC again over stored versions. It rewrites a verdict that moved and keeps the first board.json beside it. See CLI.
  • A verdict belongs to its build, not to a fresh DRC, and the page says so. See Projects.

Fab output

  • Gerbers written directly. RS-274X for copper, mask, silkscreen, paste and edge cuts, plus an Excellon drill file. See Fab files.
  • Read back by gerbonara, an independent library, with the result reported. See Fab files.
  • JLCPCB assembly files. A BOM and a CPL in their format, in the Gerbers' millimetres, with Bottom for back parts. See Fab files.
  • Silkscreen drawings. One drawing per part is used by the Gerber, KiCad and the screen. It stays clear of copper by construction. See Fab files.
  • JLCPCB's own table, checked on every board: what the fab will not make or place, and what costs more. See JLCPCB's own table.
  • Datasheet layout rules, checked as advice on every board. See Datasheet layout rules.
  • The maker's mark, placed in the emptiest spot and sized to the board. --no-mark or rules.mark leaves it off. See Fab files.
  • A stackup and a fabrication sheet. The vendor's standard build for the board's layer count, and rows measured off the board under Geometry, Copper, Holes and Assembly. See Fab files.
  • gerbers.zip, the fab package alone, from Export, the version menu, the API or the MCP. See Exports.
  • Stale layers cleared when several boards share an output directory. See Fab files.

KiCad, schematic and 3D

  • A .kicad_pcb in KiCad 7's format, which KiCad 7 to 10 read. It carries LCSC properties, rule areas, the pour and every arc. See KiCad and 3D.
  • A .kicad_sch written from the sheet the workbench draws. It is checked net for net against the design with KiCad's own tools. See KiCad and 3D.
  • A server-side schematic layout. Signals flow left to right, pull-ups sit above and decoupling below, and wires cross nothing. See Workbench.
  • Vendor 3D models for every LCSC part, from EasyEDA. One mesh feeds the viewer and KiCad. A model past 40,000 triangles is drawn as a simple shape in the 3D view, and KiCad still gets it. See KiCad and 3D.
  • kicad-cli as the judge. Its DRC judges every routed board, and without it the verdict is not judged. It also makes a raytraced render, a GLB, and a Gerber plot checked against ours to 0.012 mm. See KiCad and 3D.
  • A .kicad_pro carrying the rule the board was routed at, so KiCad's DRC judges against it. See Placement.

Stock and price

  • Stock at 1, 10, 25 and 100 boards, by exact LCSC code. It includes attrition, price breaks, setup fees and a risk per line. See Stock.
  • catalogue or live, said on the report. By default stock comes from the catalogue on disk. It is live only with SOLDERMASK_PARTS=jlcsearch. See Configuration.
  • Stock headroom as runs, such as 999+×. See Stock.

The app: projects

  • The home page as one plane: ledger, command line, disc and foot. Only the ledger scrolls. See Projects.
  • Facets, filter and sort. All, GO, NO-GO, Unjudged and Examples, with archived projects behind a switch. See Projects.
  • Example boards whose first action is Fork & edit. See Projects.
  • Live build state in the row, from any device, refreshed every 3 s while a job runs. See Projects.
  • The disc. The board's skeleton, its verdict and its versions, with Open, Fork, Export, Rename, Archive and Delete. Deleted projects go to a trash. See Projects.
  • The foot. A chip each for the routers, kicad-cli, the model, the catalogue and running jobs, each saying why it is not green. See Projects.
  • Keyboard: j and k or the arrows, Enter, f, / and Escape. See Projects.
  • About and Benchmarks pages, and this manual at /docs. See App and Benchmarks.

The app: workbench

  • Three views, CU, 3D and SCH. Keys 1, 2 and 3 switch them. See Workbench.
  • The poll. The verdict as one go/no-go pill in the header, with a station for each clause of the pass rule. See The poll.
  • Why. One card a blocker, with only the actions that can clear it. See Why.
  • The command bar. Cmd+K reaches parts, nets, findings, views, layers and versions, and runs a build. See The command bar.
  • Findings on the copper. A reticle marks each DRC error and advisory, and the board flies to the one you pick. See Findings on the copper.
  • An address that is the place. /p/<project>/v004/3d?pick=J1&drawer=cost holds the version, the view, the pick and the drawer tab. Back and Forward walk them. See Workbench.
  • Regions round the board that fold and remember. See Workbench.
  • Editor and Board palettes, a grid, and an active copper layer on Page Up and Page Down. See Workbench.
  • Drag a part and it stays. The move is saved as a pin the placer honours, with net-aware snapping. See Workbench.
  • f flips a part to the back, or says why it must stay on top. See Workbench.
  • The part under the pointer is outlined before you click, and tiny parts get a 12-pixel target. See Workbench.
  • Copper as an object. Click a track to see its net, layer, width and who drew it. Delete yours, or take the router's over. See Workbench.
  • Copper stretches with a moved part, and its nets show their ratsnest. Poured nets have none. See Workbench.
  • Route a track yourself. Press x, then drag or click corners. Add vias and flip corners from the keyboard. See Workbench.
  • The stale bar and Rebuild. Pins save a second after you stop, and only a rebuild makes a version. See Workbench.
  • Layer toggles with counts, net isolation, and a predicted congestion overlay. See Workbench.
  • 3D with vendor models, an orbit, pan and zoom pill, and an axis ball. Back-side parts hang underneath. See Workbench.
  • SCH. Drag a symbol (constraints.sheet) or a wire lane (constraints.wires). No-connect and one-pin nets are marked. See Workbench.
  • Blocks. Circuit fragments found on three or more boards by different people, added by merging nets. See Workbench.
  • Parts palette. JLCPCB stock by number or kind. Choose… offers only pins the build will accept. See Workbench.
  • Proposals. A change is built on the version on screen and shown under an Accept / Discard bar that says what it does. It survives a reload. See Workbench.
  • Remove a part, or several, as a proposal. See Workbench.
  • The build log. One timed row per stage, live, kept with the turn. See Workbench.
  • The scope, an oscilloscope over sim.json with two cursors. See Workbench.
  • The chain. The build as boxes, each with its time and warnings, and Simulate, Place again and Route again. See Workbench.
  • The rack. Nine knobs saved as constraints, and variations as saved sets of them. See Workbench.
  • The inspector and the drawer. The inspector shows the board's checks, Why cards and facts, its findings, or the picked part. The drawer holds the chain, the scope and the cost. See Workbench.
  • The readout. What is under the pointer and what you can do with it, the position and the copper layers. Stock and Sync show only when they want a look. See Workbench.

Chat and turns

  • The thread is the project's record, read from disk, the same on every device. See Chat.
  • A question builds nothing; a change is built. The reply's changes line comes from a diff, not from the model. See Chat.
  • Auto-repair. A build that is not clean goes back to the model once. The revision is kept only if it scores better. See Chat.
  • Decisions as cards under the reply. Clicking one starts the next turn. See Chat.
  • An edit builds on the version on screen, with a banner when that is not the newest. See Chat.
  • Four kinds of row: yours, the reply, a note the app wrote, and a failed turn in red. See Workbench.
  • No model is said plainly in the thread, and design.json import still works. See Chat.

Versions, history and files

  • Numbered versions that never change. One is current, and the next edit builds on it. Restore, label, annotate or fork any of them. See Versions.
  • Diffs computed from design.json, not from the model's description. See Versions.
  • Every file one click away: gerbers.zip, standalone.html, the KiCad files, BOM and CPL, board.svg, the JSON files, models and sim.json. See Exports.
  • Whole-project export and import as one zip. A refused zip names the member it stopped at. See Exports.
  • The app version that built each board is recorded on the version. See Versions.
  • Projects on disk are a readable directory, migrated on read with a backup. See Projects on disk.

Builds, sync and the phone

  • Builds are jobs in a bounded worker pool. Closing the tab does not stop one, and each project builds one at a time. See Builds and sync.
  • Live sync between devices: view, camera, selection, net, quantity and version. The last write wins. See Builds and sync.
  • Phone layout. The board fills the screen, chat and details are sheets, and Tilt orbits as you move the phone. See On your phone.
  • A QR code at startup that opens the app on a phone and logs it in. See On your phone.

The command line

  • soldermask "<prompt>" or --design, with flags for output, seed, router, layers, pour, precedent, mark, quantity, repair, wiring, model and the stages to skip. See CLI.
  • One stage at a time: --place-only, --route-only and --sim-only. A test holds every build to one realise() call. See CLI.
  • The board drawn in the terminal before the verdict: an image in Ghostty, Kitty, WezTerm, Konsole and iTerm2, braille elsewhere. See CLI.
  • VERDICT, then what the board does NOT guarantee, last so it stays on screen. ERC errors set exit status 1. See CLI.
  • setup installs Lightcycle, fetches the KiCad symbols and finds kicad-cli. --parts takes the catalogue, --astar builds the A* router, --check reports. See CLI.
  • parts show | read: a part's datasheet record, from the disk or read now. See CLI.
  • projects list | show | fork | revert | rejudge. See CLI.
  • serve with port, host, TLS or --http, token or --no-auth, --proxy, --workers and --log-file. See CLI.
  • version, release note | show | bump, docs and banner. See CLI.
  • mcp, mcp --tools, mcp --http and mcp keys add | list | revoke. See CLI.
  • learn status | generate | train | report | relabel, plus redraw, crossval, backfill and ablate. See CLI.
  • python -m soldermask.evaluate and python -m soldermask.repair. See CLI.
  • Colour rules: NO_COLOR, FORCE_COLOR, and 24-bit colour where the terminal has it. See CLI.

The HTTP API

  • Everything the pages use: health, app state, changelog, benchmarks and platforms. See API.
  • Projects: list, create, read, patch, delete, fork, export, import, chat and jobs. See API.
  • Constraints: read, write, delete, the sheet, rebuild, variations, route again and simulate. See API.
  • Jobs: status, phase, timed steps and result. See API.
  • Parts and blocks: search stock, resolve pins, add or remove parts, and add blocks. See API.
  • Proposals: propose with a scope, read, accept and reject. See API.
  • Versions: metadata, diff, label, restore, and every file. See API.
  • Trash: list, restore and empty. See API.
  • Live events, a server-sent stream per project. See API.

The MCP server

  • Fourteen tools: status, design_brief, search_parts, pins, read_datasheet, check_design, place, score_placement, precedent, build, rebuild, verdict, drc and projects. No model runs inside, except read_datasheet when the reader is on. See MCP.
  • Answers in lines. search_parts, pins, read_datasheet, place, score_placement and build answer in compact lines, unless the call asks for JSON. See Tools.
  • Every result carries verdict, gaps and notes. See MCP.
  • Bring any stage yourself. A caller can supply its own design, parts, placement, copper and knobs, and is judged the same way. See MCP.
  • Resources: the schemas, the package list, these docs, every version's files and fab.zip. See MCP.
  • Progress notifications per stage, so a client does not time out mid-route. See MCP.
  • --http: Streamable HTTP with bearer keys, one directory per key and one build slot. Keys can be added and revoked while it runs. See MCP.
  • A remote client is told what it cannot have. A precedent under a non-permissive licence is withheld and named. See MCP.
  • A hand-written server speaking three protocol versions, with stdout kept clean. See MCP.

Serving, security and operations

  • Hypercorn with TLS by default: a self-signed LAN certificate, HTTP/2 and graceful shutdown. See Production.
  • An access token, exchanged for a cookie, with a five-strike lockout, --proxy and --no-auth. See Access control.
  • Hardening: CSP with nonces, HSTS, frame and content-type headers, and size limits. See Production.
  • No third-party requests. three.js and the fonts are vendored, so the app works with no internet. See Production.
  • Observability: a timed access log, Server-Timing, /api/health and /about. See Production.
  • Deploy recipes for launchd, systemd and nginx, with backups and upgrades. See Deploying.
  • Routing on a bigger machine. tools/remote_route.sh runs a corpus pass on a spot VM and brings the corpus home. See Remote routing.
  • Everything is an environment variable: home, projects, cache, backend, keys, token, corpus, router and model file. See Configuration.
  • A troubleshooting page for every pill and message. See Troubleshooting.

Repair, the wiring turn and evaluation

  • --repair N sends the findings back as a brief. A dropped part scores worse than an unresolved one, so repair cannot hide a failure. See Repair.
  • The wiring turn (--wire). The model wires the resolved parts against their exact pin names, under a schema where a wrong pin cannot be written. See Repair.
  • soldermask.evaluate. Sixty prompts in four tiers, pass@1 per tier and pooled, with replays from saved designs. See Evaluation.
  • The harness checks itself. A row whose verdict disagrees with its build is refused. See Evaluation.
  • A benchmarks page that computes nothing. Numbers from training day are labelled as such, and corrections stay in place. See Benchmarks.

The corpus and the routability model

  • Every route is kept as a labelled example in .cache/corpus. On 26 Sep 2026 it held 65,158 examples of 15,993 boards. See Routability.
  • learn generate anneals and routes boards for hours. learn train fits the CNN (ISOnet) and two logistic baselines. See CLI and Routability.
  • Eight congestion maps and 24 scalars per placement. See Routability.
  • A calibrated probability with intervals. Between-board and within-board scores are reported separately, and the within-board null is stated. See Routability.
  • A heat head that predicts where copper will crowd, shown as an overlay. See Routability.
  • Each router's labels are kept apart (learn train --router). See Routers.
  • A bank of open-hardware boards, licences recorded, indexed for precedents. See Routability.
  • A swappable model file (SOLDERMASK_ROUTABILITY). It will not rate a poured board, and falls back to an estimate that says so. See Configuration and Placement.

Research instruments (not in the build)

  • The rubric, a geometry grader calibrated against a professional and against 3,021 revision pairs. See The rubric.
  • Mendicant. A placement folded as RNA, and a Physarum mould, as routability instruments. A Rust core is held to the numpy reference. See Physarum.
  • A graph judge (GNN), compared with the CNN on the same boards. See Benchmarks.
  • Router A/B over the whole bank, two routers under one DRC judge. See Routability.
  • Photonics. The fold-ordered placer, judged by a photonic router. See Photonics.
  • Two papers from the corpus, paper/isonet.tex and paper/mendicant.tex. See Research.

What it does not do

A board the pipeline designs is two or four layers and at most 150 mm a side. A board read from a file must be two layers, 150 mm and 120 footprints at most, with no ball grid array. A footprint from the KiCad library has at most 48 pins. A differential pair is laid for an impedance only on four layers, and the fab is not asked to control it. Lengths are matched within a pair, not across nets. Heat is judged only as track temperature rise, and there is no EMI or mechanical check.

ERC reads the netlist, not the copper. The electrical checks are only as good as what the design declared. 3D models are vendor geometry, and stock and price are snapshots. The full list is What is not guaranteed.

On this page