# Choose a Kernel
URL: /docs/guides/choosing-a-kernel



Choose a Kernel [#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 [#prerequisites]

* [Install @taucad/runtime](../getting-started/installation)
* Completed the [Quick Start](../getting-started/quick-start)

Goal [#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 [#steps]

1. Compare the Kernels [#1-compare-the-kernels]

| Kernel          | Language      | Strengths                                                           | Export Formats                   | Use Cases                                               |
| --------------- | ------------- | ------------------------------------------------------------------- | -------------------------------- | ------------------------------------------------------- |
| **Replicad**    | TypeScript/JS | Parametric BRep via OpenCASCADE. STEP export. Strong typing.        | glTF, GLB, STEP, STL, STL-binary | Professional CAD, mechanical parts, STEP interchange    |
| **OpenCASCADE** | TypeScript/JS | Direct OpenCASCADE API. Full BRep control over shapes and topology. | glTF, GLB, STEP, IGES, STL       | Advanced geometry, direct OCCT scripting, BRep kernels  |
| **Manifold**    | TypeScript/JS | Mesh-first modeling with robust booleans and fast WASM execution.   | glTF, GLB                        | Browser-native CAD, procedural booleans, mesh workflows |
| **OpenSCAD**    | OpenSCAD      | CSG modeling. Familiar `.scad` syntax. Mature ecosystem.            | glTF, GLB, STL, STL-binary       | 3D printing, functional parts, CSG workflows            |
| **JSCAD**       | TypeScript/JS | Parametric CSG with `@jscad/modeling`. Browser-native.              | glTF, GLB                        | Web-based CAD, parametric designs, lightweight models   |
| **Zoo (KCL)**   | KCL           | Cloud-native CAD. AI integration via Zoo API.                       | glTF, GLB, STEP, STL, STL-binary | Cloud workflows, AI-assisted modeling, remote execution |
| **Tau**         | Any           | Catch-all file converter. Imports STEP, STL, 3MF, OBJ, etc.         | glTF, GLB                        | File import/preview, format conversion                  |

2. Evaluate Language and Ecosystem [#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 [#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 [#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 [#5-configure-your-chosen-kernel]

Replicad [#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

```typescript
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 [#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

```typescript
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 [#openscad]

Use OpenSCAD when you have:

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

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

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

Manifold [#manifold]

Use Manifold when you need:

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

```typescript
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 [#jscad]

Use JSCAD when you need:

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

```typescript
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) [#zoo-kcl]

Use Zoo when you need:

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

```typescript
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) [#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

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

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

6. Register Multiple Kernels [#6-register-multiple-kernels]

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

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

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

Or configure kernels individually for tree-shaking:

```typescript
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](../concepts/kernel-selection) for details.

Variations [#variations]

* **presets.all()**: Returns `{ kernels, middleware, bundlers }` with all built-in plugins. Pass directly to [`createRuntimeClient`](../api/client).
* **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 [#related]

* [Kernel Selection](../concepts/kernel-selection) -- How the framework chooses a kernel
* [Plugin System](../concepts/plugin-system) -- Extend with custom kernels
* [API Reference: Kernels](../api/kernels) -- Kernel factory functions
* [Create a Custom Kernel](./custom-kernel) -- Build your own kernel plugin