A remixer for the Elektron Octatrack's operating system. Pick the modifications you want — the community's and this project's own — and build them into one firmware image from your own copy of the stock OS.

The Octatrack runs OS 1.40C on a ColdFire CPU and a two-core DSP. Several people modify it: new effects, MIDI scene locks, 256 Kits per project, bug fixes. Each started from the same reverse-engineering and each built their own way, so no two of them could share a unit. octabam is the common toolkit: a modification is a module, a selection of modules is a remix, and the build composes a remix into an image — placing code, wiring hooks by symbol, refusing collisions by name, and proving every port against its author's own build byte for byte.

No firmware is distributed here, and none may be. You supply your own 1.40C; every image is derived from it, reproducibly, on your machine.

This is a fork of sambanks/octabam, branch panel-ui. Everything below this section is Sam's project as it was forked; this fork adds, on top of it:

Looking for the firmware modules? Their current home is timhastie/octatrick: the modules (FM synth, scale quantizer, direct jump, tuner) on current octabam main, with remixes that add USB MIDI and USB audio (running on an Octatrack MKI); the sources live in timhastie/octatrick-modules. This repository's upstream-port branch mirrors it; panel-ui is the emulator and panel work on the older base.

• A virtual front panel for the emulator (tools/panel/): the whole Octatrack panel in a browser page or a macOS app, with the LCD, every key, encoder, LED colour, the crossfader and scenes, driven by the real firmware running in the emulator. The panel link protocol, the key matrix and the LED map are documented in tools/panel/PANEL_LINK.md and tools/panel/KEYMAP.md; the panel itself in tools/panel/README.md.
• The emulator in real time, with sound: the C++ machine (tools/emu/ot_emu, Sam's) now runs both DSP cores under the dsp56300 JIT as workers on the lockstep schedule, paced to real time, with the main, cue and eight per-track outputs available through CoreAudio, persistent card images with write-back, and the effects rendering correctly (milestones O15-O24 in CONTEXT.md).
• Three firmware modules built with octabam's module system, ColdFire only, DSP payloads stock (REMIX=tim make cf, make image-cf): modules/synth (a two-operator FM synth machine on any FLEX track whose sample is named SYNTH*.wav, with its own PLAYBACK page, paraphonic chords, VOIC/CHRD on the LFO page, and note lengths recorded from live playing), modules/quantizer (a SCALE row: the PTCH knob, locks and CHROMATIC keys snap to a scale; GLIDE with 303-style legato), and modules/direct-jump (CHAIN AFTER gains DIRECT). All three have been flashed and used on an Octatrack MKI by the fork's author; see CONTEXT.md for the build history and the hardware notes.

Unofficial. Not affiliated with, endorsed by or supported by Elektron. As in octabam, no firmware is distributed here: every image is built on your machine from your own copy of OS 1.40C, and modifying your unit's firmware is outside Elektron's licence terms and warranty. Read docs/remixer/FLASHING.md before flashing anything.

Credit, beyond the octabam credits below. The voice engine of the synth builds on the trig and voice-structure findings of mxldyn/octamax and on Bryan T's EMAC notes (docs/firmware/EXTERNAL.md); the flash images are packed with mischa85/elektron-firmware-tool; the emulator cores are Musashi and the dsp56300 emulator. Nearly all of the code in this fork was written with Claude Code, directed and tested by the fork's author.

From the community, built from the authors' own repositories:

From this project — the DSP effects it began as, and the ColdFire patches that grew around them:

make modules prints the authoritative index, the compatibility matrix (which ColdFire-side modules can share an image, from the same check the build makes) and every remix. A README is a copy of that; when they disagree, the tool is right.

make setup          # toolchain: DSP56300 assembler + emulator, m68k-elf, firmware tool (macOS + Homebrew)
make os             # download the official 1.40C — your own copy
make recon          # unpack it -> out/raw/section_3_MAIN_OS.bin
make modules        # what exists, what composes with what, the remixes
make check REMIX=ported      # MIDI SCENES + LOFI AMF FIX: build, gate, boot under the emulator
make image REMIX=ported BUILD=101   # repack as a card-flashable .bin, version-stamped

git submodule update --init fetches the community sources the first time. make remix opens the TUI remixer (make emu-setup provisions it): the library of everything that could be in an image, the choosers the unit will show, every effect auditionable by ear, and the built image booted in the local ColdFire emulator. docs/remixer/REMIXER.md is its manual.

OCTAKIT and MIDI SCENES share an image through a bridge. Both hook the same stock routine (apply_part, 0x40009094) and both want the MIDI CC dispatch; modules/scenes-kits chains them — his pre-work, then her engine load; our CC cave, then her handler, then stock — and the build refuses the pair without it. What the bridge does not settle is his Part save/reload menu hooks against her Kit menus: unmeasured, and the next thing to look at with both authors (modules/scenes-kits/README.md).

modules/<name>/manifest.py   what a module IS and what it claims   (yours, or a pointer into an author's repo)
remixes/<name>.py            which modules, in which chooser order
tools/remix/ledger.py        refuses two modules that claim one address, hook, id or buffer — by name
tools/build/build_bus.py     THE build: assembles, links, places, wires, verifies -> out/mainos_bus.bin
tools/verify/*               the gates: oracles, the boot under the ColdFire port, menu, cycles, identity

A module's code lands in one of three places, and the build decides which bytes go where — a module declares what it is, not an address:

The OS-image edits every class needs — a detour at a stock instruction, a poke, a grown table — are Detour, Poke, TableGrow, wired by symbol and asserted against stock before a byte is written. docs/remixer/PLACEMENT.md is the map: what is free, what was measured, and the one retraction.

A port is a proof. The build re-links every unit at the author's own address and compares, rebuilds Em's runtime to the identities her recipe pins, and refuses on any drift. What the community gets is not a copy of their work but their work, placed by a build that can see everyone else's. What the DSP side has always had — make check, the local render at ~6× real time, the 26-configuration bit-identity gate for changes to the build itself — the ColdFire side now has too: every DRAM remix boots under the ColdFire port and its window is read back against the linked image before the image is called built.

Two shapes, both worked examples in the tree:

• Build from your repository. Your repo becomes a submodule under modules/<name>/upstream; the manifest points Linked units at your .s files (or a Runtime at your recipe). You keep developing where you are; an update here is a submodule bump plus your oracle still holding. modules/midi-scenes and modules/octakit are this.
• Write the module here. Copy modules/_template_cf/ (ColdFire) or modules/_template/ (a DSP effect), read modules/hello-dram/ or modules/hello/, follow docs/remixer/MODULES.md.

What makes either painless: code in GNU-as with symbols rather than absolute addresses, an artifact of your own build to prove against, and never an Elektron byte in your repo — .incbin what you need from the user's stock image at build time, as Octakit does. CONTRIBUTING.md has the whole contract, the gates and the etiquette.

A flash is manual and slow, so the project is built around not needing one to make a judgement. The DSP side renders locally on the real assembled instruction stream (make render, make render-rig, make reverb IN=loop.wav; docs/remixer/HARNESS.md); the ColdFire side boots the built image under a headless port of the machine (make emu-cf; docs/firmware/COLDFIRE_PORT.md) and, for the firmware's own screens, under Unicorn (docs/remixer/EMU.md). make check runs everything that can be checked without hardware. It is the floor, not the ceiling: what the emulators structurally cannot see — caches, the recorder, cross-core timing — is listed beside every gate that is blind to it.

Writing a non-official OS to an Octatrack can leave it unusable, and it puts your warranty in question. Nothing here is endorsed by, supported by, or affiliated with Elektron. If you flash a modified image you do so entirely at your own risk. docs/remixer/FLASHING.md has the recovery path — read it before you need it — and docs/remixer/FAILURE_MODES.md the register of what has gone wrong on a unit and why.

Nothing built by the new ColdFire pipeline has been flashed yet (10 Sep 2026). The community authors' own builds are what has run on hardware; this project's bus engines and ColdFire patches are on Sam's unit. Back up projects before flashing anything that changes them (Octakit migrates Parts to Kits on load; downgrading may lose Kit data — her warning, and it applies).

MKI and MKII run the same 1.40C image (hash-verified), so an image should run on either; everything here has only ever been tested on an MKII.

No Elektron binary is redistributed here — and none may be. make os downloads your own copy; the tooling regenerates Elektron's image byte-for-byte before it will produce a modified one. The same rule binds you onward: a built .bin or .syx contains Elektron's OS — do not share built images. Share the repo; everyone builds their own.

Octatrack and Elektron are trademarks of Elektron Music Machines MAV AB, used here only to identify the hardware this project targets.

PLAN.md            Read this first: the programme, where it stands, the ground, the work order.
CONTRIBUTING.md    The module contract, the oracle rule, the gates, submodule etiquette.
modules/           The contributions -- one directory each. This is the product.
remixes/           Named selections of modules, in chooser order.
tools/remix/       The toolkit: schema, registry, ledger, the loader, the DRAM platform, the TUI.
tools/build/       The image build (build_bus.py) and the tools that understand the OS layout.
tools/verify/      The gates.
tools/harness/     Hear and measure the DSP side locally (dsp_host, send_probe, rig_render).
tools/emu/         The ColdFire emulators: the headless port (ot_emu) and the Unicorn bring-up.
tools/hw/          The unit and its card: MIDI control, capture, project files, MIDI flashing.
tools/patches/     Local patches to the vendored toolchains.
scripts/           Toolchain setup, OS fetch and recon, the bit-identity gate.
dsp/               Shared DSP infrastructure: the null stub and the probes.
docs/remixer/      Using and extending the remixer: MODULES, PLACEMENT, REMIXER, TOOLING, FLASHING.
docs/firmware/     The firmware, reverse-engineered: ARCHITECTURE, DSP, CHIP, PARAM_PAGES, MAINMENU, the port.
docs/effects/      The effects programme: REVERB, BUS, XBUS, VOICING, CAPTURE, FLASHPLAN.
docs/history/      Closed records, kept for provenance -- including the effects-era PLAN.

Em (emuyia) designed Octakit, and with it the loader-appended DRAM runtime that octabam adopted whole as its large-payload placement: her early loader, stage, hash gate and post-clear relocation are the measured reverse-engineering this platform stands on; tools/remix/loader.S is derived from hers with attribution. Her repository explicitly invites being used as a submodule to combine with other efforts; that is what this is.

bkkbrls-del wrote midisc and was game for its rebuild in GNU-as form; the octabam-gas branch waits on his own finishing touches before it goes back to him as a PR.

Bryan T answered the project's oldest open question — where the stock Echo Freeze Delay lives (in ColdFire SDRAM, eight 1.4 MB rings, the very region the DRAM measurement then found being cleared at boot) — along with the timestretch architecture, the DSP data-table atlas and the recorders' control path, recorded with its own confidence markers in docs/firmware/EXTERNAL.md. He also contributed modules/hello, and the AMF fix is his.

This began as a fork of mxldyn/octamax by Maxolydian, whose reverse engineering of the OS format, memory map and parameter tables made any of this reachable; the upstream history is in this repository's log.

vendor/ pulls in dsp56300, mc68k and elektron-firmware-tool.

MIT for this repository's own code and documentation. It does not extend to Elektron's firmware, which is not distributed here, nor to the community repositories referenced as submodules, which remain their authors' under their own terms.