What Pre-Trained Models Are Available for Text-to-CAD?

The earthtojake/text-to-cad repository ships with twelve ready-to-use CAD definitions—including Formula-1 cars, humanoid robots, and mechanical assemblies—that you can render instantly via the cadgen skill CLI or Python API without additional training or data collection.

The text-to-cad project provides a complete pipeline for converting natural language into manufacturable CAD files. At its core, the cadgen package (located in packages/cadgen/) includes a curated library of pre-trained model definitions stored under the top-level models/ directory. These definitions contain complete geometric hierarchies, material specifications, and assembly instructions required to generate STEP and GLB outputs on-the-fly.

Complete Library of Pre-Trained Text-to-CAD Models

The repository organizes models into thematic categories. Each model lives in its own subfolder (e.g., models/f1/) and includes a dedicated README.md and source directory (src/) containing the Python geometry definitions.

Automotive and Racing Vehicles

• f1 — Formula-1 race car featuring a detailed monocoque, suspension geometry, power-unit assembly, and aerodynamic surfaces.
• f14d — F-14D Tomcat fighter jet with configurable wings, nose gear, and main landing gear assemblies.
• hypercar — High-performance hyper-car with advanced chassis architecture, power-train layout, suspension systems, and integrated lighting.
• w16 — 16-cylinder automotive engine block complete with crank shaft, pistons, cam drive, oil system, and cooling passages.
• motorbike — Complete motorcycle assembly with frame, wheels, mirrors, seat, and lighting fixtures.

Robotics and Humanoids

• juno — Full-body humanoid robot including torso, pelvis, upper and lower limbs, and wrist carrier modules.
• lyra — Articulated human hand model with individual finger segments, knuckle joints, and palm geometry.
• tendon_hand — Soft-actuated robotic hand driven by tendon cables; includes an interactive web demo.

Component Libraries and Assemblies

• drawings — Modular library of generic CAD components such as mounting brackets, plates, and fasteners.
• assemblies — Example multi-part assemblies demonstrating how to combine individual model parts (e.g., a complete robot arm).
• moonwatch — Classic wristwatch model comprising case, dial, strap, and mechanical movement housing.
• examples — Minimal demonstration models used for integration testing and documentation tutorials.

How to Generate CAD Files from Pre-Trained Models

You can invoke these models through three primary interfaces: the command-line tool, the Python ModelBuilder class, or the interactive Jupyter viewer.

Command-Line Generation with cadgen

The cadgen skill CLI provides the fastest path from model name to manufacturable file. Install the package per packages/cadgen/README.md, then use the model subcommand.

Export a hyper-car as a STEP file for manufacturing:

cadgen model hypercar --output hypercar.step

Generate a GLB preview of the F1 car for web viewing:

cadgen model f1 --format glb --output f1.glb

Programmatic Access via Python

For batch processing or integration into larger pipelines, import ModelBuilder from the cadgen package. The builder resolves model source files automatically from models/<name>/src/.

from cadgen import ModelBuilder

# Load motorbike geometry

builder = ModelBuilder.from_model('motorbike')

# Export manufacturing-ready STEP

builder.export_step('motorbike.step')

# Export lightweight GLB for web preview

builder.export_glb('motorbike.glb')

Interactive Preview in Jupyter

The built-in viewer renders models directly in notebook cells without exporting to disk first.

from cadgen.viewer import Viewer

viewer = Viewer()
viewer.display_model('lyra')  # Renders the hand model interactively

Model Architecture and Source Organization

Understanding the file structure helps when extending or debugging a model. Each pre-trained model follows a strict convention:

• models/<model_name>/README.md — Contains model-specific documentation, parameter descriptions, and preview assets.
• models/<model_name>/src/ — Houses the Python modules that define the geometry, joints, and material hierarchies.
• packages/cadgen/README.md — Documents the core runtime, CLI entry points, and ModelBuilder API signatures.

The cadgen library treats these directories as immutable, versioned assets. When you call ModelBuilder.from_model('f14d'), the loader imports the geometry definition from models/f14d/src/ and caches the compiled boundary representation for subsequent exports.

Summary

• earthtojake/text-to-cad provides twelve pre-trained CAD models spanning vehicles, humanoids, and mechanical components.
• All models reside in the models/ directory and are ready to render without training or data collection.
• The cadgen skill CLI supports direct export to STEP (manufacturing) and GLB (web/visualization) formats.
• Python users can leverage ModelBuilder.from_model() and export_step()/export_glb() for scripted workflows.
• Interactive development is supported via cadgen.viewer.Viewer for Jupyter environments.

Frequently Asked Questions

What file formats can I export from text-to-cad pre-trained models?

The cadgen tool chain supports STEP (ISO 10303) for CNC manufacturing and GLB (glTF 2.0) for web and real-time visualization. The CLI exposes these via the --format flag, while the Python API offers explicit export_step() and export_glb() methods on the ModelBuilder instance.

Do I need to train these models before using them?

No. The models are pre-trained in the sense that they ship with complete geometric definitions and assembly logic. You can run cadgen model f1 immediately after installation without downloading weights or performing fine-tuning. The term "pre-trained" here refers to the CAD domain expertise encoded in the source files under models/<name>/src/.

How do I add a custom model to the cadgen library?

Create a new directory under models/ with a src/ subfolder containing your Python geometry definitions. You must implement the standard model interface expected by ModelBuilder (see models/examples/src/ for a template). Once the directory contains a valid README.md and source modules, the cadgen model <your_model_name> command will recognize it automatically.

Where are the model geometry definitions stored?

Each model's Python source code resides in models/<model_name>/src/. For example, the Juno humanoid logic is located in models/juno/src/. The ModelBuilder class dynamically imports these modules at runtime based on the string identifier passed to from_model().

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}