Skip to the content
6 layers20.7 × 59 mmBest, the printed circuit board in 3D

Board design as composition: verified chip packages, intent files and generated critical blocks for KiCad, between easy_pcb and ultraroute

Size
20.7 × 59 mm
Copper layers
6
Thickness
1.6 mm
Parts
238
Nets
175
Pads
849
Tracks, vias
4,604, 284
Pours
4
Routed
Yes
KiCad
KiCad 9.0 (file 20241229)
Created
27 Oct 2026
Updated
7 Nov 2026

Overview

Best is an open-source printed circuit board by sequoia-hope, from the sequoia-hope/circuit-composer repository on GitHub, published under the MIT licence. It is a 6-layer board of 20.7 × 59 mm with 238 parts on 175 nets, routed with 4,604 tracks and 284 vias.

It is built around the RP2350A, W25Q16JVUXIQ and 74LVC2G14GW, with the LGS4056HDA, LSM6DS3TR-C and USBLC6-2P6 among its other parts. Its parts include 122 diodes, 54 capacitors, 33 resistors, 10 ICs and 10 transistors. It belongs with the RP2350 boards of this library.

Main components

12

README

README.md

circuit-composer

Board design as composition: chips are ingested once into verified, published packages, and boards are built by combining them. It covers the stage between schematic and routing: constraint definition and physical design planning. The full design is in Circuit Composer — System Spec.md.

It sits between two sibling projects:

  • easy_pcb runs a board from requirements to fab outputs with the pcb-design skill. Its phase-3 classification (design/nets.csv) imports into an intent file, and its worked example, easy2350, is the first annotated board here.
  • ultraroute is the router. It takes this project's output: a KiCad board with critical blocks placed, routed and locked, plus rules and cost grids.

Status

  • Milestone 1, intent schema v0: done. Rust types, a generated JSON Schema, a validator, and one real board annotated by hand (boards/easy2350/) that passes it.

  • Milestone 2, one buck end to end: done, for the RP2350's core regulator, an on-chip buck with an external inductor and capacitors. That covers a generator, fast-tier verifier checks, a comparison against Raspberry Pi's reference layout, and the first package, packages/rp2350 0.1.0, published in this repository.

  • Milestone 3, router integration: done on our side. The constraint compiler, the region check and a routed-board seam check are in place. easy2350, with its blocks locked, was routed by ultraroute and passes every check (boards/easy2350/routed/), with and without ultraroute's --regions reading the compiled regions.

  • Milestone 4, RP2350 package: packages/rp2350 0.2.0. Core-regulator layouts for QFN-60 and QFN-80 on 2 and 4 layers, all beating Raspberry Pi's on the same checker. Crystal, USB, QSPI flash, buttons and decoupling as intent blocks, mined from the design guide and both minimal boards. Pin tables for both variants, 27 cited rules (disputes kept), and the support parts by role. ccomp check package judges any board against the package by role. Both reference boards pass every hard check. easy2350 fails one: its USB pair runs over the +3V3 plane, not ground.

  • Milestone 5, floorplanner and composer: in progress.

    • Composer: ccomp compose builds a board's circuit from package instances, the board's own parts and the nets joining them, with a binding per instance for ccomp check package. Recomposing the RP2350A minimal board (55 nets) and easy2350 (65) reproduces their netlists exactly.
    • Packages: three more, each ingested from its datasheet with cited rules: mcp73831 (LiPo charger), tlv62569 (2 A buck, with a buck intent block) and lsm6dso (IMU); and the bolt earring's chips, as that board wires them: lgs4056h (charger), ncp730 (3.3 V LDO), tps22913 (load switch), usblc6 (USB ESD) and lsm6ds3trc (IMU). And the RP2350 motor controller's (rev A), as that board wires them: eg3113 (one half-bridge phase: the EGmicro gate driver with its BSC030N08NS5 MOSFETs, bootstrap and gate network; the datasheet is Chinese only, quoted in Chinese), ina240 (inline phase current sensing across two 8 mΩ shunts) and lm74700 (ideal diode with its MOSFET, USB VBUS into the motor bus).
    • The bolt earring from blocks: boards/bolt-earring/compose.json composes the whole board from those packages, the RP2350's, and recipes for its power path, power latch, button, long-press BOOTSEL reset, dividers, light sensor and LED zones. It equals the bolt's netlist net for net (192 nets, all 256 parts). loose.json leaves the MCU's pins to the pin solver, which places all 15 connections. The app's Circuit workspace solves and composes it in the browser, with the pins and recipe parameters editable, and the Board workspace floorplans the solved board as well as the drawn one.
    • KiCad output: tools/compose_kicad.py writes the schematic (a box per block, a net label per pin) and the board through easy_pcb's writer. ERC is clean, and the board's pad nets equal the composed nets.
    • Floorplanner: ccomp floorplan places every part by simulated annealing, using pad-to-pad wirelength, courtyard overlap, board area, block cohesion, decoupling hints, rigid generated layouts, connectors flush on an edge facing out, through-hole pads that block both sides, and separations taken from the packages' rules.
      • In easy2350's own outline it finds a legal placement with 13 % less wirelength than the person's (763 mm against 878; KiCad DRC: no courtyard, clearance or short findings), with the parts whose place is part of the design locked where the person put them: the headers, USB-C, SWD, the RP2350 and its core regulator, the buttons and the LEDs.
      • A footprint locked in the board (KiCad's lock) stays put: ccomp floorplan fixes it, and the app reads each part's lock from the board it opens and writes it back when it saves.
      • The demo board is in boards/rp2350-battery/: USB-C, a charger, load sharing, a buck, the RP2350 and an IMU. It composes and floorplans legally at 40 × 32 mm.
      • A rigid layout's tracks and vias keep other parts off them, as its parts do. A part keeps the margin from a side an edge connector sits flush on, and separations rise in weight through the anneal, like overlaps, so the end keeps them.
    • Board intent: ccomp compose --intent writes the composed board's intent file: each package's intent.json in board names (its nets found through their pins, its parts through the binding, blocks and domains named INSTANCE/NAME), nets two packages share merged to the stricter values, then the composition's own intent (board nets no package covers, a default for the rest). KiCad's net names, as compose_kicad.py labels them. The charger and IMU packages carry intent files now; the battery board's validates against its netlist, 42 of 42 nets.
    • Routing composed boards: tools/prepare_route.py gives a placed board its stack-up (4 layers), the fab rules, a net class per net from its intent, planes, a current-width rule where a net's current needs one (IPC-2221), and each rigid block's generated copper, locked. tools/route_board.sh runs it all from the composition through ultraroute to the seam checks. The battery board routes in under a minute with 0 DRC errors, 0 unconnected and 0 region violations on 4 of 4 seeds (boards/rp2350-battery/routed/).
    • Package rules as routing constraints: ccomp compile turns the packages' block constraints into regions: via_count <= 0 into a via rule, unreferenced_length_mm <= 0 into keeping off layers with no ground beside them and off the voids in the ground fill beside the others. Hard constraints are never, soft ones a weighted avoid. ccomp floorplan --intent keeps a length-limited net's pins' box under 0.75 of its limit. Against the rp2350 package the battery board went from 22 fails of 63 (2 hard) to 13 to 15, with no hard fail on any of 4 seeds.
    • Decoupling: prepare_route.py --composed draws and locks each decoupling capacitor's stub to its pin, and the floorplanner leaves room for it: a near hint is measured from the part's pad on that net, and other courtyards across the line to the pin are priced. The battery board's decoupling fails went from 6 to 1 to 3.
    • Off-chip bucks: ccomp gen buck places a divider (rfb_top, rfb_bot, cff roles: FB runs clear of the switch node, the VOUT sense from COUT when it fits), takes the output net from the inductor, can return ground through the plane (gnd_return_vias), and searches behind the switch pin's row (back). The TLV62569's layout (packages/tlv62569/layouts/) measures 3.53 mm² hot loop and 11.05 mm² output loop, and the battery board uses it: package fails 9 to 13 of 63, none hard, on 4 seeds (ultraroute f179fcb, which reads clear_under: other nets' vias keep their plane holes from under a hard over-ground net).
    • Crossings: ccomp floorplan can price crossings between the straight pin lines of the nets a block keeps over ground (planar from the intent, w_cross, off by default). On the battery board it took the QSPI fails from 8.25 to 7.0 on average over four placements, but the crystal's from 1.25 to 3.5 (boards/rp2350-battery/routed/README.md).
    • Not yet: room for every stub beside the chip (8 of 10 fit); the flash's QSPI over ground (soft in the rp2350 package, so the router pays its price); intent for the remaining packages and the recipes; package schematic sheets.
  • Research library: library/ holds 143 cited claims from 41 vendor app notes, datasheets and articles, on five topics:

    • buck layout,
    • half-bridges and motor drivers,
    • crystal oscillators,
    • USB, return paths and decoupling,
    • CAN, connector protection and trace current.

    It is one database with the packages' rules. 17 disputes are kept as linked pairs, one of them against an rp2350 rule. Every quote is checked against its document (library/README.md).

The app (prototype)

app/ is Circuit Composer's own UI, specified in docs/app-spec.md: a Rust core compiled to WASM (app/core, the floorplanner and the board document) and a Svelte page (app/web). It opens a board's floorplan; you drag, rotate and lock parts, and the floorplanner anneals live in a worker in the page, from scratch or refining what is there. The Circuit workspace shows the board as blocks and the nets between them. Shape builds the board's outline: rectangles, circles, slots, polygons and generators (the bolt earring's is the first), each added or cut away, with corner rounding, symmetry, holes, keep-outs and SVG/DXF import; "Use as board outline" hands it to the floorplanner. The geometry is crates/shape, also behind ccomp shape, and a board's shape.json reaches ccomp floorplan when its spec sets no outline. It runs with no server: it opens the example boards that app/examples.sh exports from boards/ into the site. That is also how it runs on GitHub Pages, where the site is the app alone: https://sequoia-hope.github.io/circuit-composer/. Boards are drawn through a placeholder until board-draw, the renderer shared with UltraRoute Studio, lands. AI fills, the terminal and the handoff to UltraRoute need the app's server, which is next.

sh
app/examples.sh     # export boards/ as the app's example boards (committed)
app/build.sh        # core to WASM, page to app/dist/
./serve.sh          # then open /app/dist/ on the project's registered port

URL parameters: board=NAME, view=circuit|board|shape|copper|rules (ws= in older links), embed=1 (for Boardroom's single-window mode: a slim bar of workspaces and, for a project's board, Save, in place of the header; selection is posted to the parent window). On a touchscreen a finger pans the board and two pinch to zoom. With a mouse or a finger, a press on a part selects it, and only a selected, unlocked part moves, once dragged past a few pixels; Esc during a drag puts it back.

Build and run

sh
cargo build --release
ccomp=target/release/ccomp

$ccomp schema -o schema/intent.schema.json             # regenerate the JSON Schema
$ccomp classes                                         # net class presets and block types
$ccomp netlist path/to/board.kicad_sch                 # the netlist as JSON (runs kicad-cli)
$ccomp validate boards/easy2350/intent.json            # pass/fail, findings per net and block
$ccomp resolve boards/easy2350/intent.json             # nets with preset defaults filled in
$ccomp import easy-pcb ../easy_pcb/examples/easy2350/design/nets.csv \
    --board easy2350 --netlist ../easy_pcb/examples/easy2350/hw/easy2350/a/easy2350.kicad_sch \
    -o draft.json                                      # draft intent from easy_pcb

Any command can work on a board in a project instead of being given every path: --project DIR (-C) and --board NAME (-b) fill in the inputs it was not given from the board's files. Boards live under compose/<board>/ in an easy_pcb project and under boards/<board>/ here, each optionally with a board.json naming where its files are (crates/ccomp/src/project.rs). Outputs are still written only with -o.

sh
$ccomp boards                                          # this repository's boards
$ccomp -b rp2350-battery boards                        # one board's files, and which exist
$ccomp -b rp2350-battery compose                       # = compose boards/rp2350-battery/compose.json
$ccomp -C ../my-project floorplan --seed 2             # a project's only board

Milestone 2's tools:

sh
# Fast-tier checks on a buck block, with a picture of what was measured
$ccomp check buck board.kicad_pcb --roles vin=U1.49,sw=U1.48,pgnd=U1.47,fb=U1.50,cin=C6,cout=C7,inductor=L1 --svg block.svg
$ccomp check buck board.kicad_pcb --intent boards/easy2350/intent.json --block core_reg

# Generate the block (parts and copper in the IC's frame); --defaults prints the parameters
$ccomp gen buck board.kicad_pcb --intent boards/easy2350/intent.json --block core_reg -o gen.json

# Generate, apply to a test bench with pcbnew, verify, and run KiCad's DRC
~/.claude/bin/reserve -c 8 -l "buck bench" -- python3 tools/bench_buck.py BOARD ROLES.json OUT_DIR
python3 tools/apply_layout.py BOARD gen.json ROLES.json -o OUT.kicad_pcb [--group NAME] [--fixture]
# A vendor board's own regulator copper (parts, pours, joining tracks and vias) as a layout
python3 tools/extract_layout.py REFERENCE.kicad_pcb ROLES.json -o layout.json --source rp2350a_minimal
python3 tools/compare_buck.py packages/rp2350/layouts/qfn60-4layer/compare.spec.json OUT_DIR

Milestone 4 adds net-level measurements, for interface blocks:

sh
# Pad-to-pad copper paths, track with no ground beside it, nearest decoupling per power pin
$ccomp measure board.kicad_pcb --spec packages/rp2350/reference/rp2350a_minimal/measure.spec.json
python3 tools/kicad_pins.py board.net U1 --rename SWD=SWDIO   # a part's pin table from a netlist

# A board against a package, by role: wiring, block constraints, length limits, part values
$ccomp check package board.kicad_pcb --package packages/rp2350 --binding boards/easy2350/rp2350.binding.json

Composing and floorplanning (milestone 5):

sh
python3 tools/circuit_check.py packages/*/schematic/circuit.*.json --kicad 9   # symbols, footprints, pins
$ccomp compose boards/rp2350-battery/compose.json -o composed.json --intent intent.json   # + the board's intent
python3 tools/compose_kicad.py composed.json OUT_DIR                           # schematic, ERC, board
$ccomp floorplan OUT_DIR/BOARD.kicad_pcb --composed composed.json --spec boards/rp2350-battery/floorplan.json -o placement.json
$ccomp floorplan ... --evaluate PLACED.kicad_pcb                               # score a person's placement
python3 tools/apply_placement.py OUT_DIR/BOARD.kicad_pcb placement.json -o placed.kicad_pcb   # + KiCad DRC
python3 tools/prepare_route.py placed.kicad_pcb --intent intent.json --spec boards/rp2350-battery/floorplan.json \
    --pro OUT_DIR/BOARD.kicad_pro -o ROUTE_IN                                  # stack-up, rules, classes, planes, locked blocks
ULTRAROUTE=PATH tools/route_board.sh rp2350-battery OUT [SEED]                 # all of it, routed and checked

Recomposing an existing board:

sh
$ccomp compose boards/easy2350/compose.json -o composed.json --bindings OUT_DIR   # circuit + bindings
python3 tools/package_circuit.py packages/rp2350 --board qfn60 --variant RP2350A --netlist REF.net --chip U1 --source rp2350a_minimal -o packages/rp2350/schematic/circuit.RP2350A.json
python3 tools/compose_from_netlist.py draft BOARD.net --instance mcu rp2350@0.2.0 RP2350A BINDING.json --keep-designators -o compose.json
python3 tools/compose_from_netlist.py compare BOARD.net composed.json --binding mcu BINDING.json

The research library:

sh
$ccomp library check                                   # ids, sources, links, both sides of each dispute
$ccomp library query --scope circuit=buck --status contested
python3 tools/library_fetch.py && python3 tools/library_quotes.py   # documents, hashes, quotes

Every command prints one JSON result. Exit status: 0 success, 1 the input failed validation, 2 the command could not run.

Layout

PathWhat
crates/intent/The schema types (model.rs), class presets and block types (presets.rs), the KiCad netlist reader, the validator, the easy_pcb importer
crates/ccomp/The command-line harness
crates/pcb/A KiCad board as copper per net (read with ultraroute's kicad-pcb, pinned), geometry, and copper-path search
crates/verify/Fast-tier verifier checks (buck.rs, nets.rs) and SVG drawings of what they measured
crates/floorplan/The floorplanner: simulated annealing over part poses, rigid groups, edges, separations
crates/compose/The composer: package instances, the board's own parts and nets into one circuit, with a binding per instance
crates/library/The research library: cited claims from library/ and every package's rules.json, checked and queried as one database
crates/blockgen/Block generators (buck.rs) and the layout format, in the anchor part's frame
tools/pcbnew-side steps: apply a layout, the test bench, comparisons
library/Claims by circuit class, their sources (URLs and hashes; documents cached, not committed)
packages/<chip>/Published packages: manifest, intent, cited rules, layouts with verify reports
schema/intent.schema.jsonGenerated; a test fails if it is stale
boards/<board>/One annotated board each: intent.json, input/ (netlist snapshot), validate.json
.claude/skills/circuit-composer/The Claude Code skill that drives ccomp

The intent file (v0)

A JSON sidecar keyed by KiCad net names (/GPIO0, +3V3) and reference designators. Every constrained value is {value, strength: hard|soft, weight (soft only), provenance}, and a provenance cites a key of sources with a locator (page, section, timestamp) and a kind: datasheet, expert, simulated, requirement (the board's own budget), or preset.

Net classes are presets over attributes: a class names the attributes a net must state (SWITCH needs voltage and current) and supplies soft defaults for the rest (aggressor strong). A default never satisfies a requirement and can never be hard.

The validator refuses a board until every connected net has intent with its class's required fields, every block has a library type and owns real parts (no part in two blocks), every hard constraint (including must/never region rules and protection paths) has a provenance that resolves to a source, protection-path pads lie on their net, and differential pairs name each other.

Decisions

DecisionWhy
Intent file is JSON (spec open question)The schema is generated as JSON Schema from the Rust types; packages already use intent.json; serde refuses unknown fields, so typos fail loudly
requirement and preset provenance kinds, beyond the spec's datasheet/expert/simulatedBoard budgets (500 mA USB) are the designer's claims, not a datasheet's; presets must be visibly weaker than evidence
max_length net attribute, beyond the spec's tableeasy_pcb's length_limit is enforced today and the router needs it
Regions may be anchored to a partPackage rules ("cut layer 2 under the inductor's LX pad") are stated relative to parts, before placement exists
Boards keep a netlist snapshot in input/Validation is reproducible without the sibling checkout, as ultraroute's jobs/<board>/input/

Milestone 2: the RP2350 core regulator

Checks (crates/verify/src/buck.rs, about 1 s on a whole board). Copper paths are found through tracks, vias and zone fills. Loop areas integrate |winding number|, so a loop that crosses itself counts both lobes; a plain shoelace sum let them cancel and under-reported the reference's output loop by half.

CheckWhat
hot_loop_area_mm2VIN pin → CIN → PGND pin along the copper
output_loop_area_mm2SW pin → inductor → COUT → PGND pin
switch_node_area_mm2All switch-net copper, overlaps counted once
feedback_clearance_mmFeedback path (FB pin to COUT) to switch-node copper, IC pins excluded
switch_node_underlap_mm2Other nets' copper on the layer under the switch node

Generator (crates/blockgen/src/buck.rs). It places CIN, the inductor and COUT on a 0.1 mm grid in four rotations, by beam search:

  1. CIN, kept only where the switch pin can still escape.
  2. The inductor, with a lookahead on the output loop.
  3. COUT.
  4. The feedback run (straight, or one bend).
  5. Ground vias, kept clear of a generated In1.Cu keepout under the switch node.

Runs escape each pin past its tip and neck to pin width before widening. Clearances come from the board's own net classes. No copper may cross under the inductor except on its own pads. The output is in the IC's frame (layout.json), so it transplants onto any board with the same footprint.

Result on a 4-layer test bench (packages/rp2350/layouts/qfn60-4layer/): KiCad DRC clean, 30–80 s on 8 shared cores, and deterministic (a rerun reproduces layout.json byte for byte). Every row below is measured by the same checker:

Hot loopSwitch nodeOutput loopFB clearanceScore*
Raspberry Pi reference (2-layer)1.0642.3532.4520.3653.47
Reference transplanted to 4 layers (easy2350)1.0642.3012.4520.3863.44
Generated1.0251.9042.3430.4153.15

*hot + 0.5 · switch node + 0.5 · output loop, mm². With no prior given, the generator puts CIN and COUT where Raspberry Pi did, both on x = 2.0 mm in the IC's frame. The inductor sits 0.4 mm further in, so its LX pad lands right over the pin-48 run. Caveat: the reference uses copper zones; the generator draws tracks (LX 0.2 mm wide, against the reference's 0.3 mm strip). Some of the smaller switch-node area is narrower copper, and these proxies do not yet price trace resistance or inductance.

Milestone 3: the constraint compiler

Agreed with ultraroute: cost grids are regions, not rasters. ccomp compile writes:

  • routing.json, which the router reads with --regions. It holds polygons in board millimetres, each with per-layer rules on lists of nets (classes are expanded from the intent file), and hard max_lengths. Part-anchored regions are placed on their part. Intent weights in (0, 1] become the router's extra-length multipliers, × 10.
  • A .kicad_dru: the board's own rules kept, plus a marked block of length rules, so KiCad's DRC checks the same limits. A rerun replaces the block only.

Region rules use the router's meanings: must (these nets' copper may not leave the region on its layers), never, avoid and prefer (prices by weight). A rule may target the nets' vias instead of their tracks.

ccomp check regions BOARD --routing routing.json lists copper that breaks a rule. Its tests plant every kind of violation on the package bench. tools/verify_routed.py adds KiCad's DRC (unconnected items, errors, length limits) and the buck metrics. Together they check a routed board's seams.

On easy2350 (inputs pinned to easy_pcb 2d56198 in boards/easy2350/input/): 3 regions, 12 rules and 17 length limits. easy_pcb's released route passes all of it.

Routed by ultraroute (ad79cd7, without --regions for now; see boards/easy2350/routed/): 0 DRC errors and 0 unconnected after a refill. All 17 lengths and 12 region rules hold, and all 232 locked items, the regulator block among them, come back unchanged.

Mining: rp2350-motor-controller

The fabricated rev A of the motor controller (boards/rp2350-motor-controller/), measured with the same checks. Its RP2350B (QFN-80) regulator matches Raspberry Pi's layout within 2 %, but sits over a solid In1.Cu ground plane, which the datasheet asks to be cut away. That is recorded as a datasheet-versus-practice dispute. Its XL7005A 60 V buck has a hot loop 25× the RP2350's. Mining it added asynchronous bucks (a diode role), divider feedback, and plane shielding to the checks.

Its four half-bridges and three phase current-sense amplifiers are measured too (ccomp check half-bridge, ccomp check sense). Bridges A–C have commutation loops of 25.4–25.5 mm², each through its own 2.2 µF ceramic. Bridge D has no ceramic of its own and closes through phase A's, at 91 mm². The INA240s sit under their shunts, with sense loops of 2.7–7.1 mm² and taps within 0.5 mm of the shunt pads.

Its power entries are measured too (ccomp check protection, ccomp check ideal-diode). The USB ESD array sits 15–16 mm from the connector behind two vias, which fails the library's no-via rule. The motor-bus TVS sits behind the input connector, 7 mm of copper away, but a surge entering at the pass-through connector reaches bridge D before it. The LM74700 senses its MOSFET at its pins. The board's firmware asks for a 20 V USB-PD contract at boot, which drives the USB ESD array's 5 V VBUS clamp into conduction; the board's own review assumed 5 V.

Next

  • Rerun the routed check with --regions once ultraroute has it.
  • Milestone 4: the RP2350 package's QFN-80 variant, using the motor controller's regulator as its measured reference.
  • The asynchronous buck in the generator, then a half-bridge generator (milestone 7), measured against the motor controller's bridges.
  • Package: a 2-layer layout, and the transplant tool used in context on a real board, not only on a test bench.
  • Then mine ~/pcb/rp2350-motor-controller for further blocks.

Findings for the sibling projects

  • easy_pcb's nets.csv for easy2350 classified 61 of the 65 connected nets. KiCad's auto-named two-pin nets were missing. Fixed on the easy_pcb side: nets_check.py now fails such nets.

License

MIT, see LICENSE. Packages are MIT too. They cite vendor documents by URL and hash and do not include them. compare/reference.* are this project's measurements and drawings of Raspberry Pi's published minimal-board layout, kept for comparison.

Parts

238
QtyValueFootprintReferences
117WS2816C-1313parts:LED_WS2816C-1313LED1, LED10, LED11, LED100, LED101, LED102, LED103, LED104, LED105, LED106, LED107, LED108, LED109, LED110, LED111, LED112 +101
38100nparts:C_0402_1005MetricC1, C2, C21, C201, C202, C203, C204, C205, C206, C207, C208, C209, C210, C211, C212, C213 +22
710kparts:R_0402_1005MetricR2, R10, R19, R20, R22, R33, R34
710uparts:C_0603_1608MetricC16, C17, C20, C29, C75, C78, C79
61kparts:R_0402_1005MetricR1, R3, R23, R30, R31, R32
6BSS138Wparts:SOT-323_MOSFETQ3, Q5, Q6, Q7, Q9, Q10
5100kparts:R_0402_1005MetricR17, R18, R24, R25, R26
41Mparts:R_0402_1005MetricR11, R12, R21, R29
44.7uparts:C_0402_1005Metric_small_padsC11, C12, C13, C22
34.7kparts:R_0402_1005MetricR14, R15, R27
3TPS22913parts:YZV0004ADADU4, U9, U10
215pparts:C_0402_1005MetricC14, C15
21uparts:C_0402_1005MetricC18, C19
227parts:R_0402_1005MetricR6, R7
25.1kparts:R_0402_1005MetricR4, R5
2CJ2101parts:SOT-323_MOSFETQ2, Q8
110nparts:C_0402_1005MetricC76
112MHzparts:Crystal_SMD_3225-4Pin_3.2x2.5mm_ABM8Y1
118kparts:R_0402_1005MetricR8
11N4007WSparts:D_SOD-323D3
11N4148WSparts:D_SOD-323D5
122kparts:R_0402_1005MetricR16
13.3uHparts:L_pol_2016L1
133parts:R_0402_1005MetricR13
1680kparts:R_0402_1005MetricR28
174LVC2G14parts:SOT-363_SC-70-6U8
1ALS-PT19parts:SENSOR_ALS-PT19Q1
1BAV70Wparts:SOT-323_BAT54SWD4
1BAV99Wparts:SOT-323_BAT54SWD2
1HANGERflame:HANGER_FLAMEH1
1LBSS84WT1Gparts:SOT-323_MOSFETQ4
1LGS4056Hparts:DFN-8-1EP_2x2mm_P0.5mm_EP0.9x1.5mmU2
1LPR302823flame:BAT_PADS_FLAMEBT1
1LSM6DS3TR-Cparts:LGA-14_L3.0-W2.5-P0.50-TLU6
1NCP730-3.3parts:WDFN-6-2x2U3
1PESD5V0S1BLparts:D_SOD-882D6
1PWRparts:SW_B3U-3000PSW2
1RP2350Aflame:RP2350-QFN-60-1EP_7x7_P0.4mm_EP3.4x3.4mmU1
1RUNparts:TestPoint_Pad_1.5x1.5mmTP1
1SWCLKparts:TestPoint_Pad_1.5x1.5mmTP2
1SWDIOparts:TestPoint_Pad_1.5x1.5mmTP3
1USB-Cparts:USB-C_SMD-TYPE-C-31-M-12_1J1
1USBLC6-2P6parts:SOT-666U5
1W25Q16JVUXIQparts:USON-8_L3.0-W2.0-P0.50-BL-EPU7

More from sequoia-hope/circuit-composer

6
  • 2 layersRp2350-matrix, the printed circuit board in 3D

    Rp2350-matrix

    sequoia-hope/circuit-composer

    Board design as composition: verified chip packages, intent files and generated critical blocks for KiCad, between easy_pcb and ultraroute

    135 partsMIT
  • 2 layersRp2350-battery, the printed circuit board in 3D

    Rp2350-battery

    sequoia-hope/circuit-composer

    Board design as composition: verified chip packages, intent files and generated critical blocks for KiCad, between easy_pcb and ultraroute

    60 partsMIT
  • 4 layers30 × 30 mmFixture, the printed circuit board in 3D

    Fixture

    sequoia-hope/circuit-composer

    Board design as composition: verified chip packages, intent files and generated critical blocks for KiCad, between easy_pcb and ultraroute

    7 partsMIT
  • 2 layers52 × 51 mmFixture, the printed circuit board in 3D

    Fixture

    sequoia-hope/circuit-composer

    Board design as composition: verified chip packages, intent files and generated critical blocks for KiCad, between easy_pcb and ultraroute

    4 partsMIT
  • 4 layers21 × 51 mmFixture, the printed circuit board in 3D

    Fixture

    sequoia-hope/circuit-composer

    Board design as composition: verified chip packages, intent files and generated critical blocks for KiCad, between easy_pcb and ultraroute

    4 partsMIT
  • 4 layers52 × 71.5 mmFixture, the printed circuit board in 3D

    Fixture

    sequoia-hope/circuit-composer

    Board design as composition: verified chip packages, intent files and generated critical blocks for KiCad, between easy_pcb and ultraroute

    4 partsMIT

Similar boards

  • 4 layers25.4 × 35.8 mmEarring, the printed circuit board in 3D

    Earring

    sequoia-hope/ultraroute

    PCB autorouting experiments around copperroute: route jobs, leaderboards, board morphing

    167 parts1MIT
  • 2 layers100 × 100 mmRioctrl shiftio, the printed circuit board in 3D

    Rioctrl shiftio

    festlv/rioctrl-hw

    Hardware design for modular CNC controller

    141 parts16CERN-OHL-S-2.0
  • 4 layers15 × 29.2 mmFuimini V2, the printed circuit board in 3D

    Fuimini V2

    Zipra1/Fuimini-V2

    nRF flavoured SlimeVR-compatible trackers. Now with higher volume production in mind!

    62 parts3CERN-OHL-S-2.0
  • 2 layers30 × 30 mmReCamera Gimbal, the printed circuit board in 3D

    ReCamera Gimbal

    Seeed-Studio/OSHW-reCamera-Series

    reCamera is a series of open-source AI cameras.

    123 parts495Apache-2.0
  • 4 layers34 × 45 mmZigbee Air Sensor, the printed circuit board in 3D

    Zigbee Air Sensor

    acha666/Zigbee-Air-Sensor

    Low power air sensor with E-ink screen and ESP32-H2

    89 parts1GPL-3.0
  • 4 layers27.4 × 72.3 mmPower module, the printed circuit board in 3D

    Power module

    tangles-0/cyberdeck-scout

    // #ifndef PINPA0 // #define PINPA0 11 // #endif // #ifndef PINPA1 // #define PINPA1 8 // #endif // #ifndef PINPA2 // #define PINPA2 9 // #endif // #ifndef PINPA3 // #define PINPA3 10 // #endif // #ifndef PINPA4 //…

    129 parts6
  • 4 layers100 × 100 mmHornSystem, the printed circuit board in 3D

    HornSystem

    cristobalcuevas/PCB-Designs

    Projects with Kicad

    233 parts

Questions

How big is the Best PCB?

It measures 20.7 × 59 mm and has 6 copper layers, 1.6 mm thick.

What parts does the Best use?

238 parts, built around the RP2350A, W25Q16JVUXIQ, 74LVC2G14GW and LGS4056HDA. The full list of its parts is on this page, with links to each part's symbol and footprint where PCBKit's library has them.

Where can I download the Best KiCad files?

From the sequoia-hope/circuit-composer repository on GitHub, at the commit this page was made from: the board is boards/flame-earring/routed/best.kicad_pcb and its schematic boards/rp2350-battery/kicad/rp2350-battery.kicad_sch. PCBKit opens the board in the browser, with nothing to install.

Can I use the Best design in my own project?

Its repository publishes it under the MIT licence: you may reuse it on that licence's terms (keep the author's notice, and for a copyleft licence share your changes alike).