Meet your
new workbench.

Lathe is a native Mac app for designing hardware with AI. Describe what you want to make, and Lathe drafts the 3D parts, the circuit, the circuit board and the firmware in one project. Then you inspect every detail, change what you want, check it, and export files for the tools and suppliers you already use.

This guide covers everything the app can do today: how projects work, how to talk to the assistant, each workspace, the checks Lathe runs, importing CAD, 3D printing, exports and Git. It also says plainly where the limits are.

One project

Chat, CAD, schematic, PCB, firmware and parts all edit the same structured design.

You stay in control

Every proposed change can be reviewed, applied, rejected and undone.

Local first

Projects are folders on your Mac, with Git built in. There is no project cloud sync.

Real files out

STEP, STL, 3MF, KiCad, Gerbers, firmware source, CSV and more.

Start

Install and sign in

Download Lathe for Mac, open the disk image and drag Lathe to Applications. Lathe updates itself after that.

Mac
Apple silicon. Lathe is tested on macOS 27; macOS 26 is the minimum.
Account
Sign in with Apple or Google. Use the same account you use on this website.
Without an account
Choose Continue without an account on the welcome screen to design, run checks and export locally. Sending a chat message, generating a board or compiling firmware asks you to sign in, and keeps your draft while you do.
Updates
Lathe checks for updates itself. Use Lathe → Check for Updates… to check now.
Welcome tour
A short tour runs on first launch. Replay it any time from Help → Welcome Tour.

Your first project

  1. Create a project. Press ⇧⌘N, give it a name, choose a project type and pick where its folder lives.
  2. Describe the idea. Say what it should do, how big it can be, what it runs on and anything you already know. “A desk thermometer with an OLED screen, USB powered, about the size of a deck of cards” is a good start.
  3. Answer questions. When a choice would change the design, such as battery or USB power, Lathe asks before it builds. Answers are saved to the project's design brief.
  4. Inspect the result. Click an artifact card in the chat, or press ⌘2, to open the assembly, schematic, board or firmware beside the conversation.
  5. Refine. Select an object and ask for a change, or edit it yourself in the inspector. Every change can be undone with ⌘Z.
  6. Check and export. Press ⇧⌘R to run checks, then export from the Build workspace or print with ⌘P.

What a project is on disk

Each new project is a folder, for example Desk Robot/, containing Desk Robot.workbench, a README, a .gitignore and a Git repository on main. The .workbench package holds the whole design: geometry, electronics, firmware, parts, chats, notes and retained files. Save with ⌘S; returning users reopen their last project automatically.

Starter projects

Choose Starter projects… in the sidebar to open a ready-made project as your own copy. The Desktop Assistant example includes an enclosure, electronics and firmware, and works offline. Orbit is a planetary-drive showcase for the CAD workspace.

Lost track of older projects? File → Recover Earlier Projects… scans a folder you choose and brings them back into the sidebar.

Project types

The project type decides which workspaces you see and how the assistant approaches the work. You can change it later from the composer's Project type menu; your design is kept.

3D Design

Parts for 3D printing. A focused CAD canvas with objects, dimensions, export and print. No electronics.

Assembly · Files · Tasks

Full Project

Complete hardware: CAD, a custom PCB, firmware and parts in one place. The default.

Full Build · Assembly · Schematic · PCB · Firmware · Parts · Cart · Build · Files · Tasks

Starter Kit

Prototype on a solderless breadboard with an Arduino Uno or Nano, ESP32 DevKit, or Raspberry Pi 5 or Pico. No soldering, no custom board.

Breadboard · Firmware · Parts · Cart · Build · Files · Tasks

A Full Project gains a Breadboard tab as soon as it has a breadboard prototype. For prototypes and common modules, the assistant prefers a development board on a breadboard. It reserves a custom PCB for compact, enclosed or production designs.

Layouts and navigation

The window has three layouts. Switch between them at any time; nothing is lost.

⌘1 Chat only
The conversation fills the window. Artifact cards open workspaces when you need them.
⌘2 Chat and workspace
Chat on the left, a workspace preview on the right. Use the preview’s dropdown to switch workspaces, or expand it.
⌘3 Workspace only
The full editor with workspace tabs. The assistant floats over the canvas, so you can keep asking without leaving.

The sidebar lists your projects and their chats. A dot next to a chat means it needs you: amber when Lathe is waiting for an answer, red when the last reply failed, or plain when a reply arrived while you were elsewhere. Press ⌘K for the command palette, which reaches every action by name.

The clipboard button in the header opens Design context: the saved requirements, notes, open questions, assumptions, check results and decision history that every chat in the project shares.

Work with Lathe

The assistant

Chat is where most work starts. The assistant reads the current project, uses real tools to build and edit it, and explains what it did. It works on the same design you see, so you can mix asking and editing freely.

Writing a good request

  • Say what done looks like. Size, power source, mounting, what it measures or moves, how it will be made.
  • Point at things. Select an object in the canvas before asking, or type @ to mention a part, a file or imported CAD. The exact selection travels with your message.
  • Give numbers. “Make the wall 2.4 mm” is better than “make the wall thicker”.
  • Attach references. Add up to four project files or images to a message from the composer's file menu.

While it works

Progress
Replies stream in with the steps Lathe is taking. Artifact cards show what was created or changed.
Questions
When a decision matters, Lathe shows a question card. Your answers go into the design brief so later chats know them too.
Queue
Press Return while a reply runs to queue a follow-up. It sends when the current reply finishes. Edit or remove queued messages before they go.
Stop
⌘. stops the reply. Steps that were already saved stay in the project.
Automatic repair
After a reply changes the design, Lathe reruns the supported checks. If something fails, it sends the failures back for up to two repair turns and shows “Fixing N issues automatically”.
Voice
Use dictation in the composer to speak your request.

Finding things

⌘F finds text in the open chat; Return and Shift-Return step through matches. ⇧⌘F searches every chat. In the composer, ↑ and ↓ walk back through what you have sent.

Slash commands

Type / in the composer to see the command menu. Commands are shortcuts for common requests.

/goal <what done looks like>
Lathe keeps taking turns toward the goal until it reports it complete with checks passing, hits a blocker, or uses its 10-turn budget. For example: /goal a printable phone stand with every check passing. Use /goal pause, /goal resume and /goal clear, or /goal alone for its status.
/fix
Fixes every failing check, giving each one the tools that resolve it, then checks again.
/review [focus]
A critical design review against your brief, by severity: blockers, major and minor findings with evidence and fixes. It changes nothing. Add a focus, such as “/review the lid fit”.
/status
Where the project and board stand, from saved results only. Answered locally, without an AI request.

Reviewing changes

Lathe never quietly rewrites your design. Choose how changes land from the approval menu in the composer:

Manual approval
Each change waits for you. Review shows a before-and-after comparison of the CAD, schematic or files, and you choose Apply or Reject.
Auto-approve
Changes that pass validation apply automatically. Everything stays undoable.

Planning. Choose Start planning to work out an approach before anything is built. Lathe drafts a build plan you can revise step by step, then confirm to build from it.

Undo. Applied changes and your own edits share one history. ⌘Z and ⇧⌘Z step through both. If the design moved on while a proposal waited, Lathe marks it out of date and offers to rebuild it against the current revision.

Models and reasoning

Pick the model and reasoning level from the composer. Auto chooses a model for each request and is always available. Which models and levels you can pick depends on your plan.

GPT-6 Luna
Fast, everyday work. Available on every plan.
GPT-6.1 Sol
Complex design work. Plus, Pro and Max.
GPT-6 Astra
Demanding design and reasoning. Pro and Max.
Reasoning
Low, Medium, High and Extra High. Higher levels think longer and use more of your allowance. Lathe raises the default level for a first full design and for repairs; an explicit Low stays Low.

Hide models you don't use in Settings → Models. Your monthly allowance and recent usage are in Settings → Plan & Usage and on your account dashboard.

Workspaces

Full Build

⌥⌘0. The whole product at once: the mechanical assembly and the electronics side by side, shown Together, as CAD or as Electronics. Every part, whether mechanical, electronic, breadboard or firmware, is in one list. Select a part to hide it, edit its dimensions or values in place, open it in its own workspace, or ask Lathe to change it.

Assembly (CAD)

⌥⌘1. The 3D workspace. Parts are real solids built on the Open CASCADE geometry kernel, with named feature histories you can edit numerically.

Moving around

Drag to orbit, Shift-drag to pan, scroll or pinch to zoom. Click the view cube for named views, including exact top, bottom and isometric. Press F to fit. Switch between perspective and orthographic, and set display quality to Low, Medium or High in the toolbar; quality never changes geometry or exports.

Seeing inside

Display
Shaded with edges by default, plus shaded, wireframe and X-ray (X).
Section (S)
Cut through every visible part on a plane you set numerically; flip which side shows.
Dimensions (D)
Overall size of the selection in world coordinates, in your display units.
Measure
Click two points, snapping to vertices, for distance and XYZ deltas.
Explode
Pull an assembly apart to see how it goes together.
Grid and planes
Floor, XY, XZ and YZ reference planes with an adaptive grid.
Estimated temperature
From the Display menu, tint the board, its parts and the enclosure with the thermal estimate.

Editing

  • Click a part or a row in the Objects list to select that exact instance. Hide, isolate or fit it from its menu.
  • Change supported dimensions, placement and material in the inspector (⌥⌘I). Edits are undoable.
  • Color a part or one occurrence with the color picker, hex values or presets. Color is kept in 3MF exports.
  • In an empty assembly, Create enclosure adds an editable body and lid.
  • When the circuit board changes, a fitted enclosure shows Review update to rebuild its standoffs, openings, vents and lid around the new board.

The canvas assistant

In the full workspace the assistant floats over the canvas and knows what you have selected. Drag its handle to any corner or edge and it shrinks to a small circle; click it to bring the composer back with your draft intact.

Schematic

⌥⌘2. A vector schematic of the circuit. Pan, zoom and find symbols. Select a symbol and choose Highlight connections to trace its nets. Drag symbols freely: connectivity is stored separately from wire paths, so nets stay attached. The Checks popover lists electrical findings and points at the net, pin or part each one names.

Lathe's electronics come from a curated starter library of real parts, including ESP32-S3 and RP2040 boards, sensors like the BME280 and MPU-6050, the SSD1306 OLED, the DRV8833 motor driver and the INA219 current monitor. The checks know each part's rules, such as address straps, required capacitors and flyback diodes.

PCB

⌥⌘3. Placement, routing and layers for the custom board. Toggle layers or choose a preset, and see ratsnest airwires for connections still to route.

Generate and check
Lathe generates a routed two-layer board in KiCad on its engineering service and runs design rule (DRC) and electrical rule (ERC) checks against that exact revision. Fabrication files require this check to be current and passing.
Move and reroute
Move a part on a routed board and Lathe reroutes only the affected nets in the background. It applies as its own Undo step.
Thermal view
A steady-state temperature map of both copper layers, with each part’s heat from the electrical budget. Optionally include the enclosure. You can align a thermal camera image or sensor frame to compare with the estimate.
Board card
The project overview shows placement, routing, DRC/ERC counts and whether the board is ready for fabrication.
3D board
The checked board, with its component models, can be placed into the assembly so the enclosure fits around it.

Breadboard

⌥⌘B. For Starter Kit projects, and Full Projects with a prototype. Parts sit on real breadboard holes, and the strip under the cursor is highlighted so you can see what connects.

W
Draw a jumper wire
R
Rotate the selected part
⌫
Delete the selection

Lathe checks the wiring for shorts, 5 V on 3.3 V pins, LEDs without resistors and modules with no power. Parts lists the kit as a shopping list.

Firmware

⌥⌘4. A code editor for the project's firmware, with a file list, search, find and replace, go to line and Quick Open (⌘P). The firmware follows the circuit's pin map, and is flagged for review when the hardware changes.

Boards
Arduino Uno, Arduino Nano (ATmega328), ESP32, ESP32-S3, ESP32-C3 and RP2040 / Raspberry Pi Pico, using the Arduino framework.
Build ⌘B
Compiles the current source in an isolated build service. Compiler errors link straight to the file and line. Open Problems and Output with ⌘J.
Flash
Upload a current, successful build to a board over USB. Lathe verifies the uploaded bytes. Many ESP32 boards need BOOT held while you tap RESET.
Serial monitor
Connect at any baud rate, read timestamped output, send lines and save the log. Print numbers like temp:21.5 to plot them live. Ask Lathe sends recent output to the chat.
Behavior tests
For supported sensor projects, Lathe runs the real firmware against a modeled sensor (present, missing, lost, recovered, bad data and timer rollover) and checks reporting, baud, faults and status LEDs.
Source folder
Save to Folder (⌥⌘S) writes the firmware to a folder you choose, with setup notes, so you can keep working in your own editor.

Parts and Cart

⌥⌘5 Parts is the bill of materials: every component with its quantity, sourcing and recorded price. Unknown prices stay blank instead of becoming zero, and estimates are labeled as estimates. Replace or remove a part through review; Lathe cleans up its connections and keeps quantities.

Component Library (⇧⌘L) is an offline catalog of 18,699 components, browsable by category, with footprints and, for about 9,000 of them, 3D models. The assistant searches the same catalog.

⌥⌘6 Cart turns purchased parts into a shopping list grouped by supplier, with saved product links. Ask “Find these on Amazon” to fill it, then choose Continue on Amazon or open each supplier's page. Lathe never places orders or charges a card.

Build

⌥⌘7. Where a design turns into something you can make.

Checks & exports
Every check, its result and its fix. Each failing check has a one-click Fix, Recheck, Find data or Plan a test. Exports live here too.
Requirement readiness
Your requirements with measurable acceptance criteria, each marked passed, failed, stale or unverified, and milestones from engineering review to physical acceptance.
Build steps
A step-by-step build guide you can print as HTML.
Commissioning
Record real measurements from your prototype, with the instrument and conditions, so they count toward your requirements.
Make it
Order folders for JLCPCB or PCBWay, plus the list of printable parts. See Ordering boards.

Files and Tasks

⌥⌘8 Files gathers everything the project keeps: references you added, imported CAD, exports and every build output. Open a file to see its real contents. Boards, Gerbers and drill files draw their copper and layers; schematics draw symbols and wires; G-code shows toolpaths with a layer slider; STL, OBJ, 3MF, STEP and IGES open in 3D; code, CSV, images, SVG and PDF render natively.

Exports offer Keep a copy in project files, on by default, so every file you hand off stays recoverable. Firmware builds and board checks keep their outputs automatically. Check receipts and pinned libraries are hidden as Build records; show them from the filter menu.

⌥⌘9 Tasks lists every conversation in the project as a task you can come back to. Search, filter by status, rename, mark completed or archive, and browse tasks across all your projects.

Make it real

Checks and analysis

Press ⇧⌘R or choose Design → Run Checks. Results are tied to the exact design revision: when you edit, dependent results become stale until you check again. Use /fix to have Lathe repair failures.

Checks

Electrical rules
Net integrity, pin roles, conflicting outputs, voltage ranges and part-specific rules.
Board rules
KiCad design rule and electrical rule checks on the generated board.
Electrical budget
Per-part loads and regulator dissipation added up against each supply.
Circuit simulation
DC operating points with tolerance corners for a circuit block.
Manufacturing
The board and drill files against a chosen fabricator’s limits.
Assembled product
Ray-casts the fitted enclosure for sensor vents, connector access, mounting posts, lid retention, collisions, thin walls and display windows.

Engineering calculators

Ask in plain language, for example “how long will this run on a 2000 mAh cell?”

Battery life
Average and peak current from a duty cycle, regulator dropout and cell limits.
Structure
Brackets, arms and shelves as beams: stress, safety factor and deflection, including layer direction for printed parts.
Enclosure heat
Wall, air and part temperatures in a sealed box, and whether printed walls will soften.
Board heat
The PCB thermal map described above.
Actuators
Loads, gearing, speed, stall current and duty-cycle torque from stated inputs.
Multirotors
Whether a drone can hover and for how long, from masses and a thrust table.
Joint motion
Clearance through a joint’s range and inertia of the moving parts.

Importing CAD

Bring in parts from other tools with File → Import CAD… (⇧⌘I). Every import shows a review of the geometry, names and dimensions before you apply it, and can be undone. The original file is kept in the project.

STEP
Solids and assemblies, up to 128 distinct solids and 256 placed copies. Becomes editable solid geometry.
IGES
Solids, plus surfaces kept as analytic references. Units come from the file.
3MF
Meshes with their units, components, placements and object colors.
STL and OBJ
Meshes. You choose the units and which axis is up. Multi-file kits import as separate parts.
DXF
2D profiles. Select one and choose Extrude profile… to turn it into an editable solid.

Meshes are reference geometry: you can place, color and print them, and convert them to a faceted solid to add features. Feature history from the original app is not reconstructed. Files can be up to 20 MB each, eight per import.

Desktop CAD add-ins

Lathe connects directly to Autodesk Fusion, Blender, Rhino and SketchUp running on the same Mac.

  1. Open Settings → Connections → Desktop CAD and save the add-in for your app.
  2. Install it in your CAD app (in Fusion: Utilities → Scripts and Add-Ins) and choose Pair with Lathe.
  3. In Lathe choose Pair add-in, select the .lathecad.json connection file it created and enter its eight-digit code. The code works once and expires after ten minutes.
  4. Use Import CAD… → Desktop CAD to browse the open document and import it, or one component, for review.

Using SOLIDWORKS, Inventor, Creo, NX, CATIA or FreeCAD? Export STEP and import it. Onshape import is coming soon.

3D printing

Add your printer once in Settings → Printers and Lathe designs parts to fit its build volume in every project. Then press ⌘P to print the selected part, the enclosure body and lid, or All parts laid out on one plate.

Printer app
Lathe prepares the model and opens your printer’s own app (Bambu Studio, PrusaSlicer, Cura, Creality Print, OrcaSlicer, PreForm and others), where you choose material and start the print.
PrusaLink
Direct printing to Prusa printers. Lathe slices with your saved PrusaSlicer configuration and checks that every move fits the bed before sending.
OctoPrint
For printers connected through an OctoPrint server.
Klipper / Moonraker
For Voron and compatible Creality, ELEGOO and QIDI setups.

Supported brands include Prusa, Bambu Lab, Creality, ELEGOO, Anycubic, Flashforge, UltiMaker, QIDI, Voron and Formlabs. Materials range from PLA, PETG, ABS, ASA and TPU to nylon, polycarbonate, carbon-filled filaments and resin. Prepared layers can be reviewed as a toolpath before you start, and Lathe flags overhang, wall, bridge and layer problems.

Exports

Choose individual files for your next tool, or a review package for a wider handoff. Export from the Build workspace. What is available depends on the content and checks in your project.

3D parts

STEP · .step
Solid parts and preserved analytic surfaces for CAD exchange. Polygon meshes alone cannot be exported as STEP.
3MF · .3mf
Parts, enclosures and lids with millimeter geometry and intended color. Slicer settings are chosen separately.
STL · .stl
Triangle meshes for parts, enclosures and lids. Millimeter geometry; color is not retained.

Electronics

KiCad · .kicad_sch / .kicad_pcb
Editable native schematic and board, with retained libraries and check reports, in the electronics review package. Requires Generate and check for the current project.
JLCPCB / PCBWay order folders
Gerber ZIP, assembly BOM and placement CSV in the board house’s format. Requires a current, passing board check. Lathe does not place the order or verify supplier stock.
Schematic · .svg
A visual snapshot of the schematic’s symbols and wire paths.
Connectivity · .net
Experimental connectivity-only netlist. Matching footprint libraries and separate native import checks are needed.
PCB source folder
Experimental developer handoff with saved project data and footprint source requests. This source-only package has no generated board or completed checks.

Code & parts

Firmware source folder
The project’s source files, preserved in their folder structure. This export is not a compiled or flashed image.
Parts list · .csv
Components, quantities, sourcing and recorded prices. Unknown prices remain empty instead of becoming zero.
Physical wiring · .csv
Net names, exact component instances and documented physical pins.

Project & guide

Lathe package · .workbench
The editable project, including its conversations, notes and firmware files.
Project data · .json
Structured project data for inspection and further processing.
Build guide · .html
A printable guide with recorded steps, sources and physical observations. Review the saved information before building.
Hardware / electronics review folders
Supported current geometry, retained print outputs, firmware and recorded engineering evidence. Native electronics require current passing board checks. Current validated compiler artifacts are included when available; physical qualification remains separate.

Ordering boards

Go to Build → Checks & exports → Make it. With a current, passing board check, Lathe creates an order folder for JLCPCB or PCBWay:

  • a ZIP of Gerber and drill files,
  • an assembly bill of materials,
  • a placement file in the board house's format (JLCPCB CPL or KiCad for PCBWay),
  • and a how-to-order guide.

You upload these to the board house yourself. LCSC part numbers are left blank because Lathe does not verify stock. Review parts, quantities and fabrication options before you order.

Git and GitHub

Every new project is a Git repository. The branch pill in the chat header shows uncommitted changes as added and removed lines. Click it to review diffs, commit, push, pull, fetch, and create or switch branches. The Source Control menu has the same commands.

  1. Connect GitHub in Settings → Connections. Lathe shows a one-time code to approve on GitHub.
  2. Use Source Control → Publish to GitHub… to create a repository for the project.
  3. Open pull requests with Create Pull Request…, and open someone else's project with File → Clone Project….
Reference

Settings

Open with ⌘,.

Profile
Your account, sign-out and account deletion.
Plan & Usage
Your plan, monthly allowance and recent activity.
Models
Which models appear in the picker. Auto is always included.
Appearance
System, Light or Dark, and accent color.
Workspace
Startup behavior, the demo project, the welcome tour and keyboard shortcuts.
Printers
Your printers, their build volumes, connections and the default printer.
Connections
GitHub, desktop CAD add-ins and STEP import from any other CAD app.
Notifications
Optional macOS alerts for finished replies, questions, proposed changes, errors and blocked builds. Off until you turn them on.
Data & Privacy
What leaves your Mac and what Lathe keeps.

Keyboard shortcuts

Projects and chats

⌘NNew chat
⇧⌘NNew project
⌘OOpen project
⌘SSave project
⇧⌘IImport CAD
⌘PPrint (Quick Open in the firmware editor)
⌘,Settings

Chat

⌘LFocus the composer
⌘.Stop generating
⌘FFind in chat
⌘G / ⇧⌘GNext / previous match
⇧⌘FSearch all chats
↑ / ↓Walk through messages you sent (in the composer)
/Open the command menu (in the composer)
@Mention a file, part or object (in the composer)

Layout and navigation

⌘1Chat only
⌘2Chat and workspace
⌘3Workspace only
⌘KCommand palette
⇧⌘BToggle the sidebar
⌥⌘IToggle the inspector
⇧⌘LComponent Library
⌘[ / ⌘]Back / forward

Workspaces

⌥⌘0Full Build
⌥⌘1Assembly
⌥⌘2Schematic
⌥⌘3PCB
⌥⌘BBreadboard
⌥⌘4Firmware
⌥⌘5Parts
⌥⌘6Cart
⌥⌘7Build
⌥⌘8Files
⌥⌘9Tasks

3D canvas

DragOrbit
⇧ + dragPan
Scroll or pinchZoom
FFit the model (also ⌘0)
XX-ray (⇧⌘X x-rays every part)
DShow dimensions
SSection view
escClear selection and show hidden objects

Design, Git and firmware

⇧⌘RRun checks
⌥⌘CCommit
⌥⌘PPush
⌥⌘XPull
⌘BBuild firmware
⌥⇧⌘FSearch firmware
⌥⌘FReplace in file
⌃GGo to line
⌘/Toggle line comment
⌘JProblems and output panel
⌥⌘SSave the firmware source folder

Your data

Projects, conversations and original files stay on your Mac. There is no project cloud sync. When you ask the assistant for something, the message, the relevant design context and any attachments you chose pass through Lathe's service to the AI provider. Board generation, firmware builds and behavior tests send the inputs they need to Lathe's engineering service, which works in a temporary directory and cleans up after each job.

Lathe keeps account information and usage records to run the service and your plan. Read the full privacy policy. Deleting your account does not delete projects from your Mac.

Current limits

Lathe is early. Here is where it stops today, so you can plan around it.

  • Lathe runs on Apple silicon Macs only. Pricing and plan limits are previews until published.
  • Electronics come from a bounded starter library and two-layer boards. General circuit synthesis and routing beyond it are not available yet.
  • Meshes from STL, OBJ, 3MF or the assistant's scripted shapes cannot be exported as STEP. Feature history from other CAD apps is not imported.
  • Constrained sketches and finite-element, transient-thermal or EMC analysis are not included.
  • Onshape import and bringing your own model API keys are coming soon.
  • Fabrication packages need a current, passing board check. Exported files and check reports do not establish physical fit or electrical operation. Review the design and parts before ordering, printing or powering hardware.

Found a problem or have a question? Email support@lathelab.com.