Click ○ to set current · double-click a name to rename

Cur	Name	On	Freeze	Lock	Color	Linetype	Lineweight	Objects

autocad.site — AI Generative CAD & MCP Platform

The world's first AI-native CAD platform: 19 Model Context Protocol (MCP) tools for autonomous agents, 3D CSG solid modeling, real-time collaboration, and professional 2D drafting in pure JavaScript.

🤖 Model Context Protocol (MCP) & AI Engine

19 dedicated MCP tools for Claude Desktop, Google Antigravity, Cursor, and Windsurf agents.
Procedural JavaScript Sandbox (cad_execute_script) for drafting 10,000+ entities with zero token exhaustion.
Parametric generators: structural grids, trusses, mechanical flanges, gears, and architectural floorplans.
In-browser AI Web Bridge (window.CAD) and URL parameter deep-linking (?sample=mosque, ?cmd=...).

🧊 3D Solid Modeling & 3D Printing

Parametric CSG 3D solids: BOX, CYLINDER, SPHERE, EXTRUDE, REVOLVE, UNION, SUBTRACT, INTERSECT, MASSPROP.
Interactive 3D Orbit view with wireframe and shaded rendering.
Direct binary and ASCII STL export for 3D printing slicing.
Multi-plane 3D geometry: 3DPOLY, UCS alignment, and 14 camera projections.

🌐 Cloudflare D1 Real-Time Collaboration

Instant one-click online sharing with persistent live view and edit URLs.
Non-destructive multi-user collaborative sync: draw orders and text updates merge in real time without page reload.
Zero-server footprint: SQLite edge storage via Cloudflare D1 and Workers.
Configurable link expiration (1, 7, 30 days or permanent).

📐 Geometric Drafting Engine

Lines, Bulge Polylines, Circles (2P/3P/Radius), Arcs (3P/Center), Ellipses, Rectangles, Regular Polygons.
Associative Hatching (Internal point picking & boundary detection loops) and gradient fills.
Multiline Text (MTEXT) and Single-Line Text with custom text styles and formatting.
Linear, Aligned, Radius, Diameter, Angular & Ordinate Dimensions.

⌨️ Command Line (AutoCAD-compatible)

Full command interpreter supporting 900+ standard AutoCAD commands & aliases.
Direct distance entry, polar tracking, and interactive ortho mode (F8/F10).
Snapping: Endpoint, Midpoint, Center, Intersection, Perpendicular, Tangent, Nearest.
Interactive tools: TRIM, EXTEND, OFFSET, FILLET, CHAMFER, ARRAY, STRETCH, MIRROR.

📁 File Interchange & Multi-Space

Full ASCII DXF export & import (AutoCAD 2000 AC1015 format compatible).
High-fidelity SVG vector plotting at true engineering scales.
Model Space & Paper-Space Layouts with scale-accurate Viewports (MVIEW / VPSCALE).
Block definitions (BLOCK), attribute tags (ATTDEF/ATTRIB), and CSV reports.

Creator: Ahmd Abyd (blackmoon)

Contact: [email protected]

License: MIT • Open Source for the Global CAD & JavaScript Community

GitHub Repo

🤖

AutoCAD.site Generative CAD MCP Server & Browser Bridge

Empowers AI Agents (Anthropic Claude, Cursor, Windsurf, Google Antigravity, BrowserOS) to programmatically compose, calculate, and stream massive 2D/3D CAD engineering drawings with 0 token exhaustion.

✓ Official Anthropic Registry (Active) 📦 npm v0.2.1 ⚡ Smithery.ai Verified 🌐 Glama.ai Listed

🚀 Why MCP & Generative CAD?

Traditional AI interactions with CAD suffer from a severe limitation: outputting 10,000 raw drawing coordinates via text prompts exhausts LLM context windows, costs hundreds of thousands of tokens, and is painfully slow. The JsCAD CAD Engine MCP Server eliminates this bottleneck by giving AI models programmatic CAD drafting tools and an isolated JavaScript execution sandbox.

⚡ Key Superpowers for AI Agents

Procedural Code Sandbox (cad_execute_script): AI writes high-speed JavaScript generator loops. 50,000 entities are calculated and rendered in milliseconds inside an isolated Node permission-checked process.
High-Level Parametric Generators (cad_generate_parametric): Built-in instant generators for structural column grids, roof trusses, machine flanges with bolt circles, involute gear teeth, and multi-room floor plans.
Real AutoCAD Command Pipeline (cad_run_commands): Executes authentic AutoCAD command strings (e.g. LINE 0,0 100,0; CHPROP ALL; LA WALLS C red) with Quick Select filters and full problem reporting.
Bi-Directional DXF & SVG Plotting: Imports and exports full AutoCAD 2000 (AC1015) ASCII DXF with layers, linetypes, colors, and blocks, plus instant vector SVG visual verification.
Cloud Collaboration (cad_share_drawing): Shares active sessions to Cloudflare D1 with live view & edit URLs for real-time human-agent co-designing.

🏗️ System Architecture

+--------------------------+         +-------------------------------+
| AI Agents (Claude /      |         | Browser CAD Workspace (JsCAD) |
| Antigravity / Cursor)    |         | https://autocad.site          |
+--------------------------+         +-------------------------------+
       |                                             ^
       | stdio JSON-RPC                              | Live Hash / WebSocket / BroadcastChannel
       v                                             v
+--------------------------+  Cloudflare D1  +-------------------------------+
| CAD Engine MCP Server    | <=============> | CAD Web Bridge (window.CAD)   |
| (mcp-server/index.js)    |   Share & Sync  | URL params (?cmd=, ?sample=)  |
+--------------------------+                 +-------------------------------+
       |
       +---> Node Permission Sandbox (cad_execute_script)
       +---> Parametric Geometry Generators (Truss, Grid, Flange, Gear)
       +---> AC1015 DXF Importer & Exporter / SVG Vectorizer

🛠️ Complete MCP Tool Inventory (19 Tools)

Every tool is available over JSON-RPC via stdio to any MCP-compliant client:

Tool Name	Description	Key Parameters
`cad_new_drawing`	Initializes or resets drawing space, filename, and engineering units.	`name`, `units`
`cad_add_layers`	Creates layers with standard AutoCAD ACI colors, linetypes, and lineweights.	`layers: [{ name, color, linetype, lineweight }]`
`cad_batch_add_entities`	High-speed bulk insertion of primitives without command line overhead.	`entities: [ { type, ...props } ]`
`cad_generate_parametric`	Algorithmic generators for complex engineering assemblies.	`type`: `structural_grid`, `truss`, `mechanical_flange`, `gear`, `architectural_floorplan`
`cad_run_commands`	Runs native AutoCAD command-line strings with optional Quick Select filtering. Supports 2D drafting and 3D solid modeling commands.	`commands: "LINE 0,0 100,0; ZOOM E"`, `select: {...}`
`cad_list_commands`	Searches and lists all implemented CAD commands, aliases, and descriptions.	`filter: "layer"`
`cad_execute_script`	Runs procedural JavaScript generator loops in an isolated Node sandbox. Supports `solid(recipe)` helper for 3D solids.	`code: "for(let i=0; i<100; i++) ..."`
`cad_create_block`	Defines reusable Blocks with geometry and dynamic `ATTDEF` tags.	`name`, `basePoint`, `entities`
`cad_insert_block`	Inserts block references with position, scale, rotation, and attribute values.	`name`, `position`, `scale`, `rotation`, `attributes`
`cad_open_dxf`	Opens an existing ASCII DXF (AutoCAD R12 to 2018+) into the active session.	`filename: "drawing.dxf"`
`cad_export_dxf`	Exports AutoCAD 2000 (AC1015) compliant ASCII DXF with symbol tables and polyface mesh representation of 3D solids.	`filename: "output.dxf"`
`cad_export_svg`	Renders high-fidelity vector SVG preview for visual agent inspection.	`filename: "preview.svg"`, `width`, `height`
`cad_export_stl`	Exports closed 3D solids to binary or ASCII STL for 3D printing.	`filePath: "part.stl"`, `binary`, `ids`, `scale`
`cad_solids`	Inspects 3D solids: list, measure (volume, area, centroid), or manifold check.	`action: "list"\|"measure"\|"check"`, `ids`, `limit`, `from`
`cad_get_stats`	Inspects drawing metrics: entity count, layer distribution, bounds, solid count, and volume.	None
`cad_share_drawing`	Uploads drawing to Cloudflare D1; returns real-time view & edit URLs.	`name`, `expiresDays: 7`
`cad_open_shared`	Fetches and loads a shared cloud drawing by ID or URL into the session.	`urlOrId: "https://autocad.site/?share=..."`
`cad_update_shared` / `cad_revoke_shared`	Updates or revokes shared drawings using editToken / ownerToken.	`id`, `token`

📐 Supported Entity Types for `cad_batch_add_entities`

AI agents can insert any AutoCAD entity with exact coordinates, layer assignment, and styling:

// Batch entity definitions supported by cad_batch_add_entities:
{ "type": "LINE", "start": [0, 0], "end": [100, 50], "layer": "WALLS", "color": "red" }
{ "type": "CIRCLE", "center": [50, 50], "radius": 25, "layer": "EQUIPMENT" }
{ "type": "ARC", "center": [0, 0], "radius": 30, "startAngle": 0, "endAngle": 90 }
{ "type": "LWPOLYLINE", "vertices": [[0,0], [100,0], [100,50], [0,50]], "closed": true, "width": 2 }
{ "type": "ELLIPSE", "center": [50, 50], "majorAxis": [40, 0], "ratio": 0.5 }
{ "type": "TEXT", "text": "ROOM 101", "position": [10, 10], "height": 3.5, "rotation": 0 }
{ "type": "MTEXT", "text": "Notes:\\P1. Exact dimensions.\\P2. Verified.", "position": [10, 30], "height": 3.0 }
{ "type": "DIMENSION", "subType": "linear", "p1": [0, 0], "p2": [100, 0], "dimLine": [50, 15] }
{ "type": "HATCH", "pattern": "ANSI31", "scale": 1.0, "loops": [[[0,0], [50,0], [50,50], [0,50]]] }
{ "type": "INSERT", "blockName": "DOOR_900", "position": [20, 0], "scale": [1, 1], "rotation": 0 }
{ "type": "XLINE", "base": [0, 0], "dir": [1, 0] }
{ "type": "RAY", "base": [0, 0], "dir": [0.707, 0.707] }
{ "type": "DONUT", "center": [0, 0], "insideRadius": 5, "outsideRadius": 10 }
{ "type": "SPLINE", "controlPoints": [[0,0], [20,50], [60,20], [100,80]], "degree": 3 }

🕌 Agent Masterclass: 3D Architectural Master Planning (Grand Mosque)

How AI Agents orchestrate massive multi-plane, multi-elevation 3D CAD drawings via the project MCP server without context token exhaustion.

3D Axonometric Isometric View (SWISO)

Master Architectural Ground Plan (Top View)

📖 The 5 Step Architecture for AI Agents

Step 1 — Space & Layers Initialization: Call cad_new_drawing with the drawing name, followed by cad_add_layers with architectural colors, linetypes (e.g. Center for grid), and lineweights.
Step 2 — True 3D Entity Batching: Use cad_batch_add_entities. Points for LINE and POLYLINE3D take { x, y, z } directly. Circular entities and text take plane: { o, x, y, z } or normal: [x,y,z] and elevation z.
Step 3 — Procedural 3D Arches & Spires: Never stream 10,000 raw text lines. Use loops for the 16 meridian arches curving to the dome apex ($Z = +54\text{m}$) and the 100m minaret's dual cantilevered balconies.
Step 4 — Hybrid 3D Solids: Call cad_run_commands with authentic AutoCAD solid commands (BOX 40,90,0 6,6 24, CYL 60,110,20 18 4, SPHERE 60,110,36 18) to combine wireframes with watertight volumetric solids.
Step 5 — Multi-View SVG & DXF Verification: Rotate camera with cad_run_commands: "VIEW SWISO" and export vector SVG with cad_export_svg, then export production AutoCAD 2000 DXF via cad_export_dxf.

💻 Reusable Agent JSON-RPC Recipe

// 1. Initialize Drawing & Layers
{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"cad_new_drawing","arguments":{"name":"Grand_Mosque_3D.dwg"}}}
{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"cad_add_layers","arguments":{"layers":[{"name":"WALLS","color":"#00ffff"},{"name":"DOME_3D","color":"#ffaa00"},{"name":"MINARET_3D","color":"#ff7700"},{"name":"CARPET_HATCH","color":"#2d5a3f"}]}}}

// 2. Batch Add Multi-Plane Entities (3D Polylines, Circles, Hatches)
{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"cad_batch_add_entities","arguments":{"entities":[
  {"type":"POLYLINE3D","points":[{"x":60,"y":128,"z":24},{"x":60,"y":120,"z":45},{"x":60,"y":110,"z":54}],"layer":"DOME_3D"},
  {"type":"HATCH","pattern":"ANSI31","scale":2.5,"loops":[[{"x":4,"y":64},{"x":116,"y":64},{"x":116,"y":156},{"x":4,"y":156}]],"layer":"CARPET_HATCH"},
  {"type":"DIMENSION","dimType":"linear","p1":{"x":0,"y":0},"p2":{"x":120,"y":0},"textPos":{"x":60,"y":-16},"textSize":2.5}
]}}}

// 3. Add 3D Solids, Switch Camera & Export SVG
{"jsonrpc":"2.0","id":4,"method":"tools/call","params":{"name":"cad_run_commands","arguments":{"commands":"CYL 60,110,20 18 4; SPHERE 60,110,36 18; VIEW SWISO"}}}
{"jsonrpc":"2.0","id":5,"method":"tools/call","params":{"name":"cad_export_svg","arguments":{"filePath":"plans/mosque-axonometric.svg","background":"#0b1120"}}}

🌐 Direct In-Browser AI Bridge

For AI browser subagents (like BrowserOS Neo, Puppeteer, Playwright) or in-page automation scripts, JsCAD exposes zero-refresh programmatic control without requiring a local Node process:

1. In-Page JavaScript API (`window.CAD`)

Complete programmatic control via the browser developer console or agent execution:

// 1. Execute AutoCAD commands or procedural scripts:
window.CAD.execute('LINE 0,0 200,0; CIRCLE 100,50 35; ZOOM E');

// 2. Document & canvas lifecycle:
window.CAD.newDrawing('Office_Layout.dwg');
window.CAD.loadSample('arch');  // 'arch', 'mech', 'elec', or 'empty'
window.CAD.zoomExtents();

// 3. Import & Export:
const dxfText = window.CAD.exportDXF();   // AutoCAD 2000 AC1015 DXF string
const svgText = window.CAD.exportSVG();   // Precision vector SVG
const jsonDoc = window.CAD.exportJSON();  // Document state object
window.CAD.loadDXF(dxfText);              // Import DXF directly
window.CAD.loadJSON(jsonDoc);             // Import JSON state

// 4. Query entities:
const currentEntities = window.CAD.getEntities('current'); // 'current', 'model', 'all'

// 5. Cloud collaboration (Cloudflare D1):
const share = await window.CAD.share({ name: 'Robotics_Frame', expiresDays: 14 });
console.log('View URL:', share.view);
console.log('Edit URL:', share.edit);
await window.CAD.openShare(share.id, share.editToken);

// 6. Browser Library (IndexedDB):
const drawings = await window.CAD.listDrawings();
if (drawings.length > 0) await window.CAD.openDrawing(drawings[0].id);

2. URL Query Parameters & Deep-Links

Launch the CAD app preloaded with specific geometry or commands:

// Auto-run commands on launch:
https://autocad.site/?clean=1&cmd=RECTANG,0,0,100,60;CIRCLE,50,30,20;ZOOM,E

// Load sample drawing:
https://autocad.site/?sample=arch  // or 'mech', 'elec'

// Open shared collaborative link:
https://autocad.site/?share=YL4epyMTzbHv_uDaryiyHg#edit=h4fKJ8ImJ0x97fkssBJj2DUUFQ_f3gcJ

3. Live Zero-Refresh Hash Streaming

Push real-time geometry to an open tab without refreshing the page:

window.location.hash = '#cmd=' + encodeURIComponent('CIRCLE 100,100 25; RECTANG 20,20 60,60');

4. BroadcastChannel & PostMessage

// Control from any iframe, extension, or sibling tab:
const channel = new BroadcastChannel('jscad-bridge');
channel.postMessage({ type: 'CAD_EXECUTE', script: 'PLINE 0,0 100,0 100,100 0,100 C' });

Shortcut	Command	Description

Turning an image or scan into a drawing

For users and AI agents (through the MCP server). A picture is only a picture: to edit it as CAD it has to be redrawn as lines, text, hatches and blocks.

Small sheets (forms, tables, details)

Attach the image (IMAGEATTACH, or drop the file on the drawing) as a reference.
Measure positions from the image pixels rather than by eye, so table lines and cells line up.
Draw on separate layers (frames, grid, fills, text, logo) next to or over the image; agents use cad_batch_add_entities.
Compare with the original (cad_export_svg for agents) and correct the differences.

Large plans (architectural drawings, many sheets of detail)

Reading a big plan in one look does not work: fine text and dimensions are lost. Split the work: algorithms find the geometry, the AI decides what it means, and the result is checked against the image.

Underlay and scale first. Attach the image on a locked layer. Use SCALE with Reference (or ALIGN) so a known dimension or the scale bar measures true. One wrong scale ruins everything after it, so confirm it.
Work in tiles. Cut the image into overlapping tiles (about 1000–1500 px), handle each one and place the results in drawing coordinates.
Geometry by code, not by eye. Image tools (for example OpenCV) clean the scan (straighten, black and white, remove specks), find straight lines and arcs (door swings), merge broken pieces, make near-horizontal and near-vertical lines straight, close gaps at corners, and pair parallel thick lines into walls (MLINE). The AI reviews and fixes the result.
Text by OCR. OCR (for example Tesseract or PaddleOCR, both read Arabic) reads room names and dimensions; the AI decides which text is a dimension, a room name or a note.
Blocks and layers. Doors, windows, sanitary fittings and furniture become one block each, inserted many times. Sort everything into layers such as walls, doors, windows, text and dimensions.
Build in batches. Agents send a few hundred objects per cad_batch_add_entities call and use cad_execute_script for procedural parts, so thousands of coordinates do not pass through the conversation. Save progress tile by tile (cad_export_dxf).
Check automatically. Export SVG, overlay it on the image, score each tile for how well the lines match, and redo only the tiles that score low.
Ask when unsure. Hand-drawn plans, blurry scans, hatching and stamps defeat automatic tracing. Keep the image underneath as a reference and ask instead of guessing.

What JsCAD does and does not do

JsCAD provides the drawing side: image underlay (embedded in the drawing), layers, blocks, multilines, tables, text, scaling by reference, DXF and SVG export, and the MCP tools above.
JsCAD does not trace images or read text from them automatically: steps 3 and 4 need outside image and OCR tools.
Expect automation to do most of a clean printed plan, with review for the rest; poor scans need much more manual work.

Drawing in 3D

JsCAD allows drawing, snapping, and modifying shapes directly in 3D space and across any work plane (UCS).

1. 3D Wireframes & Points (Acceptance A1)

Type 3D coordinates (x,y,z) or snap directly to 3D geometry across any of the 14 preset views.

3D Wireframe Cube with Roof Ridge in SW Iso View

100-unit cube with a gable roof ridge in SW Isometric view

Direct 3D Coordinates: Draw a 3D frame by typing LINE 0,0,0 100,0,0, LINE 0,0,100 0,50,150, etc. Use 3DPOLY for 3D polylines through non-coplanar points.
Preset Views: Switch between 14 preset view cameras (VIEW TOP, VIEW FRONT, VIEW RIGHT, VIEW SWISO, VIEW NEISO...) or click the Views ribbon buttons.
3D Snapping: Endpoint, midpoint, intersection and center snaps pick true 3D points regardless of the current view camera.

2. Drawing Shapes on Any Plane (UCS & Acceptance A2)

Any 2D shape (circles, arcs, polylines, hatches, text, dimensions) can be drawn on any 3D plane.

Circle drawn on the Front face plane, seen from SW Iso View

Circle drawn on the Front face plane, projecting as an exact ellipse in SW Isometric view

Work Planes (UCS): Set a work plane with UCS 3point (origin, X axis, XY plane), UCS Origin, or UCS Object. In face views (Front, Right, etc.), the work plane automatically aligns with the face (when UCSORTHO = 1).
Planar Entities: Circles, arcs, and polylines store their coordinate system plane. In corner views (like SW Isometric), a circle on the front face projects with mathematical precision as an ellipse.
Standard DXF Compliance: Planar entities export to standard AutoCAD DXF using their Object Coordinate System (OCS) normal vectors (group codes 210, 220, 230) and elevation.

3D Solids

Create, edit, preview, and 3D print solid models from within JsCAD.

Draw a closed 2D sketch: Draw a closed polyline (PLINE with Close), circle (CIRCLE), or ellipse (ELLIPSE).
Extrude or Revolve into 3D: Run EXTRUDE (EXT) and enter a height, or REVOLVE (REV) around two axis points. Primitive solids like BOX, CYLINDER (CYL), and SPHERE can also be placed directly.
Boolean edits: Use SUBTRACT (SU) to cut holes, pockets, or slots (select solids to keep, press Enter, then select solids to subtract). Use UNION (UNI) to merge solids, and INTERSECT (IN) to keep only common overlapping volume.
Measure properties: Run MASSPROP to measure volume, surface area, bounding box limits, and centroid.
3D Preview & Orbit: Run 3DORBIT (ORBIT / 3DO) or click 3D view in the 3D ribbon tab to orbit, pan, and zoom solids in flat-shaded WebGL with feature edges.
3D Printing (STL export): Run STLOUT to export selected solids as Binary or ASCII STL files ready for 3D slicers.

Important details on solids & file formats

Faceted representation: Curved solids (cylinders, spheres, revolved shapes) are faceted into planar triangles using tolerance-controlled chords.
DXF saving: AutoCAD DXF format stores solids as standard AC1015 Polyface Meshes so third-party CAD programs can display them. JsCAD attaches an extended XRECORD containing the exact parametric recipe so opening the file in JsCAD restores editable solids.
JSON & Share links: Native JSON files and shareable cloud links store full parametric recipes directly, keeping solids fully editable with zero loss.