openshape3d

Sketch usability work (September 2026): current implementation status and 42-issue queue. Earlier parity notes contain historical defaults; both annotation visibility switches currently default off (selection-based).

An open-source direct-modeling CAD app for iPad and iPhone, built with SwiftUI, a custom Metal renderer, and a dual geometry kernel: OpenCASCADE (OCCT) for exact B-rep solids, with the MIT-licensed Euclid mesh-CSG library alongside it. See Geometry kernels.

Screenshots

Sketch on a plane or a body face, pull the profile into a solid, then blend the edges — every operation undoable.

Pick a sketch plane	Push/pull to a solid	Fillet the edges

The same tools on iPhone — the contextual bars adapt to compact width.

Ask Claude for a part

On the Mac, you can describe a part in plain English and have Claude model it in OpenShape 3D, check that it will print, and save the STL to Downloads — no CAD experience, no terminal. Switch it on in Settings ▸ AI Assistant and click Add to Claude Desktop…. Step-by-step with screenshots: docs/CLAUDE_DESKTOP_TUTORIAL.md (developers and other assistants: docs/AI_MODELING_SETUP.md).

Getting started

First launch opens a welcome screen; Add Sample Designs puts four editable examples (a motorcycle wheel, a mounting plate, a glass bottle and a plate cam) into a Demos folder in the gallery. It is always available again from the gallery's … menu.

Install Git LFS before cloning. The prebuilt ThirdParty/OCCT.xcframework (the OCCT static libs, ~280 MB) is stored via Git LFS, so the app builds straight after a clone — no local OCCT build needed.

brew install git-lfs      # once per machine
git lfs install
git clone [email protected]:laanlabs/openshape3d.git

If you cloned without LFS and the build fails with "There is no XCFramework found at …/ThirdParty/OCCT.xcframework" (or the .a files are tiny pointer text), run git lfs install && git lfs pull to fetch the real libraries. To rebuild the framework from OCCT source instead, see scripts/build_occt_ios.sh.

Features (v0.5)

• Sketch planes — pick a world plane (XY/YZ/ZX tiles at the origin), tap any planar body face to sketch on it, or pull an offset construction plane off a face (drag the arrow or type the distance; persisted). Re-entering the same plane continues the same sketch item, and the camera animates head-on.
• Sketch tools — Line (with chain continuation and close-the-loop), Rectangle, Circle, Arc (drag the chord, then drag the arc to adjust the bulge), Ellipse, and Polygon (side count in the numeric bar), with endpoint/midpoint/center/vertex + grid snapping. The Apple Pencil draws.
• Sketch editing — tap entities to select, drag endpoints/handles or the entity body to edit (one coalesced undo step per drag), Delete, and Trim: tap a segment to remove the span between its nearest intersections (circles trim to arcs, rectangles explode into lines). A move/rotate gizmo appears on sketch selections (double-tap selects the whole connected chain, Copy chip drags duplicates), and Make Construction / Make Regular toggles dashed reference geometry that is excluded from profile fills and preferred as a revolve axis.
• Constraints & dimensions (2D solver) — a pure-Swift variational solver (Levenberg–Marquardt with a numeric Jacobian, SVD/eigen null-space DOF analysis) behind a ConstraintSolver facade — no C++ dependency. An adaptive Constrain menu applies geometric relations (coincident, horizontal/vertical, parallel, perpendicular, equal length/radius, concentric, midpoint, symmetric, tangent, colinear, and Lock); driving dimensions (length, radius, diameter, angle — with inline arithmetic like 25.4/2) pull the geometry to value. Constraints show as tap-selectable glyphs on the canvas and, with dimensions, list under Constraints in the Items panel — Delete removes either (undoable, re-solves). A conflicting constraint/dimension is refused with a non-blocking message rather than corrupting the sketch. The sketch pill reports its state — green fully defined (0 DOF) or blue under-defined (N DOF) — and dragging an under-defined point solves live as the rest follows. Constraints/dimensions persist with the sketch and survive extrude.
• Text & Project — the Text tool places typed strings as glyph-outline sketch profiles (content/height/font dialog) that fill and extrude like any sketch; the Project tool flattens a tapped body's feature edges onto the active sketch plane as editable, unlinked line entities (the CNC flat-layout workflow).

Architecture

Kernel/       Geometry: profiles, extrude, booleans, STL, feature-edge
              extraction, behind the `KernelOps` facade. Double precision,
              nonisolated (runs off the main actor), fully unit-tested.
Kernel/OCCT/  The B-rep kernel seam: `OCCTBridge` (Obj-C++, the ONLY place
              OCCT's C++ headers are included) and `OCCTKernel` (the Swift
              API the rest of the app calls). See Geometry kernels below.
Model/        DesignDocument (value type), undoable commands, SwiftData
              persistence with a compact binary mesh format ("OS3D").
Rendering/    Custom Metal renderer: MTKView (on-demand drawing), Blinn-Phong
              "CAD look" shading with per-body material factors, procedural
              anti-aliased grid, feature edges with vertex-shader depth bias,
              MSAA 4x, display-mode pipelines (wireframe/x-ray/hidden edges),
              section clip plane, textured image quads, ground blob shadows,
              gizmo overlay pass, turntable camera + animator, offscreen
              thumbnail capture.
Interaction/  Gesture arbitration, CPU ray-cast picking (AABB + Möller–
              Trumbore), gizmo drag math.
Editor/       EditorViewModel — the mode state machine tying UI, kernel, and
              viewport together. The viewport never mutates the model.
UI/           SwiftUI chrome: gallery, tool palette, numeric input, overlays.
Shaders/      Single Shaders.metal + ShaderTypes.h shared with Swift via
              bridging header (one source of truth for uniform layouts).

Rendering conventions: kernel/model math is Double, GPU buffers are Float32. Meshes are welded by (position, normal) so hard edges survive; feature edges come from a 20° dihedral-angle threshold.

Why these choices?

Commercial direct-modeling CAD apps generally pair a licensed proprietary kernel — Siemens Parasolid, say — with a renderer written in-house. A licensed kernel isn't an option for an open-source app, so openshape3d started on an open mesh library (Euclid) behind a kernel facade (KernelOps) that a stronger kernel could replace later. That replacement is now underway: OCCT, the same open-source B-rep kernel several commercial CAD products shipped their early versions on.

Geometry kernels: OCCT + Euclid

Why two kernels

Euclid is a polygon-mesh CSG library: it has no analytic surfaces. A sketched circle is tessellated to a fixed segment count (ProfileDetector.circleSegments = 48) before any solid exists, so "extrude a circle" produced a 48-sided prism, not a cylinder — visibly faceted, and impossible to fillet properly. There is no mesh-side fix; the representation itself has to become exact. That means a B-rep kernel, and the open option is OpenCASCADE (LGPL 2.1 + OCC exception).

Euclid is not being deleted. It stays as the mesh path for ops not yet ported and as the fallback when OCCT can't build or boolean a shape.

How they divide today

Body.brep holds an optional OCCT solid (TopoDS_Shape). When present it is the source of truth: Body.adoptBRep(_:) derives both the render mesh and the CSG (euclid) mesh from the same OCCT tessellation, so what you see and what booleans actually cut can never disagree.

Op	Kernel
Extrude (all profiles; circle → analytic cylinder)	OCCT
Primitives (box / cylinder / sphere)	OCCT
Boolean between two B-rep bodies	OCCT
Revolve, sweep, loft, shell, chamfer/fillet, push-pull, pattern, mirror, split	Euclid
Extrude-into-target boolean; multi-profile extrudes	Euclid
STL import; live drag previews	Euclid

Smooth shading comes from normals evaluated on the analytic surface (BRepAdaptor_Surface D1 → dU×dV), not per-facet — that, plus a size-independent angular deflection, is what makes a cylinder read as round.

Known limitations (honest list)

• Un-ported ops drop the brep. Fillet or shell a cylinder and the result reverts to Euclid-only, so it goes faceted again. Porting fillet (BRepFilletAPI) is the next milestone.
• Circular holes are polygonal — only the outer profile of a circle is analytic.
• The .os3d archive doesn't carry the brep, so export/import degrades to Euclid-only. In-app SwiftData persistence does round-trip it.
• iOS slices only — the xcframework has ios-arm64 + ios-arm64-simulator; macOS/visionOS builds would need slices added.
• STEP/IGES are off. DataExchange + XDE roughly double the static library (18 → 47 toolkits, ~74 → ~140 MB/arch), so they're disabled until a feature needs them — a one-line flip in scripts/build_occt_ios.sh.

Everything B-rep sits behind OCCTKernel.useOCCTAsSourceOfTruth; set it to false to fall back to the pure-Euclid kernel everywhere.

Licensing

OCCT is LGPL 2.1 with the Open CASCADE exception. The app's own code is MIT; OCCT keeps its own license. Shipping requires the usual LGPL obligations — prominent notice, license text, and a route for users to relink the library (the checked-in scripts/build_occt_ios.sh reproduces the exact binary).

Building

First build only — OCCT must be built once. The app links ThirdParty/OCCT.xcframework, which is not checked in (~190 MB build artifact). Build it with the checked-in recipe:

brew install cmake                       # if you don't have it
# OCCT source + an iOS CMake toolchain file, then:
OCCT_SRC=/path/to/OCCT-7_8_1 \
IOS_TOOLCHAIN=/path/to/ios.toolchain.cmake \
scripts/build_occt_ios.sh

It cross-compiles a minimal headless OCCT (modeling only — no visualization, no third-party deps) for device + simulator and assembles the xcframework. Takes a few minutes; you only do it once.

Then open openshape3d.xcodeproj in Xcode 26+ and run the openshape3d scheme on an iPad (or iPhone) simulator or device. The Euclid package resolves automatically.

Sanity-check the kernel on a booted simulator any time with scripts/run_occt_spike.sh (builds a box and an extruded circle, and asserts the circle yields exactly one analytic cylindrical face).

Tests: ⌘U, or

xcodebuild test -project openshape3d.xcodeproj -scheme openshape3d \
  -destination 'platform=iOS Simulator,name=iPad Pro 13-inch (M5)'

Unit tests cover the geometry kernel (bridge/weld, blob serialization, profiles, extrusion conventions, booleans, STL layout) and the OCCT seam (analytic face types, smooth-normal tessellation, B-rep serialization round-trip, transform baking); XCUITests drive the real flows (place → edit → move → sketch → extrude → subtract).

Roadmap

• Offset edge UI (kernel done), section caps + interference highlighting
• Auto-constraining guides, pattern constraint, spline tangency (Phase C tranche 2+); the 2D constraint solver, constraints, dimensions, and sketch states already ship (Phase C tranche 1)
• Parametric history sidebar with editable steps (Phase D)
• B-rep kernel (Phase E) — in progress. OCCT is live for extrude, primitives and booleans (see Geometry kernels); next up are fillet/chamfer on BRepFilletAPI, then shell, revolve/sweep/loft, and STEP/IGES
• Keyboard shortcuts + Command Search, face/edge selection filters
• PBR visualization space (environments, per-face materials, capture)
• Fat-line edge rendering, dark mode viewport theme
• Assembly-style grouping (Items folders), SVG/DXF drawing export

See docs/MODELING_PARITY_GOALS.md for the ordered sketch + solid modeling roadmap (fillet, shell, splines, STEP — with acceptance criteria), docs/PARITY_SPEC.md for the feature-by-feature status audit, and docs/IMPLEMENTATION_PLAN.md for phase sequencing.

License

MIT. openshape3d is an independent project: it is not affiliated with, endorsed by, or derived from any other CAD application. Product names mentioned anywhere in this repository are trademarks of their respective owners and are used only for factual comparison.