@opendaw/nam-wasm

Neural Amp Modeler WASM with multi-instance support for Web Audio integration.

Based on Steven Atkinson's NeuralAmpModelerCore and the TONE3000 WASM port.

Features

- Multi-instance support - Run multiple independent NAM models simultaneously
- Optimized for AudioWorklets - Minimal API designed for real-time audio processing
- TypeScript support - Full type definitions included
- Small footprint - ~200KB WASM binary

Installation

``bash
npm install @opendaw/nam-wasm
`

Usage

$3

`typescript
import { createNamModule, NamWasmModule } from "@opendaw/nam-wasm"

// Initialize the module
const emscriptenModule = await createNamModule()
const nam = NamWasmModule.fromModule(emscriptenModule)

// Set the sample rate (must match your AudioContext)
nam.setSampleRate(48000)

// Create an instance and load a model
const instanceId = nam.createInstance()
const modelJson = await fetch("model.nam").then(r => r.text())
const success = nam.loadModel(instanceId, modelJson)

// Process audio (in your AudioWorklet's process method)
nam.process(instanceId, inputBuffer, outputBuffer)

// Clean up when done
nam.destroyInstance(instanceId)
nam.dispose()
`

$3

`typescript
// processor.ts - AudioWorklet processor
import { createNamModule, NamWasmModule } from "@opendaw/nam-wasm"

class NamProcessor extends AudioWorkletProcessor {
private nam: NamWasmModule | null = null
private instanceId: number = -1

constructor() {
super()
this.init()
this.port.onmessage = (e) => this.handleMessage(e.data)
}

private async init() {
const module = await createNamModule()
this.nam = NamWasmModule.fromModule(module)
this.nam.setSampleRate(sampleRate)
this.instanceId = this.nam.createInstance()
this.port.postMessage({ type: "ready" })
}

private handleMessage(data: any) {
if (data.type === "loadModel" && this.nam) {
const success = this.nam.loadModel(this.instanceId, data.modelJson)
this.port.postMessage({ type: "modelLoaded", success })
}
}

process(inputs: Float32Array[][], outputs: Float32Array[][]) {
if (!this.nam || !this.nam.hasModel(this.instanceId)) {
return true
}

const input = inputs[0][0]
const output = outputs[0][0]

if (input && output) {
this.nam.process(this.instanceId, input, output)
}

return true
}
}

registerProcessor("nam-processor", NamProcessor)
`

$3

`typescript
// Create multiple independent instances
const instance1 = nam.createInstance()
const instance2 = nam.createInstance()

// Load different models
nam.loadModel(instance1, cleanAmpJson)
nam.loadModel(instance2, distortedAmpJson)

// Process independently
nam.process(instance1, guitar1Input, guitar1Output)
nam.process(instance2, guitar2Input, guitar2Output)

// Check instance count
console.log(nam.getInstanceCount()) // 2
`

API Reference

$3

#### Static Methods

| Method | Description |
|--------|-------------|
| fromModule(module, bufferSize?) | Create from an Emscripten module instance |
| create(createModule, bufferSize?) | Create from module factory function |

#### Instance Management

| Method | Description |
|--------|-------------|
| createInstance() | Create a new NAM instance, returns instance ID |
| destroyInstance(id) | Destroy an instance and free resources |
| getInstanceCount() | Get number of active instances |

#### Model Management

| Method | Description |
|--------|-------------|
| loadModel(id, json) | Load a .nam model (JSON string), returns success |
| unloadModel(id) | Unload model from instance |
| hasModel(id) | Check if instance has a model loaded |
| getModelLoudness(id) | Get model loudness in dB (if available) |
| hasModelLoudness(id) | Check if model has loudness metadata |

#### Audio Processing

| Method | Description |
|--------|-------------|
| process(id, input, output) | Process audio through instance |
| processInPlace(id, buffer) | Process audio in-place |
| reset(id) | Reset instance state (call on transport stop) |

#### Configuration

| Method | Description |
|--------|-------------|
| setSampleRate(rate) | Set sample rate for all instances |
| getSampleRate() | Get current sample rate |
| setMaxBufferSize(size) | Set max buffer size (default: 128) |
| getMaxBufferSize() | Get current max buffer size |

#### Cleanup

| Method | Description |
|--------|-------------|
| dispose() | Free all allocated memory |

Building from Source

$3

1. Node.js (v16+)
2. Emscripten (v3.1.41+)

$3

`bash
git clone https://github.com/emscripten-core/emsdk.git
cd emsdk
./emsdk install 3.1.41
./emsdk activate 3.1.41
source ./emsdk_env.sh
`

$3

`bash


Clone with submodules

git clone --recursive https://github.com/andremichelle/nam-wasm.git
cd nam-wasm

Or init submodules if already cloned

git submodule update --init --recursive

Install dependencies

npm install

Build WASM and TypeScript

npm run build

Or build separately

npm run build:wasm # Build WASM only
npm run build:ts # Build TypeScript only
`

Output files are in dist/:
- nam.wasm - WebAssembly binary (~200KB)
- nam.js - Emscripten ES6 module wrapper
- index.js / index.d.ts - Package exports
- NamWasmModule.js / NamWasmModule.d.ts - TypeScript API

Performance

| Model Type | CPU Usage* | Quality |
|------------|-----------|---------|
| Standard | ~8% | Full fidelity |
| Lite | ~5-6% | Nearly indistinguishable |
| Feather | ~4-5% | Great for live/mixing |
| Nano | ~3% | Some loss in detail |

*Per instance on i7 @ 4.2GHz

With Lite/Feather models, 6-8 simultaneous instances run comfortably.

License

MIT License

$3

`
Neural Amp Modeler Core
Copyright 2023-2025 Steven Atkinson
MIT License
https://github.com/sdatkinson/NeuralAmpModelerCore

Neural Amp Modeler WASM (original port)
Copyright 2023 Steven Atkinson
MIT License
https://github.com/tone-3000/neural-amp-modeler-wasm
``

Resources

- NAM Model Library (ToneHunt)
- TONE3000 Models
- Understanding NAM Types