Design real CAD parts
just by describing them.

PrintPal's AI CAD Modeler turns your ideas into precise, editable 3D models in seconds — no complex CAD software to learn. Adjust any dimension, preview instantly in your browser, and export production-ready files for printing, Fusion 360, SOLIDWORKS, and beyond.

Open the CAD Modeler View pricing

Renders in your browser Exports real STEP files Pay only for AI turns

printpal.io / tools / 3d-cad-modeler

Chat

M3 corner bracket, 30 mm legs, two countersunk holes per leg

Got it. Bracket envelope 30 × 30 × 4 mm. @feature[corner_holes] ready to reference.

Generated model · 142 lines · openscad · 24.6 ms

3D viewer

M3 corner bracket — parametric OpenSCAD turntable render

30 × 30 × 4 mm

1,824 tris

Built for

Mechanical Engineers Hardware Startups Makerspaces Print Farms Educators OpenSCAD Power Users

Real parametric parts. Real OpenSCAD code.

Every model below is a working OpenSCAD script the agent has generated for real visitors. Open any one of them to keep iterating with chat, tweak the parameters, and export.

Scale model · display

AIM-9 inert scale display replica — parametric OpenSCAD turntable render

9,540 tris

Display replica · inert

AIM-9 display model

Inert exterior scale replica — tapered seeker nose, canard + tail fin sets, rolleron tip housings, and surface detail down to the rivet bands. Every collar, band, and fin is a parameter.

// === AIM-9 inert display model ===
overall_length = 287;
body_diameter  = 12.7;
nose_length    = 34;
rear_fin_chord = 54;
fin_thickness  = 2.0;

// @feature: tapered_seeker_nose
x_frustum(nose_length, body_radius,
          nose_tip_radius, nose_center_x);

// @feature: rear_fin_set
vertical_fin(rear_fin_x_start, rear_fin_chord,
             body_radius, rear_fin_outer_radius,
             fin_thickness, 1);

77 params 649 lines 287 × 63 × 63 mm

Electronics enclosure

Raspberry Pi 5 case — parametric OpenSCAD turntable render

4,210 tris

Enclosure · board-fit

Raspberry Pi 5 case

Vented enclosure sized to the Pi 5 board — standoffs on the 58 × 49 mm hole pattern, cutouts for USB / Ethernet / micro-HDMI / USB-C, and a slot vent bank. Resize the board, the case follows.

// === Raspberry Pi 5 case ===
board_x = 85;   // [60:120]
board_y = 56;   // [40:90]
wall    = 2.4;  // [1.5:0.1:4]
hole_dx = 58;   // Pi mount pattern
hole_dy = 49;

// @feature: board_standoffs
for (sx=[-1,1], sy=[-1,1])
  translate([sx*hole_dx/2, sy*hole_dy/2, floor_th])
    difference() {
      cylinder(h=standoff_h, d=6);
      cylinder(h=standoff_h+1, d=2.4);
    }

23 params 135 lines 91 × 62 × 26 mm

Standard parts · BOSL2

Spur gear with involute teeth — parametric OpenSCAD turntable render

24 teeth · M2

Library · BOSL2 / gears

Spur gear

Real involute teeth via the BOSL2 part library — not a hand-modeled mesh, not a fake glamour-shot gear. One function call generates a manifold solid you can print.

include <BOSL2/std.scad>
include <BOSL2/gears.scad>

// === Spur gear ===
teeth     = 24;  // [12:1:60]
modulus   = 2;   // [1:0.5:4]
thickness = 8;   // [3:1:20]
bore      = 14;  // [4:0.5:20]

// @feature: gear_body
spur_gear(
  mod            = modulus,
  teeth          = teeth,
  thickness      = thickness,
  shaft_diam     = bore,
  pressure_angle = 20,
  backlash       = 0.1
);

6 params 26 lines Ø 52 × 8 mm

Rotating machinery

Backward-curved centrifugal impeller — parametric OpenSCAD turntable render

12 blades

Turbomachinery · swept blades

Centrifugal impeller

Backward-curved impeller — 12 sinusoidally-tapered blades swept from hub to rim, with filleted roots and a through-bore. Pure function-driven geometry, no hand-modeled mesh.

// === Centrifugal impeller ===
blade_count        = 12;  // [4:1:24]
blade_outer_radius = 43;  // [20:60]
blade_sweep_angle  = 45;  // [0:80]
blade_height       = 16;  // [6:30]

// @feature: backward_curved_blade_array
for (i = [0 : blade_count - 1])
  rotate([0, 0, i * 360 / blade_count])
    single_backward_curved_blade();

21 params 265 lines Ø 90 × 28 mm

Generate your own parametric part

Free in-browser rendering and export. AI generations metered as pay-as-you-go credits.

Not a mesh generator. A CAD agent.

Mesh AI is great for figurines. Parametric AI is what you need for parts that have to fit, mount, screw, or print to spec.

Mesh-style 3D generators

Art-first AI — outputs a finished triangle mesh, not a design

Outputs a frozen mesh — change one dimension, regenerate from scratch
No design contract, no review checklist, no parametric handles
Geometry is faceted-only — no true CAD primitives or features
Hard to constrain by dimensions, tolerances, or hole patterns
Great for figurines, miniatures, character models, and display props

That sound like what you need?
Try our 3D Generator — purpose-built for mesh-style models.

AI CAD Modeler

Parametric agent — OpenSCAD-native, engineer-first

Outputs editable OpenSCAD with stable @feature handles
Brief + checklist contract enforced and shown above every generation
Real STEP AP214 export — opens cleanly in Fusion / SOLIDWORKS / Onshape
OpenSCAD WASM in the browser — sub-second iteration loop
Best for mechanical parts, mounts, fixtures, enclosures, printable parts

Drop a sketch. Drop a photo. Get the CAD.

The agent is vision-capable. Hand drawings on graph paper, screenshots from a Google search, photos of a broken bracket on your workbench — anything that shows the shape works.

printpal.io / tools / 3d-cad-modeler · image-to-CAD

Your reference

Hand-drawn reference sketch of a spur gear — Ø70 mm, 24 teeth, Ø14 bore

gear_sketch.jpg 240 KB

Live 3D preview

Generated spur gear — Ø70, 24 teeth — parametric OpenSCAD turntable render

Ø 70 × 8 mm · 24 teeth

matched 4 / 4 features

Read reference image · detected: spur gear, 24 teeth, Ø70 mm OD, Ø14 mm bore, module ≈ 2 mm

Generated parametric gear · involute teeth via BOSL2 · 286 lines · openscad · 0.9 s

After every generation a 4-view technical sheet of your model goes back to the agent automatically — so on the next turn it can compare what it built against your reference and refine without you having to nudge it.

Everything an AI pair-programmer for CAD should have

The interface borrows what Cursor got right for code, then bends it around a 3D viewer and an OpenSCAD compiler.

Chat-driven generation

Plain-English prompts in, fully-parametric OpenSCAD code out. The agent maintains a design brief and a per-turn checklist so you can see what it intended to build.

Stable @feature references

Every named feature gets a // @feature: name tag in the code. Reference them in chat with @feature[name] or click the chip to highlight the geometry in 3D.

Live in-browser render

OpenSCAD compiled to WebAssembly. Every edit re-renders in milliseconds, with no server roundtrip — your code never leaves your machine until you press Generate.

Auto-fix & auto-iterate

Compile errors get silently re-prompted and repaired. When you attach a reference image, a self-critique pass compares the render to your image and refines.

Session history

Every project autosaves. Browse, search, rename, and reload any past session — chat, code, viewer settings, and the design contract all come back exactly as you left them.

Build mode + Code mode

Drag primitives onto a 3D canvas, OR drop into raw OpenSCAD. Switch freely — the agent picks up your hand-edits on the next turn without losing context.

Engineering-grade exports

STL and 3MF for slicers, STEP (real AP214 faceted BRep) for downstream CAD work, OFF for academic tools, and the raw .scad source for OpenSCAD users.

Vision-aware iteration

Drop a sketch, hand drawing, or photo. After each generation, a 4-view sheet of your model goes back to the agent so it can compare against your reference.

Sketch & photo input

Drop in a hand drawing, a photo of an existing part, or a napkin sketch — the vision-capable agent reads it, asks any clarifying questions, and writes the parametric code to match.

The agent iterates and checks its own work.

Tell it what to change. It generates, repairs compile errors silently, measures its output against the brief, and only stops when the part is actually printable. You see what it did, every step.

printpal.io / tools / 3d-cad-modeler · session #482

Turn 1

Stepped shaft, 120 mm long, Ø20–30–20, 1 mm chamfers on both ends, with a top keyway 40 × 6 × 3 mm.

Brief committed. Envelope 120 × 30 × 30 mm, 5 features queued. Building @feature[left_section], @feature[mid_section], @feature[right_section], @feature[keyway], @feature[end_chamfers].

Auto-fix · OpenSCAD compile error on line 84 (missing ;) — repaired silently, regenerating. 1 retry

Generated model · 128 lines · openscad · 1,576 tris · 1.6 s

Brief check · bbox 120.00 × 30.00 × 30.00 mm matches committed envelope ± 0.00 mm

Turn 2 · revision

Make @feature[keyway] 2 mm deeper and shift it 5 mm toward the right end.

Updating @feature[keyway] — depth 3 → 5 mm, start X 40 → 45 mm. Other features unchanged.

Re-rendered · 130 lines · openscad · 1,602 tris · 1.4 s

Validations · manifold ✓ · watertight ✓ · printable wall ≥ 1.6 mm ✓ · keyway clearance ✓

Auto-fix on compile errors

If the generated OpenSCAD doesn't compile, the agent re-prompts itself with the failing program and the error, repairs it, and tries again — bounded loop so a chatty model can't spin forever.

Brief vs reality check

After every render the actual bounding box is compared against the envelope the agent committed to in the brief. You see the diff. The next turn knows about it.

Manifold & printability checks

Watertight check, manifold check, and a minimum wall thickness pass run on every render. Non-printable geometry surfaces as a warning the agent can address in the next turn.

Every generation comes with a design contract.

Before the agent writes a single line of code, it produces a design brief — units, origin, envelope, features, defaults adopted. Then it produces a checklist of what it'll build, item by item. Then it builds it.

After the render, the brief's committed envelope is compared against the actual bounding box. If you said "120 × 30 × 30 mm shaft" and the model came out 122 × 30.4 × 30, you'll see a mismatch warning — and the next turn knows about it.

Brief and checklist render above the generation, never inside it
Bounding-box contract check after every render
Carries forward across follow-up turns automatically

Design Brief

Stepped shaft with keyway

Units: mm; origin at left end center
Envelope: 120 × 30 × 30 mm (X × Y × Z)
Features: 3 stepped sections, 1 mm chamfers, top keyway
Defaults adopted: $fn = 96 for smooth circular shaft

Checklist 5 of 5 done

Define envelope and X-axis frame
Build left Ø20 mm section with chamfer
Build middle Ø30 mm section
Build right Ø20 mm section with chamfer
Cut top keyway 40 × 6 × 3 mm

From idea to STEP file in three steps

No install, no CAD seat. Open a tab and start describing.

Describe the part

Type plain English ("M3 cable clip, 18 mm long, snap-fit"). Optionally drop a sketch or photo. The agent asks clarifying questions only when it has to.

Iterate in the chat

The agent generates editable OpenSCAD, renders it instantly, and shows you the brief + checklist. Refine in plain English ("make the clip 2 mm thicker, add a strain-relief").

Export to your workflow

One click downloads STL or 3MF for your slicer, STEP for Fusion / SOLIDWORKS / Onshape, or the raw SCAD source so you can keep iterating outside the browser.

Every export your downstream needs

Real files. Real schemas. Real STEP — not a renamed STL.

.stl

Binary mesh for slicers

.3mf

Modern slicer-native bundle

.step

AP214 BRep for CAD tools

.off

Text mesh for academic tools

.scad

Raw OpenSCAD source

All exports run client-side via OpenSCAD WebAssembly. Hits no server, costs no credits. The STEP exporter emits proper MANIFOLD_SOLID_BREP entities so files import cleanly into Fusion 360, SOLIDWORKS, Onshape, FreeCAD, NX, and Creo.

Built for parts that have to fit something

If the thing you're making has a hole that needs to clear a specific screw, a face that needs to mate with an existing part, or a slot you'll machine in aluminum next week — this is for you.

Mechanical engineers

Brackets, mounts, jigs, fixtures, sensor housings, motor adapters. Edit dimensions with a slider, then hand the STEP to a machinist or your CAD assembly.

3D printing makers

Parametric printable parts you can re-customize for every print. No more "generate a new STL from scratch every time the screw size changes."

Hardware startups

Skip the week-long CAD bring-up for v0 enclosures, breadboard mounts, and prototype housings. Get to the test fixture today, refine in CAD tomorrow.

Educators & makerspaces

Students describe what they want, see the OpenSCAD that generates it, and learn parametric thinking by tweaking code instead of fighting menus.

OpenSCAD power users

A pair-programmer that knows BOSL2 idioms, manifold backend quirks, and how to write code you'd actually be willing to commit. Auto-fix has your back on compile errors.

Print farms

Customer sends "I need a custom phone mount for X bike, with Y mounting holes" — turn it around in two chat turns and export print-ready 3MF.

Reference features by name. Click them in 3D.

Traditional CAD lets you click a face and address it directly. Mesh AI tools lose that — every edit is "regenerate the whole model from scratch." We bring it back, OpenSCAD-style.

The agent inserts // @feature: name comments above named feature groups. Click the chip to highlight that feature in bright orange in the 3D viewer. Type @feature[name] in chat to reference it across turns — even after the surrounding code has been rewritten.

Features survive regenerations — the name is the contract
Cursor-style autocomplete picker for @feature, @param, @module, @hardware
Click a chip to isolate that feature in the 3D viewer
Cmd-click to pin a highlight that persists across edits

Frequently asked questions

Mirrors the FAQPage JSON-LD above — both source from the same answers.

What's the difference between AI CAD and AI 3D mesh generators?

Mesh AI generators (text-to-3D, image-to-3D) output a static STL — a frozen triangle soup that's great for figurines and props but impossible to edit dimensionally. PrintPal's AI CAD Modeler outputs editable parametric OpenSCAD code. You get a live 3D preview, but you can also change a parameter (wall thickness, hole diameter, length) and the model regenerates. It's the difference between a JPEG and a Photoshop file — both look the same, but only one is editable.

What file formats can I export?

STL (FDM and resin 3D printing), 3MF (modern slicer-friendly with embedded metadata), OFF (text-based mesh for academic tools), STEP (faceted BRep AP214 — imports into Fusion 360, SOLIDWORKS, Onshape, FreeCAD, NX, Creo), and the raw OpenSCAD source so you can keep iterating in any OpenSCAD-compatible toolchain.

Do I need to know OpenSCAD to use this?

No. The whole point of the AI agent is that you describe parts in plain English ("M3 corner bracket, 30 mm legs, two countersunk holes per leg") and it writes the OpenSCAD for you. If you already know OpenSCAD, you can switch to Code Mode and edit directly — the agent will pick up your changes on the next turn.

Is this real STEP, or just an STL with a .step extension?

It's real ISO-10303-21 AP214 STEP — every triangle becomes a planar ADVANCED_FACE bounded by EDGE_CURVEs, wrapped in a MANIFOLD_SOLID_BREP inside a CLOSED_SHELL. The geometry is faceted (not parametric curves), so you won't be able to edit a feature tree in your CAD tool, but you can use it for machining drawings, assembly references, downstream CAD imports, and quoting work. Fusion 360, SOLIDWORKS, Onshape, and FreeCAD all open it cleanly.

How do you bill for AI usage?

Pay-as-you-go via API credits. There's no monthly subscription required, and editing, rendering, exporting, and browsing your session history are always free — those run entirely in your browser. Top up credits when you need them, or enable auto top-up so you never run out mid-project.

Does the 3D preview run on the server?

No. OpenSCAD compiles your code via WebAssembly directly in your browser, so previews are fast, private, and free. Only the AI generation step talks to the network. This also means your code never leaves your machine unless you explicitly send an AI turn.

What's a feature reference (@feature)?

The agent inserts // @feature: snake_case_name comments above named feature groups (a hole pattern, a boss, a chamfer, a bracket arm). You can then type @feature[name] in the chat to refer to it stably across turns ("make @feature[main_bore] 1 mm wider") or click the matching chip above the chat composer to highlight the feature in orange in the 3D viewer. It's the OpenSCAD equivalent of clicking a face in a traditional CAD tool — but it survives across regenerations.

What if the AI generates code that doesn't compile?

The auto-fix loop catches OpenSCAD compile errors and silently re-prompts the model with the error and the failing program, asking it to repair. You don't see anything except a brief "Auto-fixing compile error" card while it works. The loop is bounded so a chatty model can't spin forever.

Can I attach reference images?

Yes. Drop in a photo, sketch, or hand drawing and the vision-capable agent will use it as context. After each generation, a 4-view technical sheet of the current render is sent back automatically so the model can compare its own output against your reference and iterate. Auto-iterate runs a self-critique pass for up to 2 rounds when reference images are attached.

Are my designs saved automatically?

Yes. Every session autosaves to your account once you take a meaningful action (first chat send, first scene change, first code edit). The History drawer in the topbar lets you browse, rename, search, and reload any prior session — chat, code, parameters, viewer settings, and the design brief all come back exactly as you left them.

Who is this for?

Engineers needing one-off mechanical parts (brackets, mounts, jigs, fixtures, enclosures), 3D printing enthusiasts who want PARAMETRIC printable parts they can re-customize, hardware startups prototyping enclosures, makerspaces teaching CAD, and existing OpenSCAD users who want an AI pair-programmer for their scripting work.

Stop generating throwaway STLs.
Start designing parametric CAD.

Open the modeler, describe your part, and you'll have a printable file before you finish your coffee.

Open the CAD Modeler View pricing Read the docs Browse all tools

Free to render and export · Pay only for AI generations · Cancel any time

Design real CAD parts just by describing them.