CADAM: The Revolutionary Text-to-CAD Tool Every Developer Needs

Transform natural language into precision 3D models in seconds. No complex software, no steep learning curves—just describe what you need and watch CADAM generate it instantly.

For decades, creating 3D models meant mastering complex CAD software like SolidWorks, Fusion 360, or Blender. The learning curve was brutal. The interfaces were overwhelming. And the cost? Often prohibitive for hobbyists, educators, and small teams. But what if you could simply type "create a gear with 20 teeth and 5mm thickness" and get a production-ready STL file? That's exactly what CADAM delivers—a groundbreaking open-source text-to-CAD web application that's democratizing 3D design through the power of AI and WebAssembly.

In this deep dive, you'll discover how CADAM leverages cutting-edge technologies like React 19, Supabase, and OpenSCAD WASM to run entirely in your browser. We'll walk through real installation commands, explore the parametric controls that make iteration instant, and reveal why this tool is becoming essential for developers, makers, and engineers. Whether you're building custom mechanical parts, teaching CAD concepts, or prototyping products, CADAM represents a fundamental shift in how we interact with 3D modeling software.

What is CADAM? The Open Source Text-to-CAD Revolution

CADAM is the world's first fully browser-based, open-source text-to-CAD web application that converts natural language descriptions and images into parametric 3D models. Created by the Adam-CAD team—Zach Dive, Aaron Li, and Dylan Anderson—this revolutionary tool eliminates the barrier between imagination and creation by letting you describe objects in plain English while AI handles the complex CAD scripting behind the scenes.

At its core, CADAM is built on a sophisticated stack that combines React 19.1 for a lightning-fast frontend, Supabase for backend services and edge functions, and OpenSCAD compiled to WebAssembly to execute CAD operations directly in your browser. The magic happens through integration with Anthropic's Claude API, which interprets your text prompts and generates OpenSCAD code that gets rendered in real-time using Three.js and React Three Fiber.

What makes CADAM truly revolutionary is its browser-native architecture. Unlike cloud-based solutions that require server-side processing, CADAM runs entirely client-side after initial load. The OpenSCAD WASM binary executes locally, meaning your designs remain private, processing is instantaneous, and you can work offline. This approach also makes it perfect for educational institutions concerned about data privacy and makers who need reliable tools without internet dependency.

The project has gained massive traction in the developer community because it solves a genuine pain point: the abstraction gap between human intent and CAD software. Traditional parametric modeling requires memorizing complex command structures and understanding geometric constraints. CADAM's AI-powered natural language processing bridges this gap, making 3D modeling accessible to programmers, designers, and hobbyists who understand what they want but lack specialized CAD training.

Key Features That Make CADAM Essential

🤖 AI-Powered Generation with Natural Language Understanding

CADAM's flagship feature transforms descriptive text into functional OpenSCAD code. The system doesn't just create static models—it generates parametric, editable code that understands dimensions, geometric relationships, and mechanical features. When you type "create a hexagonal bolt with M8 threads and 20mm length," the AI extracts parameters like thread pitch, head diameter, and shaft length, making them adjustable via interactive sliders.

The image reference capability adds another dimension. Upload a sketch or reference photo, and CADAM's integration with Anthropic's vision model interprets visual cues to inform the 3D generation. This multimodal approach is perfect for reverse-engineering parts or converting 2D concepts into printable models.

🎛️ Interactive Parametric Controls for Instant Iteration

Unlike traditional text-to-3D tools that generate static meshes, CADAM extracts adjustable parameters from your description and presents them as real-time sliders. Change the gear's tooth count from 20 to 40, and the model updates instantly without re-running the AI generation. This smart update system saves API costs and delivers immediate visual feedback.

The parameter extraction engine identifies numeric values, dimensional constraints, and geometric properties automatically. It then binds these to UI controls using React state management, creating a seamless bridge between human input and geometric output. This feature alone makes CADAM superior to one-shot AI generators.

📦 Multiple Export Formats for Production Workflows

CADAM supports exporting models as .STL files for 3D printing and .SCAD files for further editing in OpenSCAD. This dual-format approach acknowledges that AI-generated starting points often need refinement. The STL export uses Three.js's robust geometry exporters, ensuring watertight meshes suitable for slicing software like Cura or PrusaSlicer.

The SCAD export preserves the parametric nature of your model, allowing advanced users to take the AI-generated code into desktop OpenSCAD for complex modifications. This respects the open-source ethos while providing professional-grade flexibility.

🌐 Pure Browser-Based Architecture with WebAssembly

The entire CADAM application runs client-side thanks to OpenSCAD compiled to WebAssembly. When you load the app, the WASM binary downloads once and executes locally. This architecture provides sub-100ms model regeneration when adjusting parameters, complete data privacy, and offline capability. The WebAssembly module interfaces with JavaScript through a custom wrapper that handles geometry conversion to Three.js meshes.

📚 Built-In Library Support for Complex Geometry

CADAM includes BOSL, BOSL2, and MCAD libraries pre-loaded in its OpenSCAD environment. These libraries provide advanced geometric primitives, thread generation, gear calculations, and mechanical components. When you request "a beveled gear with module 2," CADAM can leverage BOSL2's sophisticated gear modules rather than reinventing the wheel, resulting in more accurate and efficient code generation.

🎯 Real-Time Preview with Three.js Rendering

The 3D viewport uses React Three Fiber to render models with smooth camera controls, material previews, and lighting. As parameters change, the geometry updates at 60fps, providing a game-like interaction model that feels responsive and modern. The renderer supports wireframe overlays, dimension visualization, and export-ready mesh inspection.

Real-World Use Cases Where CADAM Shines

1. Rapid Mechanical Prototyping for Hardware Startups

Hardware startups operate under crushing time constraints. A founder needs a custom enclosure bracket, gear system, or mounting plate designed, tested, and printed within hours—not days. With CADAM, they simply describe the part: "Create a mounting bracket for a Raspberry Pi 4 with M2.5 screw holes at corners, 3mm thickness, and snap-fit clips for a 2mm PCB."

The AI generates parametric code, the founder adjusts dimensions using sliders to perfect the fit, and exports an STL for immediate printing. Total time: 15 minutes. Traditional CAD workflows would require 2-4 hours of designer time. CADAM's browser-based nature means the entire team can collaborate in real-time, sharing links to designs that others can modify instantly.

2. Educational Institutions Teaching CAD Concepts

Engineering professors face a dilemma: teach CAD software interfaces or teach design thinking? CADAM separates these concerns. Students learn geometric principles and parametric design by experimenting with natural language descriptions and observing how parameters affect outcomes.

A professor assigns "design a functional whistle" and students iterate by typing descriptions, adjusting parameters, and analyzing the generated OpenSCAD code. This code-as-pedagogy approach demystifies CAD operations while building intuition. The open-source nature allows institutions to self-host, ensuring student data privacy and eliminating software licensing costs that can exceed $10,000 per lab.

3. Custom Replacement Parts for Maintenance and Repair

Maintenance technicians frequently need obsolete or custom parts. Imagine a broken plastic latch in a legacy machine. The technician photographs the broken piece, uploads it to CADAM, and types "recreate this latch with 4mm thickness and reinforced mounting holes."

The AI interprets the image geometry, generates a parametric model, and the technician adjusts wall thickness and hole placement before exporting an STL for on-demand printing. This image-guided reverse engineering capability reduces machine downtime from weeks to hours and eliminates expensive custom machining.

4. Architectural Visualization and Spatial Prototyping

Interior designers and architects use CADAM for quick spatial prototypes. Describing "a minimalist bookshelf with 5 shelves, 80cm width, adjustable height feet, and hidden cable management" yields a parametric model that can be dimensionally adjusted as client requirements evolve.

The real-time parameter adjustment allows designers to explore variations during client meetings, projecting the browser-based viewport for collaborative decision-making. Exporting to SCAD format enables further refinement in architectural software, creating a seamless workflow from concept to presentation.

Step-by-Step Installation & Setup Guide

Getting CADAM running locally requires several components, but the process is straightforward. Follow these exact commands from the repository:

Prerequisites Installation

First, ensure you have Node.js 18+ and npm installed. Then install the Supabase CLI and ngrok:

# Install Supabase CLI (macOS/Linux)
brew install supabase/tap/supabase

# Or on Windows
scoop install supabase

# Install ngrok globally
npm install -g ngrok
# Or via Homebrew
brew install ngrok

Repository Clone and Dependency Installation

# Clone the repository
git clone https://github.com/Adam-CAD/CADAM.git
cd CADAM

# Install all dependencies
npm install

This installs React 19.1, Three.js, React Three Fiber, Tailwind CSS, and other frontend dependencies. The package.json includes scripts for development, building, and serving the application.

Supabase Local Environment Setup

CADAM uses Supabase for edge functions that communicate with the Anthropic API. Start the local Supabase stack:

# Initialize and start Supabase services
npx supabase start
npx supabase functions serve --no-verify-jwt

The supabase start command spins up PostgreSQL, authentication, storage, and edge function runtimes in Docker containers. The --no-verify-jwt flag allows local development without authentication tokens.

Environment Configuration

Create two environment files. First, the frontend configuration:

# Copy the template
cp .env.local.template .env.local

# Edit .env.local with your values
nano .env.local

Inside .env.local, configure:

VITE_SUPABASE_ANON_KEY="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."  # From supabase start output
VITE_SUPABASE_URL='http://127.0.0.1:54321'  # Local Supabase URL

Second, configure the edge functions environment:

# Copy the functions template
cp supabase/functions/.env.template supabase/functions/.env

# Edit with your API keys
nano supabase/functions/.env

Required variables in supabase/functions/.env:

ANTHROPIC_API_KEY="sk-ant-..."  # Your Anthropic Claude API key
ENVIRONMENT="local"  # Set to local for development
NGROK_URL="https://xxxx-xx-xx-xxx-xx.ngrok.io"  # Will be set in next step

ngrok Tunnel Configuration for Image Processing

CADAM requires ngrok to send image URLs to Anthropic's vision API:

# Start ngrok tunnel to Supabase
ngrok http 54321

Copy the generated HTTPS URL (e.g., https://a1b2c3d4.ngrok.io) and update supabase/functions/.env:

NGROK_URL="https://a1b2c3d4.ngrok.io"

Restart the Supabase functions service to pick up the new environment variable:

npx supabase functions serve --no-verify-jwt

Launching the Development Server

With all services running, start the frontend:

npm run dev

The Vite development server will start on http://localhost:5173. Open this URL in a modern browser (Chrome, Firefox, or Edge recommended) to access the CADAM interface. The first load may take 10-20 seconds as the OpenSCAD WASM binary downloads and initializes.

REAL Code Examples from the Repository

Let's examine the actual code snippets from CADAM's README and understand their technical implementation.

Example 1: Quick Start Bash Commands

The installation process uses these exact commands:

# Clone the repository
git clone https://github.com/Adam-CAD/CADAM.git
cd CADAM

# Install dependencies
npm install

# Start Supabase
npx supabase start
npx supabase functions serve --no-verify-jwt

# Start the development server
npm run dev

Technical Breakdown:

• git clone fetches the entire repository including the OpenSCAD WASM binary (approximately 15MB) and React source code
• npm install resolves dependencies listed in package.json, including React 19.1, Three.js r155, and React Three Fiber
• npx supabase start orchestrates Docker containers for PostgreSQL, GoTrue auth, Storage API, and Edge Functions runtime
• The --no-verify-jwt flag bypasses JWT token verification, essential for local development when testing API endpoints without full authentication flow
• npm run dev launches Vite's development server with hot module replacement, enabling instant code changes without full page reloads

Example 2: Frontend Environment Configuration

The .env.local file structure is critical for connecting the React app to Supabase:

VITE_SUPABASE_ANON_KEY="<Test Anon Key>"
VITE_SUPABASE_URL='http://127.0.0.1:54321'

Implementation Details:

• VITE_ prefix exposes variables to Vite's client-side bundle at build time
• The ANON KEY is a public key for Supabase client-side operations; in local dev, it's generated by supabase start and allows unauthenticated requests
• The URL points to the local Docker network where Supabase services bind to port 54321
• These variables are accessed in the React code via import.meta.env.VITE_SUPABASE_URL, enabling type-safe environment access

Example 3: Supabase Functions Environment

The backend configuration for AI integration:

ANTHROPIC_API_KEY="<Test Anthropic API Key>"
ENVIRONMENT="local"
NGROK_URL="<NGROK URL>" # Your ngrok tunnel URL, e.g., https://xxxx-xx-xx-xxx-xx.ngrok.io

Deep Dive:

• ANTHROPIC_API_KEY authenticates requests to Claude 3.5 Sonnet, the model powering CADAM's natural language understanding
• ENVIRONMENT="local" switches the function behavior to use local Supabase storage URLs instead of production CDN URLs
• NGROK_URL is crucial for image processing: when you upload a reference image, Supabase stores it locally, but Anthropic's API requires publicly accessible URLs. ngrok creates a tunnel exposing your local Supabase instance to the internet
• The Edge Functions read this file at startup, making the configuration available via Deno.env.get("ANTHROPIC_API_KEY") in the function code

Example 4: ngrok Tunnel Setup Commands

The image processing pipeline depends on this exact command:

# Install ngrok if you haven't already:
npm install -g ngrok
# or
brew install ngrok

# Start an ngrok tunnel pointing to your Supabase instance:
ngrok http 54321

Technical Architecture:

• ngrok http 54321 creates a reverse proxy tunnel from a public HTTPS endpoint to your local Supabase service
• The tunnel handles SSL termination and request forwarding, making local storage buckets accessible to external APIs
• When CADAM uploads an image, it gets stored in Supabase Storage at http://localhost:54321/storage/v1/object/...
• The Edge Function transforms this URL by replacing the base with NGROK_URL, creating https://xxxx.ngrok.io/storage/v1/object/...
• Anthropic's vision API can now fetch the image, analyze it, and incorporate visual context into the CAD generation prompt
• This pattern is essential for local AI development but should be replaced with proper CDN URLs in production

Advanced Usage & Best Practices

Optimizing AI Prompts for Better Geometry

To get production-quality models, structure your prompts with explicit parameters:

Good prompt: "Create a mounting bracket with base dimensions 50x30mm, 4mm thickness, M4 screw holes at corners (5mm from edges), filleted edges with 2mm radius, and a central cutout of 20x10mm."

Poor prompt: "Make a bracket for mounting things."

The AI extracts parameters more accurately when you specify units, hole sizes, and geometric features explicitly. Include mechanical terms like "fillet," "chamfer," "clearance," and "tolerance" for professional results.

Leveraging Built-In Libraries in Prompts

Reference BOSL2 features directly: "Use BOSL2's gear module to create a helical gear with module 2, 30 teeth, 20-degree pressure angle, and 30-degree helix angle." This guides the AI to generate optimized code using library functions rather than manual geometry construction.

Development Workflow Tips

1. Use the SCAD export for complex modifications: AI-generated code is excellent for 80% of cases, but manual refinement in OpenSCAD desktop handles edge cases
2. Parameter naming conventions: When the AI extracts parameters, rename them in the UI for clarity—"tooth_count" becomes "Number of Teeth" for team collaboration
3. Batch processing: Use the Supabase Edge Functions directly via HTTP requests to generate multiple model variants programmatically
4. Version control: Commit your .env files (without API keys) to share consistent configurations across teams

Performance Optimization

• WASM caching: The OpenSCAD binary caches in browser IndexedDB after first load. Subsequent visits load instantly
• Model complexity: Keep polygon counts reasonable; use the $fn parameter in prompts to control circle smoothness (e.g., "cylinder with $fn=32")
• AI token limits: Complex models may hit Claude's token limit. Break designs into modular components and assemble them in OpenSCAD later

Comparison with Alternatives

Why CADAM Wins: Unlike traditional CAD, there's no interface learning curve. Unlike cloud generators, you own the entire stack and get parametric, editable code. The browser-based architecture combines the accessibility of web apps with the power of desktop software.

Frequently Asked Questions

Q: Can CADAM run on mobile devices or tablets? A: Yes! The React-based frontend is responsive, and WebAssembly runs on modern mobile browsers. While complex models are best designed on desktop, viewing and parameter adjustment work smoothly on tablets for field modifications.

Q: How much does the Anthropic API cost for heavy usage? A: Claude 3.5 Sonnet costs ~$3 per million input tokens. A typical CADAM prompt uses ~500 tokens, so roughly $0.0015 per generation. For 100 generations/day, expect ~$4.50/month—far cheaper than commercial CAD subscriptions.

Q: Can I use CADAM without internet connection? A: After the initial load, yes! The OpenSCAD WASM binary and React app cache locally. However, the AI generation feature requires internet for Anthropic API calls. Once generated, parameter adjustments work offline.

Q: What file formats can I import as references? A: Currently, CADAM supports JPG, PNG, and WebP images for reference. The system extracts geometric cues and dimensions from images to inform generation. Direct 3D file import is planned for future releases.

Q: How do I customize the UI or add new features? A: Fork the repository! The React component structure is modular. Key files are in src/components/ for UI and supabase/functions/ for backend logic. The project uses TypeScript for type safety and Tailwind CSS for easy styling customization.

Q: Is the generated OpenSCAD code production-ready? A: Generally yes for 80% of use cases. The AI produces clean, parametric code using best practices. For critical applications, review the SCAD export and add tolerance adjustments or stress analysis as needed—just like any AI-generated code.

Q: Can I self-host CADAM for my organization? A: Absolutely! The entire stack can run on-premises. You'll need to host Supabase (open source) and configure environment variables for your infrastructure. This is ideal for companies with strict IP protection requirements.

Conclusion: Why CADAM Belongs in Your Development Toolkit

CADAM isn't just another AI toy—it's a paradigm shift in computer-aided design. By combining natural language processing, browser-based WebAssembly execution, and open-source flexibility, it democratizes 3D modeling in ways previously impossible. The ability to generate parametric, editable code from simple descriptions eliminates the biggest barrier between ideas and physical prototypes.

For developers, CADAM represents a new kind of API: one where human intent is the interface. The React 19 foundation ensures extensibility, while Supabase provides scalable backend services. The inclusion of professional libraries like BOSL2 means you're not sacrificing capability for convenience.

The open-source nature guarantees that this tool will evolve with community contributions, avoiding the vendor lock-in that plagues commercial CAD software. Whether you're a startup founder iterating hardware designs, an educator teaching the next generation of engineers, or a maker bringing weekend projects to life, CADAM delivers unprecedented speed and accessibility.

The future of design is descriptive, not prescriptive. Why click through menus when you can simply describe? Why learn complex interfaces when you can iterate with natural language? CADAM answers these questions with a robust, extensible platform that respects both your time and your privacy.

Ready to revolutionize your 3D workflow? Star the repository, clone it locally, and join the community that's redefining how we create. The next great product might start with a simple sentence.

⭐ Star CADAM on GitHub and start building today!