Akai S2000 Rosetta OS (WIP)

New tricks for the Akai S2000 sampler. Rosetta OS is a patch kit for the stock OS 2.0: you build a boot floppy image from your own S2000 OS disk and boot it from a Gotek (FlashFloppy). It unlocks the voice chip's hidden delay engine as effects with their own EFFECTS page (no EB16 effects board needed), puts the live input through them, including a tempo-synced live reverse delay with its own menu, adds an MPC-style home screen and menus, one-button sampling, and a synth layer (analog drift, detune, filter LFO on MIDI CCs). It also gives the S2000 64 KB of room for new code, loaded from the boot floppy after boot, so there's space to build much more. Nothing touches ROM or flash: boot your stock disk and it's an S2000 again.

Made by JunkSmithWizard (JSW) together with Claude (Anthropic's AI). Claude wrote the code and did the reverse engineering: NEC V53 disassembly, a whole-OS emulator, and the hidden delay engine measured over MIDI. JSW ran every build on a real S2000, built the measurement rig, and made the calls by ear. Same family as the GP-16 Rosetta OS, which the boot dragon comes from. Questions, hardware reports and ideas: Discord.

Demo

Listen: rosetta_fx_demo.mp3 (0:58, recorded from a real S2000 running Rosetta 0.10)

⚠ AUDIO WARNING: turn your volume down first. The test sounds are harsh: noise bursts and a 1 kHz beep.

• 0:00: noise burst, 3 hits per effect (~5 s each): OFF, ROOM, HALL, PLATE, ECHO, PINGPONG, CHORUS, FLANGER.
• 0:42: 1 kHz beep: OFF, CHORUS, FLANGER.

What it adds

The hidden delay engine

The S2000's voice chip (L7A1045) has a delay engine built in: one 65,536-sample line (~1.49 s at 44.1 kHz) and 30 taps. Each tap has its own gain and a route: left out, right out, or back into the line (feedback). The stock OS barely uses it: one preset for recording, plus a reverb-like preset that is never called.

We mapped it from a PC: Rosetta's SysEx backdoor writes taps, the PC fires a noise burst over MIDI and records the outputs, and deconvolution shows every tap (tools/irmeasure.py). Delays land within 1 sample of the table. Then:

• Reverbs are multi-tap feedback loops designed offline in a Python model of the engine (tools/fxdesign.py), with exact Q15 gains (the OS's own 8-bit levels halve the decay).
• Chorus / flanger sweep tap delays from an LFO every tick (0.51 ms). Two neighbouring taps crossfade for fractional delays, so the sweep is smooth with no clicks.
• ECHO / PINGPONG are plain taps plus feedback (375 ms echo, 300/600 ms ping-pong).

One delay line means no series allpasses, so the reverbs have a metallic, digital character. Cool, but there's room to grow (modulated feedback taps are next).

Reverse needs more than taps: on notes, Rosetta copies chunks of the delay line out to sample RAM, flips them, and plays them on spare voices. On the live input it goes further: the chip's own input DMA is pointed at a ring buffer Rosetta fills, in stereo mode. The left channel is your input (the dry monitor). The right one is the previous chunk of the input backwards, played on its own voice with its own envelope, volume, filter and send.

Using it

Panel names: F1 / F2 = the two buttons under the screen, SINGLE = the home key, SAMPLE = REC.

• EFFECTS: the first press opens the FX page; pressing it again picks the next effect. F1 / F2 move the >; the DATA wheel and the PAGE/GROUP keys change the value.
• MFX (input FX): on the sampling screen (SAMPLE), press EFFECTS. Same page, but WET is IN: how much of the input goes into the effect. EFFECTS again = next type, SINGLE = back to the meter. You hear it live; the take still records dry. One delay engine, so the type, time and feedback are shared with the notes' FX page.
• Live reverse: pick REVERSE or REV HALL on the MFX page and turn IN up. The page becomes the REV menu: PAGE ▲▼ = page, F1 / F2 = knob, wheel or GROUP ▲▼ = value. The rocker walks the knobs straight through all four pages (full push = a whole page).

SAV writes one 1 KB block of the boot floppy (inside the OS file, so the OS's own SAVE never touches it); the knobs come back at the next boot. It only writes when you ask. tools/stick.py carries saved knobs over when a new build goes on the stick.

Long chunks and octave up store the input at 22 or 11 kHz, so the reversed copy gets darker (the dry never does). While live reverse runs, the monitor is ~12 ms late (stock: ~3 ms).

• ROSETTA ROM: right after boot, turn the DATA wheel on the main screen to pick program 1-9 (RS SAW ... RS PLUCK) and play. SUPERSAW and PAD stack 3 detuned voices per note, BASS 2. The SYNTH CCs below (drift, detune, filter LFO) turn them into a moving analog-style synth.
• SYNTH (the MULTI key; stock multi mode is not used): SYN <program> / < ANALOG > GO. The wheel or rocker picks the mode, F2 = GO. Then 4 pages like the REV menu (F1 / F2 or the rocker = knob, wheel = value, PAGE = page, home = back to the mode menu, home again = HOME):

Edits go to every keygroup of the selected program number; save the program with the stock SAVE to keep them.

• HOME (main screen): line 2 shows LOAD <effect> EDIT. Left button under the screen = LOAD, right button = EDIT program.
• Menus: EDIT (program), REC → EDIT (sample) and TUNE (global) open a menu like EDIT PROGRAM 1/8 / >SAMPLES+ZONES. DATA wheel or PAGE picks a group, the right button goes in, the left button goes out. Inside a group, PAGE loops through that group's pages and GROUP jumps to the next group.
• REC: opens on the input meter. Right button = ARM: the take starts when the sound passes the threshold, or press GO (left button) or REC to start now. REC = start/stop: hold it and the take stops when you let go; tap it and the take runs until you tap again (mono; the sample is cut to what was recorded, up to the SETUP length). Left button = SETUP (name, length, mono/stereo, pitch, threshold); home = back to the meter. After the take you land on the sample select page.
• Home key: back one level (page → menu → HOME).
• PLAY: auditions the current sample when no program is loaded.
• SYNTH (any MIDI channel, all 0 = stock): the boot screen says ROSETTA+ READY / SYNTH CC 20-25 when the extra code is in.

Quick start (build your own disk)

You need: your own S2000 OS 2.0 floppy as a Teledisk .td0 or raw 1.6 MB image, Python 3.10+ with numpy, NASM on PATH (or $NASM), a Gotek with FlashFloppy, and one HFE template of an Akai HD floppy (e.g. your stock OS disk converted with the HxC Floppy Emulator software; every sector is overwritten, only its track layout is used).

python tools/td0.py s2kos2.td0 build/s2kos2.img
python -I tools/mkbaby.py build/s2kos2.img template.hfe build/S2K_ROSETTA

1. Copy build/S2K_ROSETTA.hfe to the Gotek's USB stick as DSKA0000.hfe, with FF.CFG set to nav-mode = indexed. Keep one image on the stick. To update a stick that has saved knobs on it, use python -I tools/stick.py build/S2K_ROSETTA <drive> instead: it keeps them.
2. Boot the S2000 from the Gotek. The dragon flies, then the HOME screen.
3. The disk also carries a small test kit (CLICK, NOISE BURST, BEEP 1K) to LOAD from the same floppy. It's built with the akaitool package from AKAI-CD-ISO-MAKER (clone it next to this repo or set $AKAITOOL), or set TESTKIT=0 to leave it out. The ROSETTA ROM synth waves and programs (tools/rompler.py, 30 KB) go on too; ROMPLER=0 leaves them out.

Every patch checks the stock bytes first, so a wrong OS image fails loudly instead of building junk.

Build your own features (the extra 64 KB)

The menu code (src/rosetta_menu.asm and friends, 5.6 KB) is full, so new features go in the hi code:

• src/rosetta_load.asm (285 B, in free space before the dragon) reads the hi blob from the blocks right after the OS file on the boot floppy, on the first main-loop tick, through the OS's own raw floppy read (1F50:00BB). It checks the RSHI magic, then calls the blob's tick on every main-loop tick. Popups: LOADING / READY / FAILED.
• src/rosetta_hi.asm hooks the OS at run time from a patch table (segment, offset, stock bytes, new bytes); every stock byte is checked first, so nothing points at the hi code unless it really loaded. The OS calls fixed slots in the blob's header, so a new build can be sent in live: py -3.10 tools/hiload.py (SysEx, ~2 s).
• Hooks used so far: pitch (2345:5611, semitone × 256 before the exp table, so cents add linearly), filter target (2345:59CD, log 0-FFF, the chip glides to it every ~15 ms), MIDI CC (2B9D:01AE). The note-on path, voice table and chip registers are in docs/FINDINGS.md; ideas in docs/ideas.md.
• Timing: the OS tick [73DA] is 0.511 ms on hardware (1957 Hz).
• The live input path, the DMA channels and the voice-chip registers as used (incl. two traps: a 0 written to the volume register keys the voice off, and big envelope steps never move) are in docs/FINDINGS.md.
• tools/lrsim.py runs the live-reverse engine's real machine code in unicorn against a simulated ADC ring and DMA pointers and checks every mode against numpy. It caught three bugs before they reached hardware.
• The emulator can run the whole thing: s2k_ui.py uses the build's .img as the floppy (S2K_DISK, S2K_DISK_AT to insert it after the OS's boot-time disk read so notes play).

Also in the box

• tools/s2kfx.py: the PC side of the FX lab (SysEx F0 7D 53 ...): ping, peek, poke, outw, sel (pick an effect), load (tap tables), note, rec. tools/irmeasure.py and tools/demo.py measure and record. tools/hiload.py hot-loads the hi code.
• tools/s2k_emu.py + tools/s2k_ui.py: a unicorn emulator that boots the real OS to the main screen and presses keys (seq, fxcheck, pagewalk, isrcheck, ...). Needs unicorn and capstone.
• tools/x86dis.py, tools/sweep.py: V53 disassembly helpers (code map, port map, xrefs).
• tools/td0.py, tools/hfe.py: Teledisk and HFE converters (HFE overlay with CRC check on read-back).
• tools/stick.py: writes a build to the Gotek stick (checks for FF.CFG), keeping the knobs saved on it.
• docs/FINDINGS.md: the lab notebook (hardware map, code map, sound engine, build history).
• docs/menu_design.md: the menu redesign plan. docs/pagewalk.txt, docs/ui_tree.txt: stock UI maps.

Walls we hit

Notes for anyone hacking an S2000 / S3000-family sampler (L7A1045 voice chip, V53 CPU). Details in docs/FINDINGS.md.

• The boot ROM loads only 256 KB of OS. No room left for big features. Way round: a tiny loader in the OS reads more code from the boot floppy into CPU RAM the OS never uses (0x40000-0x4FFFF), after boot.
• There's no FX chip without the EB16 board, but the voice chip has a delay engine (one 1.49 s line, 30 taps) that the stock OS barely uses. We mapped it from a PC: SysEx backdoor + noise burst + deconvolution.
• One delay line = no series allpasses. The reverbs are multi-tap and sound metallic. Real smooth reverbs need a DSP board in the EB16 slot (hw/smart_eb).
• The filter is fixed: one resonant low-pass per voice, no hidden modes. We poked every filter register on hw: the undocumented second bank (ports E0h-E4h) changes nothing, and reg 6 word 2 is the filter's internal state (writing it = loud stuck rumble). Filter "flavours" can only be movement (curves, envelopes); real character means analog filters on the 8 individual outs (hw/ib208_clone).
• Loops need the wave on both sides. The interpolator reads 6-9 samples past a loop end and a few before the loop start after the jump. A single-cycle loop with other data around it in sample RAM clicks every loop (our rompler "crackled"). Store some of the wave before and after the loop.
• Moving delay taps crackle (OPEN). Chorus-type FX crossfade two taps between neighbouring delays. Same-value writes, small gain steps and 1-2 sample moves are clean one by one, yet the running LFO clicks on held chords. Writing a pair's lengths first and both gains back to back halved it. Hunt plan: docs/crackle_hunt.md.
• The CPU is slow for audio. A per-sample loop over 44.1 kHz eats ~80 % of the V53. Live reverse moves chunks with string instructions instead (~40 %) and has ~12 ms latency; no multiplies per sample.
• Sample-RAM DMA disturbs the even voices (it rewrites their start-address high bits). Rosetta plays its own voices on odd numbers.
• Writing the floppy: the OS has a raw sector read; flipping two immediates (DMA mode, FDC command) for one call turns it into a write. That's how SAV keeps knobs on the boot floppy.
• Lab hygiene: a SysEx poke into RAM must use addresses from the build that's running. A poke from an older build's symbol map hung the sampler once.

Status: work in progress 🚧

It boots, and the FX, menus, sampling and synth layer work on a real S2000. Expect rough edges.

Known issue: the moving FX (CHORUS, FLANGER, JUNO, TAPE) crackle on held chords (Walls). The static ones (ROOM, HALL, PLATE, ECHO, PINGPONG, DUB, RESO) are clean.

Planned:

• SYNTH page modes: FAKE FM and WAVETABLE (move a voice's loop through a table); unison.
• A SAMPLE menu: LOOPER, MPC and KEYBOARD modes.
• Live reverse: follow MIDI clock, a lower-latency fill from the timer interrupt.
• Freeze / resonator / shimmer effects, tempo-synced echo, denser and modulated reverbs.
• Quick jobs (load → audition → assign in a couple of presses), stereo hold-to-record.

Ideas, bug reports and test results are very welcome: open an issue or come to the Rosetta Discord.

Legal

Not affiliated with or endorsed by Akai Professional or inMusic. "Akai" and "S2000" are trademarks of their owners. This repo contains no Akai code or data: you build from your own OS 2.0 disk, and the test-kit sounds are synthesized. Build at your own risk; always keep your stock OS disk.

License: MIT (see LICENSE).

Thanks for enjoying, and God bless you! — JSW