Board to Molecule

Turn any KiCad, Fusion/EAGLE, or Altium board into an Adom molecule: wings around the board and four corner machine pins, MP1 to MP4, written back in the board's own format.

KiCad .kicad_pcb (7, 8, 9, 10) Fusion / EAGLE .brd Altium .PcbDoc (native OLE2, no Altium needed) Rust single binary, most boards in under 100 ms

The original board never moves: every component, track, via, and pour stays byte-for-byte where it was. The tool replaces the outer outline with a grid-snapped rectangle and adds the four pins, so the workcell can pick, place, and contact the board. Every example below was converted by the CLI and then built into 3D through the real molecule pipeline (service-kicad STEP export, then step2glb molecule mode), and every molecule passed step2glb's anchoring gate.

How it works

Like adom-lbr does for parts, the tool puts one EDA-neutral description in the middle. Each reader turns its board into the same molecule plan (millimeters, Y up, MP1 front-left, counterclockwise from above), and each writer patches that plan back into its own format.

Pins	Grid	Board edge to pin center	Pad / drill	Fusion package	KiCad / Altium footprint
large machine pins, always	32 mm	3 mm	5.2 / 3.45 mm	`MACH_PIN_LRG_SHORT`	`MachinePinLargeShort`

Each pin-to-pin span rounds up to a whole number of 32 mm steps (at least one), so a 10 x 10 mm board becomes 38 x 38 mm and a 35 x 85 mm board becomes 70 x 102 mm. The new outline is centered on the original. Inner cutouts (slots, mounting-hole rings) are kept; the outer outline, including notches in it, becomes the rectangle.

Examples: before and after

Pick a board. The 3D panes are the wiki's own Adom 3D viewer, loading the GLBs from this page; the 2D panes are rendered by the tool. The plan view shows the original outline dashed, the wings hatched, and the pins in gold. The after view is read back from the written file, not drawn from the plan.

Results

Board	Source	Original (mm)	Molecule (mm)	Grid steps	Parts	Convert	Anchored
BMA400 breakout	KiCad	10.4 x 10.4	38.0 x 38.0	1 x 1	13	10 ms	yes
Vimdrones ESC dev board	KiCad	35.0 x 85.0	70.0 x 102.0	2 x 3	95	96 ms	yes
SparkFun Qwiic Button	Fusion / EAGLE	25.4 x 25.4	38.0 x 38.0	1 x 1	48	29 ms	yes
SparkFun RedBoard	Fusion / EAGLE	68.6 x 53.3	102.0 x 70.0	3 x 2	65	315 ms	yes
miniFOC driver	Altium	40.0 x 40.0	70.0 x 70.0	2 x 2	41	144 ms	yes
Elk Pi audio board	Altium	136.2 x 93.7	166.0 x 102.0	5 x 3	440	179 ms	yes

Convert time is read, plan, write, and read back, on one core of a shared container. Anchored is step2glb molecule mode on the GLB built from the written molecule: MP1-MP4 found, board Z-up with MP1 at the origin.

What each lane does

KiCad

Writes the pin footprint in the dialect the board was saved in: KiCad 7 (fp_text, tstamp), 8 (properties, uuid), or 9+ (embedded files). A KiCad 8 board never receives KiCad 9 tokens.
On KiCad 9+ boards the pin STEP is embedded inside the .kicad_pcb (kicad-embed://), so the pins render on any machine, including service-kicad, which only ever sees the board file. Older boards get a 3dmodels/ folder beside the board.
Outer outlines made of lines, arcs, rectangles, polygons, or circles are all recognized; inner cutouts stay.

Fusion / EAGLE

Edits the XML in place: the Dimension-layer outline, a new library, and four elements.
The pins are MACH_PIN_LRG_SHORT copied verbatim from Adom_Library_Master (with their 3D package URNs), so Fusion shows the real pin model and step2glb reads the pin size from the name.
Refuses to run if the board already has parts named MP1 to MP4.

Altium

Reads and writes the binary .PcbDoc directly, no Altium needed. Only the streams it changes are rewritten (outline, board regions, components, pads, texts, wide strings, unique ids); every other stream stays byte-identical.
New pad records are cloned from a plated through-hole pad on the same board, so they match that file's Altium version; record counts in every header are kept consistent.
Reads Altium's embedded STEP models, so the 3D previews show the real component bodies.

Use

adom-wiki pkg install adom/board-to-molecule     # Linux binary + skill; old kicad-to-molecule command kept as a shim

board-to-molecule convert board.kicad_pcb         # or board.brd, board.PcbDoc
board-to-molecule plan board.brd                  # the EDA-neutral plan as JSON, writes nothing
board-to-molecule convert board.PcbDoc --vcut     # add V-cut score lines along the original outline
board-to-molecule showcase board.PcbDoc -o out/   # molecule + SVGs + before/after GLBs (step2glb)
board-to-molecule serve out-dir/                  # the before/after viewer in a Hydrogen webview

Output lands next to the input as <board>.molecule.<ext>. Every convert reads its own output back and fails if the written outline does not match the plan. CLI answers follow the Adom contract: OK: or ERROR: plus a Hint:.

What changed from kicad-to-molecule

This replaces kicad-to-molecule 0.5.0 (Python, KiCad only). The outline and pin placement math carry over unchanged; what is different:

One rule for every board: large machine pins on the 32 mm grid. The old tool picked medium pins on an 8 mm grid for boards up to 60 mm and large pins on a 16 mm grid above that.
Headless 3D export. The old KiCad output referenced the pin model as ${KIPRJMOD}/3dmodels/..., which resolves in desktop KiCad but not on service-kicad, which only sees the board file; a cloud STEP export of the old output had no pins, and step2glb reported molecule_anchored: false. On KiCad 9+ boards the pin STEP is now embedded in the board.
KiCad 8 boards received KiCad 9 tokens (embedded_fonts, a KiCad 9 version stamp inside the footprint). The pin footprint is now written in the board's own dialect.
KiCad 7 boards got contact-sized pads (1.3 / 0.78 and 4.4 / 2.62 mm) instead of machine-pin pads.
Polygon and circle outlines were not stripped, leaving the old outline inside the new one, where KiCad treats it as a cutout.

Limits

The written Altium .PcbDoc files are verified by two independent parsers (one written from KiCad's Altium importer) and KiCad 10 accepts the pin pad record, but they have not yet been opened in Altium Designer itself. Open one and run DRC before relying on it.
Fusion/EAGLE: the four pins are added to the board only. If the board is linked to a schematic, add MP1-MP4 there too (or open the board standalone) so forward/back annotation stays consistent.
The 3D previews for Fusion boards show copper and silkscreen but no component bodies (Fusion keeps package 3D models in the cloud, not in the .brd).
Only the four corner pins; intermediate edge contacts are not added.

Sample boards: KiCad samples from adom-inc/kicad-to-molecule; SparkFun Qwiic Button and RedBoard (CC BY-SA 4.0); HangX-Ma/miniFOC (Apache-2.0); elk-audio/elk-pi-hardware (CC BY-SA 4.0). Each example lists its source.