Choose a Kernel

Compare the built-in kernels and select the right one for your CAD workflow. This guide helps you decide based on language, export formats, and use cases.

Prerequisites

• Install @taucad/runtime
• Completed the Quick Start

Goal

Select the best kernel for your project based on modeling paradigm (BRep, mesh, CSG), language (TypeScript, OpenSCAD, KCL), and export requirements (STEP, STL, glTF).

Steps

1. Compare the Kernels

2. Evaluate Language and Ecosystem

• TypeScript/JS: Choose Replicad, OpenCASCADE, Manifold, or JSCAD for TypeScript-based CAD. Replicad provides a high-level API over OpenCASCADE, while the OpenCASCADE kernel gives direct API access. Manifold is mesh-first and boolean-focused, and JSCAD is CSG-focused.
• OpenSCAD: Choose OpenSCAD if you have existing .scad files or prefer the OpenSCAD language.
• KCL: Choose Zoo if you need cloud execution or AI integration via the Zoo API.

3. Determine Export Requirements

• STEP: Required for professional CAD interchange. Use Replicad, OpenCASCADE, or Zoo.
• STL for 3D printing: Replicad, OpenCASCADE, OpenSCAD, and Zoo support STL (ASCII/binary).
• glTF/GLB for web viewers: All kernels produce glTF/GLB, including Manifold.

4. Choose by Modeling Paradigm

• BRep high-level (Replicad): Best for precise mechanical parts, fillets, chamfers, and STEP export with a convenient API.
• BRep low-level (OpenCASCADE): Best when you need direct control over OpenCASCADE topology, operations, and data structures.
• Mesh-first booleans (Manifold): Best for robust boolean-heavy modeling and fast browser-native mesh generation.
• CSG (OpenSCAD, JSCAD): Best for boolean operations, 3D printing, and procedural designs.

5. Configure Your Chosen Kernel

Replicad

Use Replicad when you need:

• STEP export for CAD interchange
• BRep modeling with fillets and chamfers
• TypeScript/JS with strong typing
• Professional mechanical design

import { createRuntimeClient, fromMemoryFS } from '@taucad/runtime';
import { replicad } from '@taucad/runtime/kernels';
import { esbuild } from '@taucad/runtime/bundler';

const client = createRuntimeClient({
  kernels: [replicad()],
  bundlers: [esbuild()],
  fileSystem: fromMemoryFS(),
});

OpenCASCADE

Use OpenCASCADE when you need:

• Direct access to the OpenCASCADE Technology (OCCT) API
• Full control over BRep topology and operations
• Advanced geometry construction beyond Replicad's API

import { createRuntimeClient, fromMemoryFS } from '@taucad/runtime';
import { opencascade } from '@taucad/runtime/kernels';
import { esbuild } from '@taucad/runtime/bundler';

const client = createRuntimeClient({
  kernels: [opencascade()],
  bundlers: [esbuild()],
  fileSystem: fromMemoryFS(),
});

OpenSCAD

Use OpenSCAD when you have:

• Existing .scad files
• CSG-based designs for 3D printing
• Familiarity with OpenSCAD syntax

import { createRuntimeClient, fromMemoryFS } from '@taucad/runtime';
import { openscad } from '@taucad/runtime/kernels';

const client = createRuntimeClient({
  kernels: [openscad()],
  fileSystem: fromMemoryFS(),
});

Manifold

Use Manifold when you need:

• High-performance boolean operations in TypeScript
• Mesh-first modeling pipelines
• Browser-friendly WASM performance with robust topology

import { createRuntimeClient, fromMemoryFS } from '@taucad/runtime';
import { manifold } from '@taucad/runtime/kernels';
import { esbuild } from '@taucad/runtime/bundler';

const client = createRuntimeClient({
  kernels: [manifold()],
  bundlers: [esbuild()],
  fileSystem: fromMemoryFS(),
});

JSCAD

Use JSCAD when you need:

• Parametric CSG in TypeScript
• Lightweight browser-based CAD
• No STEP or STL export (glTF/GLB only)

import { createRuntimeClient, fromMemoryFS } from '@taucad/runtime';
import { jscad } from '@taucad/runtime/kernels';
import { esbuild } from '@taucad/runtime/bundler';

const client = createRuntimeClient({
  kernels: [jscad()],
  bundlers: [esbuild()],
  fileSystem: fromMemoryFS(),
});

Zoo (KCL)

Use Zoo when you need:

• Cloud execution via Zoo API
• AI-assisted modeling
• KCL language with remote engine

import { createRuntimeClient, fromMemoryFS } from '@taucad/runtime';
import { zoo } from '@taucad/runtime/kernels';

const client = createRuntimeClient({
  kernels: [zoo({ baseUrl: 'wss://your-zoo-server/v1/kernels/zoo' })],
  fileSystem: fromMemoryFS(),
});

Tau (Converter)

Use Tau when you need:

• Import and preview existing CAD files (STEP, STL, 3MF, OBJ, etc.)
• Format conversion to glTF without writing code
• A catch-all fallback for file formats not handled by other kernels

import { createRuntimeClient, fromMemoryFS } from '@taucad/runtime';
import { tau } from '@taucad/runtime/kernels';

const client = createRuntimeClient({
  kernels: [tau()],
  fileSystem: fromMemoryFS(),
});

6. Register Multiple Kernels

Register multiple kernels in a single client. The framework selects the kernel automatically based on file extension and import detection:

import { createRuntimeClient, presets } from '@taucad/runtime';

const client = createRuntimeClient(presets.all());

Or configure kernels individually for tree-shaking:

import { createRuntimeClient, fromMemoryFS } from '@taucad/runtime';
import { replicad, opencascade, manifold, openscad, jscad, tau } from '@taucad/runtime/kernels';
import { esbuild } from '@taucad/runtime/bundler';

const client = createRuntimeClient({
  kernels: [replicad(), opencascade(), manifold(), openscad(), jscad(), tau()],
  bundlers: [esbuild()],
  fileSystem: fromMemoryFS(),
});

Kernel selection order follows the order in the kernels array. The first kernel whose extension or import detection matches is used. See Kernel Selection for details.

Variations

• presets.all(): Returns { kernels, middleware, bundlers } with all built-in plugins. Pass directly to createRuntimeClient.
• Replicad options: Pass { wasm: 'single-exceptions' } to replicad() for detailed OpenCASCADE error messages during development.
• OpenCASCADE options: Pass { wasm: 'full' } to opencascade() for the full WASM build.
• Manifold options: manifold() currently has no runtime options; behavior is controlled by your model code.
• Zoo options: Zoo requires baseUrl for the WebSocket connection to the Zoo engine.

Related

• Kernel Selection -- How the framework chooses a kernel
• Plugin System -- Extend with custom kernels
• API Reference: Kernels -- Kernel factory functions
• Create a Custom Kernel -- Build your own kernel plugin