Voxen

AI-powered CAD generator that produces assembly-aware 3D models as discrete, labeled parts — not a single mesh blob. Powered by AMD MI300X with Qwen3-8B.

AMD AI Developers Hackathon 2026 · Oryxenlab

---

---

Overview

Most AI-to-3D tools output a single undifferentiated mesh. Voxen is different: it generates assembly-aware models where every part is named, dimensioned, material-annotated, and independently exportable. The result is a model you can actually use in downstream CAD workflows — not just a blob to look at.

The system accepts a natural language description, runs it through an LLM agent on AMD MI300X, validates the output with Zod, and renders each part as a distinct 3D object with full interactive inspection.

---

Features

• 🎯 Part-aware Generation — LLM generates each component as a separate object with name, dimensions, and material
• 🖱️ Interactive 3D Inspection — Click any part to isolate it; others fade to wireframe
• 📤 CAD-ready Export — Export as STL, OBJ, or STEP for use in Fusion 360, Blender, SolidWorks
• 🎮 Free Camera Controls — Orbit, zoom, and quick-view presets (Front/Top/Side/Iso)
• ✅ Zod Validation — All AI outputs validated before rendering
• ⚡ AMD MI300X Powered — Fast inference on cutting-edge GPU hardware

---

Tech Stack

Layer	Technology	Purpose
Framework	Next.js 16 (App Router)	Server & client rendering
Language	TypeScript	Type-safe development
UI Library	Shadcn UI	Component library
Styling	Tailwind CSS	Utility-first styling
3D Rendering	React Three Fiber (R3F)	React renderer for Three.js
3D Helpers	@react-three/drei	Edges
Validation	Zod	JSON schema validation
AI Backend	Flask (Python)	API server
ML Framework	PyTorch	LLM Fine-tuning & model optimization
Base Model	Qwen 3 8B	Foundation model for structured CAD generation
LLM Server	vLLM	High-throughput model serving
Hardware	AMD MI300X	GPU acceleration for training and inference
Auth	Clerk	Authentication & user management
Hosting	Vercel	Frontend deployment
VCS	GitHub	Source control

---

Stack Diagram

---

Architecture

Client (Browser)
    ↓
Next.js 16 Frontend  ←→  Clerk (Auth)
    ↓
Flask API (Python)
    ↓
Qwen3-8B on AMD MI300X
    ↓ generates
Zod-validated JSON (parts + metadata)
    ↓
React Three Fiber renders parts + Dashboard
    ↓
Export STEP / STL / OBJ

Data flow: User prompt → Flask receives request → Qwen3-8B generates structured part JSON → Zod validates schema → response sent to frontend → R3F renders each part as a discrete mesh → user inspects/exports individual parts.

---

Project Structure

voxen/
├── src/
│   ├── app/                    # Next.js 16 app router
│   │   ├── (auth)/             # Clerk-protected routes (sign-in, sign-up)
│   │   ├── (public)/           # Public landing page
│   │   ├── (workspace)/        # Main 3D CAD viewer and workspace
│   │   └── layout.tsx
│   ├── components/
│   │   ├── home/               # Landing page sections (Hero, Mockup, Features)
│   │   ├── workspace/          # Generator page
│   │   ├── viewer/             # R3F canvas + controls (SceneCanvas, GearCanvas)
│   │   └── ui/                 # Shadcn UI components & animations
│   ├── lib/
│   │   ├── schemas/            # Zod schemas for part JSON
│   │   ├── api/                # API wrappers
│   │   └── export/             # STL / OBJ / STEP exporters
│   └── types/                  # TypeScript types from Zod
├── backend/                    # Flask AI agent
│   ├── app.py
│   ├── agent/
│   │   ├── llm_client.py       # Qwen3-8B on AMD MI300X via vLLM
│   │   └── prompt_builder.py
│   └── validators/
│       └── assembly_schema.py  # Pydantic mirror of Zod schema
└── __tests__/                  # Vitest + React Testing Library

---

Getting Started

Prerequisites

• Node.js 20+
• Python 3.11+
• Clerk account
• AMD MI300X endpoint (or OpenAI-compatible vLLM server)

Installation

# Clone repository
git clone https://github.com/oryxenlab/voxen.git
cd voxen

# Install frontend dependencies (using pnpm)
pnpm install

# Install backend dependencies
cd backend
pip install -r requirements.txt
cd ..

Environment Variables

Create .env.local in project root:

# Clerk Auth
NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_...
CLERK_SECRET_KEY=sk_...

# Flask Backend
FLASK_API_URL=http://localhost:5000

# AMD MI300X / Qwen3
LLM_API_BASE_URL=https://your-mi300x-endpoint
LLM_API_KEY=your_api_key
LLM_MODEL=Qwen/Qwen3-8B-Instruct

See .env.example for detailed comments on each variable.

Development

# Terminal 1 — Frontend
pnpm dev

# Terminal 2 — Backend
cd backend
python app.py

Frontend: http://localhost:3000
Backend: http://localhost:5000

Testing

# Run all tests
pnpm test

# Backend tests
cd backend && pytest

---

Part JSON Schema (Zod)

Every model the AI generates is validated against this schema before being sent to the renderer:

import { z } from 'zod'

const PartSchema = z.object({
  id: z.string(),
  name: z.string(),
  color: z.string().regex(/^#[0-9A-Fa-f]{6}$/),
  geometry: z.object({
    type: z.enum(['box', 'cylinder', 'sphere', 'custom']),
    dimensions: z.object({
      width: z.number().positive(),
      height: z.number().positive(),
      depth: z.number().positive(),
    }),
    position: z.object({ x: z.number(), y: z.number(), z: z.number() }),
  }),
  material: z.object({
    name: z.string(),
    description: z.string(),
  }),
  designIntent: z.string(),
  exportFormats: z.array(z.enum(['STL', 'OBJ', 'STEP'])),
})

export const AssemblySchema = z.object({
  assemblyName: z.string(),
  version: z.string(),
  parts: z.array(PartSchema).min(1),
  metadata: z.object({
    generatedAt: z.string().datetime(),
    promptSummary: z.string(),
  }),
})

---

Export Formats

Format	Use Case
STL	3D printing, rapid prototyping
OBJ	Blender, Cinema 4D, mesh editing
STEP	Fusion 360, CATIA, SolidWorks

---

Roadmap

• Multi-turn prompt refinement (iterative editing)
• Constraint-based assembly (snap joints, axis alignment)
• Parametric dimension editing in-browser
• BOM (bill of materials) export
• Fine-tuned Qwen3 on CAD-specific dataset
• Collaborative workspaces

---

Team

Oryxenlab — AMD AI Developers Hackathon 2026

---

License

MIT