GraphOrbis CAD Engine
Drawing the world. Professional parametric CAD inside your own application.
Pricing: per concurrent session — Startup $2,400/yr + $18/session · Growth & Growth Plus scale to 1,000 concurrent · see full pricing & PDF ↓
A geometry kernel you embed, not a SaaS you rent
The GraphOrbis CAD Engine is an embeddable, browser-native parametric CAD engine for ISVs, SaaS builders, and enterprise product teams who need professional CAD authoring inside their own applications — without building a geometry kernel from scratch. Sketching with a real constraint solver, parametric solid features with full history regeneration, booleans, mass properties, and industry format I/O (DXF native, DWG via an optional sidecar), all behind a stable session-based REST API and a TypeScript SDK.
Like the rest of the Celestryll enterprise line, you host, brand and control it — the engine runs as your container against your SQL: your users never see GraphOrbis — they see your product with CAD in it. Licensing is per concurrent session, not per named seat, so partners pay for actual workload rather than seat reservations.
Features
Constraint-Solved Sketching
Lines, arcs, and circles governed by geometric constraints and dimensions — with live degrees-of-freedom feedback down to fully constrained.
Parametric Features
Extrude, revolve, patterns, mirror, and body booleans in an editable history tree — change a dimension and the model regenerates.
Format I/O
STL, OBJ, and glTF for meshes, DXF for 2D cutting toolchains, and a versioned native format that round-trips the full parametric model.
Session Licensing Built In
Concurrent-session quotas, idle auto-release, and usage metering are enforced by the engine itself — pricing and enforcement agree.
TypeScript SDK
@graphorbis/sdk mirrors the whole surface with a fluent sketch builder, live model events over WebSocket, and Three.js viewport adapters.
OEM Source Model
.NET 10 source, idempotent SQL in a schema-isolated database, Docker Compose stack, and the standard Celestryll licensing gate.
Architecture
The kernel is sovereign: geometry is validated server-side and streamed to the client as meshes — no pixel streaming, no plugins. The viewport is local: rendering runs on the end-user's GPU in the partner's own UI. The SDK is the product: partners build on a stable, versioned surface while kernel internals evolve underneath.
Try it yourself — live sample apps
Five interactive apps built on the GraphOrbis engine, running entirely in your browser on WebGPU — no install, no login. Configure, skin, and pull each model apart to feel what an embeddable parametric kernel makes possible.
Launch demo ↗
Kitchen Designer
Place & snap cabinets, appliances and counters — then open one up: ten real door styles, crown and light-rail mouldings, stain and topcoat, 32mm drilling bored into the panels, a blow-apart view and a costed breakdown that comes from the very same panel list.
Launch demo ↗
Industrial Workstation
Configure a t-slot workstation from modular framing — assemblies, mates, interference checks and a live BOM, with shop-drawing output.
Launch demo ↗
Outdoor Deck & Pergola
Size a deck, toggle railing and a pergola, then run a sun/shadow study across the boards — composite and cedar skins, board/joist BOM.
Launch demo ↗
Vehicle Configurator
Spec paint, wheels and options on a parametric car body — then spin the turntable, raise the ride height and explode every part.
Launch demo ↗
Engine Builder
Switch between I4 / I6 / V6 / V8 and the whole engine re-generates from parameters — paint the valve covers and explode it into a parts diagram.
Best in a WebGPU browser (Chrome / Edge); falls back to WebGL2. Five different products over one shared render layer — all five run right here, from the same source we build on.
Run the kernel on your own hardware
These demos run the faceted kernel in the browser. The OEM evaluation kit is the same kernel as a server you host: sketching and constraints, extrude/revolve, booleans, patterns, assemblies, 2D drawings, mass properties and STL/OBJ/glTF/SVG/DXF, driven from your own application over REST. The exact ops — fillets, chamfers, shells, STEP — run in a separate OCCT worker that is delivered to partners rather than bundled in the evaluation kit; ask and we will set it up with you.
Request the evaluation kitPricing
Licensed per concurrent session — the month’s peak number of people
modeling at the same instant, not named seats and not the developers who
build your product. A session opens on createSession and auto-releases after
15 minutes idle, so you pay for real workload. Typical utilization runs 40–60% of
seats — session pricing lands 60–75% below per-seat CAD.
- First year base waived — pay only sessions
- Full kernel · STL/OBJ/glTF/DXF I/O
- REST + WebSocket SDK · 48h email support
- Assemblies + constraint-solver API
- STEP pack (exact kernel) · SSO (SAML/OIDC)
- Slack + 8h response · 99.9% SLA · QBR
- Same $24k Growth base — the cost curve stays continuous
- Rate falls $9 · $7 · $5 as concurrency climbs
- Engineered ≤2% of your ARR to 1,000 sessions
- On-prem / private-cloud kernel · source escrow
- SOC 2 package · audit logging · 99.95% SLA
- On-prem $30k setup + $12k/yr maintenance
Growth Plus scales smoothly to 1,000 concurrent sessions
Above Growth’s 200-session cap the base stays $24k and the per-session rate keeps falling — no cliff. Engineered to stay a small, predictable share of your revenue as you grow.
| Peak concurrent sessions | All-in / yr | Blended / session / mo |
|---|---|---|
| 200 — Growth cap | $54,000 | $22.50 |
| 350 | $70,200 | $16.71 |
| 600 | $91,200 | $12.67 |
| 1,000 | $115,200 | $9.60 |
Graduated per-session: 1–100 $14 · 101–200 $11 · 201–350 $9 · 351–600 $7 · 601–1,000 $5. Above 1,000 → Enterprise. Figures illustrative.
Put CAD in your product
GraphOrbis OEM is in early access. Tell us about your application and expected concurrency and we'll map the engine to your integration — evaluation build, session tiers, and onboarding.