CARTOUCHE Drive — open-source USB 3.2 NVMe drive board

 What is CARTOUCHE?

 CARTOUCHE is a non-profit project: a full AI that runs from a USB key. You plug it into any computer (Windows, macOS

 or Linux), launch it, and chat with an open AI model (Qwen, Gemma...). Everything runs offline: no install, no

 account, no cloud, and your conversations never leave the key. Keys are sold at cost, and every price is published

 line by line on the website.

 Why a custom drive?

 An AI model is several gigabytes, and it has to be read from the key every time it starts. On a normal USB key this is

 the bottleneck: I measured a cheap 16 GB key at 21.7 MB/s, so a 3 GB model takes more than 2 minutes to load. An NVMe

 SSD behind a USB 3.2 Gen 2 bridge should reach about 1 GB/s, so the same model would load in about 3 seconds.

 Commercial NVMe enclosures exist, but I wanted a board I fully understand, that I can adapt to CARTOUCHE's case, and

 that other students can learn from. So I designed one and published everything.

 How it works

 - USB-C in (Molex 105450 receptacle), 5 V from the host.

 - A JMicron JMS583 bridge converts USB 3.2 Gen 2 (10 Gb/s) to PCIe Gen 3 x2 for the SSD.

 - A ZD25WQ16 SPI flash holds the bridge firmware; a 25 MHz crystal clocks the bridge.

 - A TI TPS82130 module (3 A buck) makes 3.3 V for the SSD from VBUS.

 - An M.2 key M socket (LOTES APCI0113) takes a 2230 NVMe SSD, held by an M2 standoff at the far end.

 I'm Arthur, a student from France (near Bordeaux). I love building things that actually work, from code to circuit

 boards, and I learn most of it by doing it.

 CARTOUCHE is my main project. It started from a simple idea: AI shouldn't need an account, a subscription or an

 internet connection. So I built an AI that runs entirely from a USB key:

 - the software runs on Windows, macOS and Linux, with the llama.cpp engine and open models;

 - a tool prepares each key: it formats it, installs the models, checks every file and signs a license tied to that

 key;

 - a website explains everything and publishes the cost of every key line by line, because the project is non-profit.

 The Éclair drive board is the next step: our own open-source hardware, to make models load in seconds instead of

 minutes.

 Before CARTOUCHE, I worked on:

 - a custom dashboard for a small self-built autonomous vehicle;

 - Vif Étincelle, an open-source bilingual decision model for robotics, trained on my own computer;

 - web experiments in React and Three.js, like a 3D autopilot dashboard simulation.

 What I enjoy most is understanding how things work all the way down, then making them simple for everyone else.

 Through CARTOUCHE and its Open AI Lab, I'd like to help other young people get access to AI and see how it's built,

 down to the circuit board.

 Specifications

 - Board: 36 x 46 mm, 4 layers, 1.6 mm, 76 components, designed in KiCad 9

 - Interface: USB-C, USB 3.2 Gen 2 (10 Gb/s); the SSD side is PCIe Gen 3 x2

 - SSD: M.2 2230 NVMe (key M)

 - Expected speed: about 1 GB/s (to be measured on the prototype)

 - License: CERN-OHL-S-2.0 (hardware), MIT (scripts)

 Schematic

 The bridge needs a lot of small parts: decoupling on its 1.0 V core and 3.3 V rails (it makes its own 1.0 V with an

 internal buck and a 4.7 uH inductor), 220 nF AC-coupling capacitors on each PCIe TX line and 100 nF on each USB

 SuperSpeed TX line, 5.1 k CC pull-downs so the host gives 5 V, a 12 k 1 % reference resistor, a reset RC and a status

 LED.

 One mistake caught while checking the schematic: on the M.2 connector, the PET/PER pin names are from the host's point

 of view, so the bridge TX must go to the M.2 "PER" pins. They were swapped in the first version.

 Stack-up and layers

 The board uses JLC's 4-layer stack-up (JLC04161H-7628: 0.21 mm prepreg between the outer layers and the planes).

 - Top: parts and all high-speed pairs, with a ground pour.

 - Inner layer 1: solid ground under every high-speed pair.

 - Inner layer 2: ground, with a 1.0 V island under the bridge for its core supply.

 - Bottom: two power pours, 5 V (VBUS) on the USB side and 3.3 V on the SSD side, split at the regulator.

 About 150 ground stitching vias tie the top pour to the inner planes.

 High-speed routing

 There are 9 differential pairs: 4 USB 3.2 lanes and 5 PCIe pairs (2 TX, 2 RX, reference clock). They are routed as

 short, straight coupled pairs, with nothing else crossing them.

 Two problems to solve:

 - The USB-C receptacle has two rows of pins. To reach the inner row without breaking the pairs, the vias go between

 the two rows, and the pairs that need it run on the bottom layer for a few millimetres.

 - Impedance: the pairs were checked with a small 2D field solver (finite differences, with solder mask,

 tools/impedance.py in the repo), first verified on a known case (50 ohm single-ended at 0.35 mm on this stack-up). USB

 pairs at 0.20 mm wide with 0.10 mm gap give about 86 ohm (target 90 ohm +/-10 %). The PCIe pairs follow the 0.5 mm

 M.2 pin pitch: at 0.20 mm wide they were about 114 ohm, too high, so they were widened to 0.30 mm (0.20 mm gap) for

 about 89 ohm (target 85 ohm +/-15 %).

 The slower signals were autorouted (Freerouting), then the remaining clearance issues were fixed by hand. Final DRC: 0

 unconnected items.

 Mechanical check

 The SSD lies over the board. From the connector drawing, the SSD sits 3.15 mm above the board, and the tallest part

 under it is about 1.5 mm, so there is margin. The standoff hole is exactly 30 mm + 1.75 mm from the connector's

 alignment posts, as the M.2 2230 format requires.

 Files (all on GitHub)

 - KiCad project, schematic PDF, 3D renders

 - Gerbers + drill, BOM with LCSC part numbers, pick-and-place file

 - The scripts used (schematic generation, placement, impedance solver)

 https://github.com/opencorp2030-ctrl/cartouche-eclair-proto

 Current status

 - Design: finished and checked (DRC clean, impedance checked)

 - Fabrication files: ready

 - Prototypes: not built yet. That is the next step.

 - Open points I'll verify on the first boards: LED polarity, SSD standoff height, and the JMS583 firmware (I've asked

 JMicron for samples and the reference firmware).

 What I'll publish after building it

 Real read/write speeds, model loading times compared with a USB key, temperatures, and every problem I find, so the

 next version (and other makers) can learn from it.

---

 Thank you for supporting makers! If PCBWay sponsors this board, I'll share my honest experience with the PCBs and the

 assembly here and in my build log, and credit PCBWay on GitHub and on the CARTOUCHE website.