MONO2K

Six mono machines for the M-VAVE FM-1. A Monomachine-style synthesizer firmware: six tracks, each one machine, a 64-step sequencer with parameter locks, trig conditions and ratchets, and a lofi bus that breaks the sound beautifully. A 1-bit screen: dithered type and machine marks, Swiss grid, PS1-era glitches.

Status: 1.0. The core (sound, sequencer, screen) runs in the browser, on a computer and on the FM-1. The FM-1 build (firmware/fm1/: the open FM-1 platform around this core) keeps one project of 64 patterns (bank A the demos, B–D blank). MONO2K 1.0 for the FM-1 installs from The Firmware Hub or the installer.

Try it in your browser: https://inigohernandez.github.io/mono2k/ (the firmware's own core, compiled to WebAssembly, with sound).

On the FM-1

• What it keeps. MONO2K saves into its own store, the last 128 KiB of the FM-1's data area (0xC0000–0xE0000): one project of 64 patterns and its sound library. It does not read the projects, presets or samples of other firmwares, and its first save overwrites whatever another firmware kept in that area. Back up with the firmware you are on before you switch.
• Back up MONO2K. The Patch Editor reads the FM-1's store over USB (Chrome or Edge) and saves it as a .m2ks file; it writes one back the same way.
• Leave it. Install another firmware as usual (the FM-1 Firmware Hub, or its maker's installer): MONO2K starts the new package's update loader, as Felucca does, whose loader it carries.
• USB. It shows up as a MIDI device named "MONO2K FM-1" and answers the identity FM-1_980. While it updates, the update loader shows up as "Felucca Update", the loader being Felucca's.
• Rescue. Hold OCT− while switching on: the FM-1 starts the updater only and waits for a package over USB.

Run it

sh web/build.sh

python3 -m http.server 8742 --directory web

Then open http://localhost:8742, press Start, click the panel and play (Z… for keys, Space PLAY, A GRID, 5 SYN).

Host build (renders the factory patterns to WAV, tours the pages and saves the screens as PBM; with --analyze, renders every pattern and solos every track, flagging what is too quiet, clicky or clipping):

cc -O2 -Wall -Wno-unused-function -Ifirmware/src -Ifirmware/gen -o build/host/m2k_host host/m2k_host.c -lm && build/host/m2k_host build/host

What is in it

Machines	GND-SIN, GND-NOIS, GND-PERC, SID-6581, FM+STAT, FM+PAR, FM+DYN, SWAV-SAW, SWAV-PUL, SWAV-ENS, DIGI-WAV, VOX-6, FX-CHORUS, FX-RINGMOD, FX-DYNAMIX (on the track before): clean-room designs after the Monomachine's families, integer only. DRM-KICK, DRM-SNAR, DRM-HATS, DRM-CYMB: drums after the LXR's voices, on its laws
Per track	the Monomachine's chain and pages: SYN A–H · AMP (ATK HOLD DEC REL DIST VOL PAN PORT) · FILT (HP / LP as base and width following the note, resonance, envelope) · FX (EQ, SRR, a delay of its own in 8-bit mu-law, ping-pong on positive sends) · DSTR (bits, fold, xor, SPU send) · 3 LFOs (any track's parameter) · ARP
Projects	the modern Elektron way: 4 projects × 4 banks (A–D) × 16 patterns (on the FM-1, one project of 64), each pattern with its own sounds. SAVE keeps the pattern (its reload point), GLO + SAVE reloads it, SAVE held keeps the project; GLO + REC / PLAY / SEQ copy, paste, clear (the pattern on HOME, the track's sound on its pages); GLO > SET picks and loads a project. On the web: a project picker, export / import as .m2kp files. Stored packed (a typical pattern 0.5–1 KB; the DEMO project 32 KB)
Factory	project DEMO, bank A: four parts, CIRCUIT, TIDE, SUSPEND and LANTERN (docs/bank-a.md: how they were made, key and idea of each), every sound picked by the owner from sound sheets; A05–A16 and banks B–D blank. A store saved with earlier demos takes the new ones where the old still stand
Sequencer	6 × 64 steps, note / accent / slide, parameter locks, the Monomachine's trig types (each step trigs the amp, the filter's envelope and the LFOs independently: step + VOL, ALL ... NONE, a trigless lock), trig conditions (chance, A:B, 1ST, PRE, FILL), ratchets, Grids' lanes (Mutable Instruments' map), mutes on the bar, swing, live recording and step entry (REC while stopped), pages held to set the length, patterns queued at the bar
Bus	a feedback-delay-network reverb at 22 kHz (RT60 0.3–24 s, DAMP the top's decay 1/1–1/30), a glitch whose one knob grows from rare quiet ghosts to wild (repeats, reverse, gates, octaves, rolls, slowing; every change crossfaded), tape wow and flutter, 4-bit ADPCM crunch, hiss and dust, drive; each control on a law measured over its whole range
MIDI	tracks 1–6 on six channels from GLO > MIDI's CHAN (1–6 at first), the others play the track in view: notes and the Monomachine's CC map (SYN 48–55, AMP 56–63, FILT 72–79, FX 80–87, LFO 1/2/3 on 88/104/112, level 7, mute 3). SYNC IN follows a MIDI clock (its tempo, a step every sixth pulse, the swing kept; start, continue, stop) from USB, the TRS jack or both, SYNC OUT sends one (24 a beat, start, stop), NOTES OUT each track's trigs on its channel. GLO > IN: where notes and CCs come from (both, USB, TRS, none), and a thru of the jack's MIDI out over USB. The emulator picks a MIDI device in (as USB) and one out

Where things are

• firmware/src/m2k.h: the API the platform calls (render, keys, buttons, encoders, MIDI, frame, LEDs, store).
• firmware/src/m2k_core.c: the unity build; m2k_dsp.c machines and the track chain, m2k_fx.c delays and the bus, m2k_seq.c sequencer, m2k_factory.c the factory patterns (a step grammar), m2k_proj.c projects, banks and the store, m2k_gfx.c 1-bit drawing, m2k_ui.c pages and controls.
• tools/gen_tables.py, gen_font.py, gen_icons.py: the tables, fonts and marks, into firmware/gen/ (Pillow and numpy in .venv).
• web/: the site: the emulator page, the manual, the installer (MONO2K for the FM-1, the same file as the latest GitHub release; it is on The Firmware Hub too) and the patch editor; m2k_web.c is the core plus exports, worklet.js runs it, app.js draws the panel, manual.js and editor.js read the machines and their knobs off the core.
• host/m2k_host.c: the host harness.

The next steps

1. On the FM-1 (firmware/fm1/README.md): MONO2K 1.0.1 is released, on the installer, as GitHub releases and on The Firmware Hub. Next: the CPU load read on the device with a --diag build (A03 SUSPEND and A04 LANTERN are over Felucca's yardstick on paper), and a store that survives a power cut during a save (two slots in the flash).
2. Calibration against the Monomachine, machine by machine: levels, spectra, the machines' own envelopes. The amp envelope, SWAV-SAW, SWAV-PUL, SWAV-ENS, the three FM+, SID-6581, GND-SIN, GND-NOIS, FX-RING, VO-6's voice and the whole track chain are done (below); VO-6's consonants and V-SW's switch are next. Driven hard, all of them meet its ceilings.
3. More machines (DPRO-BBOX, FX-REVERB and the rest of the FX family) and songs.

Author

MONO2K is made by Sequencist: GitHub · Bandcamp · YouTube · Instagram · SoundCloud

Calibration

MONO2K's machines are its own, but they are measured against the Monomachine. tools/ref/mm_ref boots an owner's Monomachine OS image in gearmulator-md-mm's emulation and plays it over MIDI only, as the instrument is played; host/m2k_ref.c plays MONO2K the same way; the scripts compare them. The OS image is read from the path given and never copied: no ROM, no ROM code and no recordings of it are in this repo.

cmake -S tools/ref -B build/ref -G Ninja -DGEARMULATOR=/path/to/gearmulator-md-mm && cmake --build build/ref
build/ref/mm_ref /path/to/os.bin render build/ref/mm < tools/ref/amp.spec > /dev/null
build/host/m2k_ref build/ref/m2k < tools/ref/amp.spec
.venv/bin/python tools/ref/envtimes.py build/ref/mm build/ref/m2k

Done so far, all measured on OS 1.32B:

• The amp envelope. The attack rises in a straight line in 0.90 ms × e^(0.0814·v), decay and release fall 20 dB in 8.3 ms × e^(0.0665·v), the hold lasts v / 32 of a beat at the tempo (32 is a beat, 8 a sixteenth: measured at 60, 120 and 240 BPM within 0.3 %, tools/ref/chain_hold46, group hold; it was a fixed 14.6 ms a step until format 13, fit at one tempo); a key let go ends the hold and the decay. MONO2K followed within a few percent from 0 to 127 until pattern format 16, when the owner chose laws of MONO2K's own for ATK, DEC and REL (gen_tables.py): the knob spent where the times are useful (ATK 0.4 s at 64, 10 s at 127; DEC and REL 0.8 s at 64, 20 s at 127), the attack the square of its time, the time shown the one heard (ATK to full, DEC and REL to -60 dB). Older patterns convert to the value that sounds nearest; the kick cases measured against the Monomachine's DEC are XFAIL for it (group kick). The LFOs too: SPD a cycle in 2^((84 − SPD) / 12) beats, DPTH squared about 64.

• SWAV-SAW on SWAVE-SAW's page: the unison pairs' detune and levels, the square and sine subs, within 0.2 c and 0.5 dB (tools/ref/swave_saw*.spec).

• SWAV-ENS on SWAVE-ENS's page (tools/ref/chain_ens15..20.spec, ensacc): PCH2–4 off its interval table (−12 to +12 semitones, 61–63 OFF, the just 3/2 4/3 5/4 6/5 beside their equal-tempered neighbours: all 66 group ends within 0.4 c); a voice two saws an octave under its note, the second PW/128 of a period on, WAVE fading their sum out and their difference in at 0.63 (levels within 0.8 dB over WAVE × PW); no level shared between the voices (0.4 dB); TUNE ±2 semitones (0.7 c); CHRL the chorus's mix (within 1.5 dB). Bank A's chords, converted, against the Monomachine's voice by voice: within 0.5 c. The chorus is stereo, as the Monomachine's (chain_ens41.spec, group ens_stereo, 12 s held): two copies off a half-rate line, each delayed by a sine at 0.2 Hz swinging ±16.8 c, the second a quarter turn on; CHRW sets them apart across the stereo (the left hears (1 + w) / 2 of one, the right of the other, w = 0.355 (CHRW / 127)^1.15), each channel at one copy's level. L/R correlation 1.000, 0.991, 0.954, 0.887, 0.795 at CHRW 0, 32, 64, 96, 127 against the Monomachine's 1.000, 0.990, 0.956, 0.890, 0.787; the copy's side within 0.5 dB of its. Known gap: at CHRW 32 the Monomachine's channels already swing a quarter turn apart (±16.7 c each) where MONO2K's stay closer (28°, ±11.6 c). The side runs through the track's own filters, amp and SRR (linear: the clip's ceiling holds it; the fold and XOR, MONO2K's own, leave it).

• FM+STAT, FM+PAR and FM+DYN on their pages (tools/ref/chain_fm26.spec, group fm): a sine carrier on the note at half GND-SIN's level, phase-modulated by sine operators side by side, every phase reset at the trig, the carrier's half a cycle on from its modulators (as the Monomachine's harmonics' phases read: a ratio-1 modulator turned over, a ratio-2 one not).

Patterns saved before are moved onto each new scale as they load (version 1: the envelope; 5: the chain, each old setting to the one giving the same Hz, dB or time, the filter placed against the note each track plays most; 6: GND-SIN's TUNE, which moved a semitone a step, kept to the semitone within the new ±2; 7: SWAV-ENS's page, each old interval folded into −11..+12 by octaves, one folding to 0 to +12, keeping every chord's notes; its DTUN (a fixed spread, not the chorus's moving copy), shape, level and sub have no counterpart and reset; a trig the old level silenced has its intervals locked OFF; an LFO aimed at the old page is cleared, intervals included, since the new axis has OFF and an octave down in it; 8: the wave bank's choice, MONO2K's 32 for every older pattern; 9: the bus's controls on their new laws, each old value to the new one that measures the same, HISS by its crackle; 10: FM+STAT's and FM+DYN's pages, MONO2K's old ones carried over as near as the new pages go, not as they sounded: the old operators ran in series, the new side by side; each ratio, depth, decay and feedback to the new page's nearest, SWEP to 1FEN; a lock goes with its parameter where it has a place; 11: SID's page, the first oscillator's wave, duty and PWM, MODE and the second's interval carried over, WAV2, FINE and MIX without a place).

The bus's controls are MONO2K's own, so their laws are a design choice, made by measurement (m2k_host DIR --bus, tools/bus_curves.py: every value of each on a reference loop). Before, most of each range sat past where it was already intense: GLCH 10 replaced the mix a tenth of the time and DRIV 10 drove it 2.9 dB into the knee; HISS's crackle came in long before its hiss could be heard; TAPE's wow grew 0.33 c a step to ±42 c; ADPC had three sounds over 64–127. Now GLCH, DRIV and HISS's crackle put the old 10 at 64 and grow by a ratio a step (0.3 % a sixteenth at GLCH 1); TAPE puts the old 20 (±6.4 c) at 64; HISS's hiss has its own law (65 dB under the mix at 1, 40 at 64); ADPC keeps 0–64 and its rate falls continuously above. The old extremes stay at 127. Measured on the old engine and the new, every old value converts to one that measures alike (the hiss there as loud or louder: its law brings it in sooner); tools/check.sh holds both.

Pattern format 17 rebuilt the bus's effects at the owner's word ("the glitch sounds intense low", "the reverb always sounds the same", "the first third of the delay's send does nearly nothing"). The old reverb's damping left little but a dull 0.2 s burst and a bass rumble at most settings (its octaves over 500 Hz died in 0.2 s from DAMP 64): the new one is a four-line feedback delay network (Hadamard matrix, two lines turned into each other by a swaying angle, every recursive product carrying its remainder, asleep once silent), RT60 0.3–24 s with the room's size, DAMP a one-pole a line giving the top's RT60 1/1–1/30 of the bottom's. The sends (VERB, DSND) are straight in level. GLCH went from full-level replacements (16 dB under the mix even at 1) to a law in rate, level, length, the dry's share and the modes (44 dB under at 1). PERFORM's repeats lock to the grid, every effect crossfades in and out, DRIVE holds its level. Old patterns convert by measurement (tools/conv17.py: the reverb to the pair nearest by its octaves' RT60s and each send by the level that keeps it as loud; GLCH by its glitch's energy and events; the sends' squares to straight levels); bank A is turned so at build (its reverb's return within 2 dB of the approved, its octaves within 3 dB at 250 Hz and 1 kHz). The delay's send leaves the Monomachine's square there (regress.py's delay_send: XFAIL).

Pattern format 18 adds Grids (ARP's GRIDS and LANES pages: X, Y, CHAOS, its cycle, the three densities, each track's lane, after the speeds) and the chances 90 60 40 10 % (after the other conditions, so a saved one keeps its number; a condition past 17's read as ALWAYS, as 17 read it). Older patterns load with no lane followed. A track on a lane plays the lane's trigs on its own clock: its K-th step since the pattern's start is Grids' step 2 (K mod 16) (RES 16: Grids' clock at 4 ppqn, a bar) or K mod 32 (RES 32, two bars), CHAOS's byte a hash of the cycle and the part (the same every PLAY, on every core). GLO > PLAY's MUTE (BAR, the default; NOW): a mute, a solo or an unmute made while playing waits for the next of the pattern's bars of 16 steps (its start always one).

DIGI-WAV plays either bank, set on SYN's third page (BANK: M2K, MONO2K's 32 waves across WAVE's range as before; M64, the owner's 64, two WAVE values a wave: an even one is that wave exactly, an odd one between two). The owner's play without their DC (each cycle's mean, up to -29 % of the peak, taken out at playback, the files and the table kept as they are): with it a trig stepped, 13-17 dB more under 60 Hz at the onset on OS13, OS36 and OS48; four that would pass 16 bits so (OS29, OS37, OS48, OS58) play 0.4-1.4 dB down. MONO2K's 32 play as before. Every wave of both at C2, C4 and C6 (tools/wave_check.py): the owner's in tune within 0.2 c, their levels and aliasing within the range of MONO2K's own (the aliasing of a 256-point table read without a band limit, both banks alike), their thump at a trig within MONO2K's worst (one of its own, 9.1 dB, kept: saved patterns play it). The DigiPro waves and BeatBox samples are the OS's data and are not copied: DIGI-WAV plays MONO2K's own waves.

Credits and licence

GPL-3.0-only. Built on the open FM-1 work: Felucca by Leo Kuroshita (Hügelton Instruments), CS-1, X0X, FoMni, zp12 and the others. Orbitron by The League of Moveable Type: SIL OFL 1.1 (assets/fonts/orbitron/OFL.txt); the firmware carries 1-bit renderings of it. The FM-1's panel geometry as measured for CoralFlower's emulator. The machines were measured against a Monomachine running in Joe Landers' Monomachine emulator, gearmulator-md-mm (a fork of Gearmulator by The Usual Suspects), with the owner's own OS image: measurements only, none of the emulator's code or data is in MONO2K. Monomachine and Machinedrum are trademarks of Elektron; M-VAVE and FM-1 are trademarks of their owners. MONO2K is not affiliated with Elektron or M-VAVE.

The DRM- drums' voice design is after the Erica Synths LXR drum voices (lxr-desktop-app, GPL-3.0-only; originally Julian Schmidt's Sonic Potions LXR): their laws (the sweep, its curve and time, the PM hats, the clap's repeats), written anew in fixed point and measured against a float model of them; none of its code or transient samples is here. LXR is Erica Synths' mark.

GRIDS (firmware/src/m2k_grids.c) is Émilie Gillet's Grids, Mutable Instruments' topographic drum sequencer (pichenettes/eurorack, grids/, GPL-3.0): its 25 nodes of pattern data and its rules (ReadDrumMap, EvaluateDrums) ported, with credit, to MONO2K's integer core; tools/ref/grids_ref.py holds the port to the original's rules. Grids is Mutable Instruments' name.

The 64-wave bank (assets/waves/mono2k64/) is the project owner's own waveforms, licensed with the project (GPL-3.0-only) unless the owner says otherwise.

Bank A's parts are MONO2K's own: their sounds were drawn at random and picked by ear, their harmony and craft from research written up in docs/composing.md; the Model:Cycles demos and the IDM references there were measured or read about, never quoted.