Write the DSP once. Run it everywhere.

npx codex create my-pedal --template fx-react
cd my-pedal
npm run dev            # http://localhost:5173 — audio on first click

// src/kernel.ts
import type { AudioKernel, KernelIO } from "@codex-music/audio-contracts";

interface ToneState {
  sampleRate: number;
  /** One-pole lowpass memory, per channel. Allocated in init(), never here. */
  lp: Float32Array;
}

export const toneKernel: AudioKernel<ToneState> = {
  init(sampleRate: number): ToneState {
    // Setup is the place to allocate. Two channels is plenty for a pedal.
    return { sampleRate, lp: new Float32Array(2) };
  },

  process(state, io: KernelIO, params, _events): void {
    // Coefficient from the cutoff knob. Cheap, allocation-free, per block.
    const cutoff = params["tone.cutoff"];
    const coeff = Math.min(1, Math.max(0.001, cutoff / state.sampleRate));
    const level = params["master.level"];

    for (let ch = 0; ch < io.outputs.length; ch = ch + 1) {
      const input = io.inputs[ch];
      const output = io.outputs[ch];
      let z = state.lp[ch];

      for (let i = 0; i < io.frameCount; i = i + 1) {
        // fround at the accumulation keeps WASM and native bit-identical.
        z = Math.fround(z + coeff * (input[i] - z));
        output[i] = Math.fround(z * level);
      }

      state.lp[ch] = z;
    }
  },

  reset(state): void {
    state.lp.fill(0);
  },
};

// src/schema.ts
import type { ParamSchema } from "@codex-music/audio-contracts";

export const MY_PEDAL_SCHEMA: ParamSchema = {
  kernelId: "sctone_",
  params: [
    {
      path: "tone.cutoff",
      label: "Tone",
      group: "Filter",
      type: "float",
      min: 200,
      max: 8000,
      default: 2500,
      units: "Hz",
    },
    {
      path: "master.level",
      label: "Level",
      group: "Master",
      type: "float",
      min: 0,
      max: 1,
      default: 0.9,
    },
  ],
};

// src/App.tsx
import { createAudioEngine, isNativeHost } from "@codex-music/audio-sdk";
import { MY_PEDAL_SCHEMA } from "./schema";

const engine = createAudioEngine({
  // browser: shared-wasm · plugin shell: native
  backend: "shared-wasm",
  graph: { schema: MY_PEDAL_SCHEMA, nodes: [{ kind: "sctone_", params: {} }] },
});

export function App() {
  return (
    <main>
      <h1>My Pedal {isNativeHost() ? "(in your DAW)" : "(in your browser)"}</h1>
      {MY_PEDAL_SCHEMA.params.map((p) => (
        <label key={p.path}>
          {p.label}
          <input
            type="range"
            min={p.min}
            max={p.max}
            step={p.step ?? ((p.max ?? 1) - (p.min ?? 0)) / 200}
            defaultValue={p.default}
            onChange={(e) => engine.setParam(p.path, e.target.valueAsNumber)}
          />
          {p.units}
        </label>
      ))}
    </main>
  );
}

npx codex export vst3
# → build/MyPedal.vst3
# → build/MyPedal.app  (standalone, same kernel)

{
  "id": "music.codex.my-pedal",
  "name": "My Pedal",
  "vendor": "Codex Music",
  "version": "0.1.0",
  "category": "Fx",
  "kernel": {
    "package": "@codex-music/audio-kernels",
    "profile": "profiles/tone-pedal.profile.json",
    "abiPrefix": "sctone_"
  },
  "ui": {
    "dist": "dist-plugin"
  }
}