Modular patches you can play and recall — in your browser, on a Teensy, and on supported modular hardware.
Cortex connects three places a patch can live: the browser editor, a Teensy 4.1 running the MusicBrain firmware, and external modules driven over MIDI, CV and gates.
Start in the browser: assemble a rack, patch instruments and effects, and play — no hardware needed. The simulator runs the Teensy firmware's own C++ DSP code, compiled to WebAssembly, and new modules are built for both at once, so a patch sounds nearly the same in the browser and on a Teensy. To hear the internal digital instruments on hardware you only need a Teensy 4.1 and a USB cable: the current firmware's audio connection is USB audio, and no complete backplane is required.
The hardware unit. A physical Cortex is a Teensy 4.1 on the busboard, with six slots for function cards: ADC8 and DAC8 for eight CV inputs and outputs, Gate8 and GateIn8 for gates and triggers, risers for panel controls. Each card gets its panel side — a Jack8 with eight 3.5 mm jacks, a Pot8-Front with eight potentiometers or an Enc5-Front with encoders and buttons — and the whole unit fits in a Eurorack case or stands on its own. One box that plays and patches your Eurorack modules and MusicBrain's own cards from the browser, and remembers every patch.
The hardware is in development: the boards below exist as designs and prototypes, and validation differs per board and function. External audio paths stay analog; internal DSP and USB audio are digital. Recall of external modules depends on which parameters and connections the hardware can actually control, and polyphony depends on the patch and the target.
Specs
Editor
Browser editor & simulator — usable now
DSP
One C++ codebase: WebAssembly in the browser, native on Teensy 4.1
Audio on Teensy
USB audio in the current firmware
Hardware
Busboard with six slots, function cards and panel fronts; Eurorack or standalone
External control
MIDI, CV and gates via the function cards (in development)
Pitch CV (design)
16-bit, 1V/oct
Firmware
Open source (MIT), released builds on GitHub, flashed with Teensy Loader
The backbone of the system: one Teensy 4.1 drives every function card you plug into its six slots, and the board takes care of power, the SPI bus, MIDI (two ins, two outs), USB host and the display port. A built-in tuning input listens to a VCO while the system dials it in, and the CAN port links external satellites. Delegated boards - extra Teensys or FPGA cards - can live in any slot and merge their audio back into the master over the shared audio lines. Every MusicBrain build starts here.
Eight control-voltage inputs for reading the analog world into the software brain: LFOs, envelopes, sequencers or expression pedals. All eight channels are sampled at the same instant, at 16-bit resolution, and accept +/-10 V directly. Pairs with a jack8 front for the panel jacks.
Eight control-voltage outputs that let the software brain play your analog gear: sequences, LFOs, envelopes or slow random drifts, updated on all channels at the same instant. The DACs are 16-bit - fine enough for stable pitch CV - and each output can pick its own range in software, from 0-5 V up to +/-10 V. Pairs with a jack8 front.
Eight gate and trigger outputs for starting envelopes, advancing sequencers and clocking external gear. The outputs swing 0-5 V and every channel has its own series protection, so a patching mistake never hurts. Pairs with a jack8 front.
Eight gate and trigger inputs that bring external clocks, triggers and footswitches into the software brain. Every channel is protected against overvoltage and reads a defined level when nothing is plugged in. Pairs with a jack8 front.
The panel side of an eight-channel card: eight 3.5 mm jacks on the standard 4 HP grid. It plugs straight onto the front connector of an adc8, dac8, gate8 or gatein8 - no wiring involved.
A four-channel jack breakout on a cable, for CV outputs that arrive through a hub connector such as the AD5754 breakout. Useful when you want a few extra outputs without giving up a card slot.
Eight potentiometers on the panel, laid out on one clean 13.75 mm grid. Together with the potriser underneath they become eight freely assignable control voltages.
Turns eight panel potentiometers into control voltages: the riser sits in a slot, reads the pot8front above it and puts all eight values on the bus, ready to be assigned to anything in the software.
Five encoders and two buttons on the panel: the hands-on interface for menus and parameters. It talks I2C and connects to the bus through the i2criser.
A passive riser that connects an encoder-and-button front (enc5front) to the bus over I2C. It carries only power and the Qwiic chain - no electronics of its own.
Extends a bus slot straight upwards, carrying the complete bus including the audio lines. This is the development board of the system: probe a live slot, or breadboard a delegated Teensy or FPGA card before it becomes a real one.
A standalone four-channel CV output board on a hub cable, built around the same 16-bit AD5754 and a precision reference as the dac8. It delivers accurate +/-10 V outputs without occupying a card slot; the jack4 breakout provides the panel jacks.
An 8-voice analog audio patch matrix: 8 input buses by 16 output buses, each bus eight voices wide. Patches are stored and recalled in software — press a button and the whole analog routing snaps into place, per voice if you want it (split 8 voices into 2x4 with independent routing). Built around eight MT8816 crosspoint chips, one per voice, socketed. Output bus 16 is reserved as a measurement bus into the ADC so the brain can calibrate levels automatically. Two placement variants exist: v0.2 (edge) and v0.3c (center, 34% shorter audio traces).
Eight-voice physical-modeling synth voice on an FPGA, played by Cortex as a
regular instrument on the SPI bus. Each voice is a Karplus-Strong string with
a morphing wavetable exciter, running through an MS-20-style filter with
diode saturation and drive. Pitch, gate and filter arrive as per-voice CV
over the established frame protocol, so to the brain it looks no different
from an analog module — it just happens to be 20 thousand logic cells
pretending to be strings.
Browser-based patch editor for the Cortex modular system. You assemble a
rack from module panels, patch them with colour-coded cables for CV, gates,
triggers, audio and MIDI, and play the result right away: the built-in
engine simulates the patch polyphonically, from a single synth voice up to
an eight-voice DX7. The same patch then uploads to the Teensy over USB,
where the firmware reproduces it — a contract test keeps editor and
firmware in step, so the editor version follows the firmware series.