turingmachine

A MIDI-domain port of the Music Thing Modular Turing Machine Mk2. Instead of voltages and analog shift registers, this crate applies the same shift-register randomisation, looping, and clock-division logic to MIDI note, velocity, gate, and CC streams.

The library is designed for two primary use cases:

1. Embedding in an application (DAW plugin, standalone sequencer).
2. Live-coding / REPL experimentation with a minimal-ceremony API.

Signal chain

The diagram below shows the hardware signal path and its Rust equivalent. Each box is a struct re-exported at the crate root.

                          CLOCK tick
                              |
                              v
                   +---------------------+
                   |   ShiftRegister     |  16-bit (four CD4015 ICs)
                   |   .clock(new_bit)   |
                   +---------------------+
                              ^
                              |
              +-------------------------------+
              |  WriteKnob.resolve(fb, rng)   |  CD4016 quad switch + TL072
              |  probability 0.0..=1.0        |  comparator
              +-------------------------------+
                              ^
                              |
                   feedback_bit(length)
                   from LengthSelector          ALPS-SR8V 9-pos rotary
                              |
                              v
              +-------------------------------+
              |   dac_byte (8 bits)           |  DAC0808 equivalent
              +-------------------------------+
               /          |           \
              v           v            v
   +-------------+  +------------+  +------------+
   | Quantizer   |  | Quantizer  |  | pulse_bit  |
   | note_from_  |  | velocity_  |  | (bit 7)    |
   | dac()       |  | from_dac() |  +------------+
   +-------------+  +------------+        |
         |                |               v
         v                v        StepOutputs::gate
  StepOutputs::note  ::velocity
                                   bits[0..7]
                                    /       \
                                   v         v
                          pulses[0..5]   gates[0..7]
                          (CD4081 AND)   (CD4050 buf)

              +---------------+  +---------------+
              | ClockDivider  |  | ClockDivider  |
              | division=2    |  | division=4    |
              +---------------+  +---------------+
                     |                  |
                     v                  v
              StepOutputs::div2  StepOutputs::div4

              +-------------------------------+
              |  rng.random() & 0x7F          |  2N3904 noise source
              +-------------------------------+
                              |
                              v
                    StepOutputs::noise_cc

Quick start

Add the dependency to your Cargo.toml:

[dependencies]
turingmachine = { path = "crates/turingmachine" }

Create an engine, tick it, and read the outputs:

use turingmachine::{TuringMachine, Scale};

let mut tm = TuringMachine::new();

// Optionally configure before ticking.
tm.set_scale(Scale::pentatonic_minor());
tm.set_root(2);               // D
tm.set_length(8);              // 8-step loop
tm.set_write(0.5);             // 50 % chance of mutation each step
tm.set_note_range(48..=72);    // C3--C5

let out = tm.tick();

if out.gate {
    println!(
        "Note ON: note={}, vel={}",
        out.note.unwrap_or(0),
        out.velocity.unwrap_or(0),
    );
}

For deterministic / reproducible sequences, use a seeded constructor:

use turingmachine::TuringMachine;

let mut tm = TuringMachine::with_seed(42);
// Two engines built with the same seed produce identical output.

Live-coding example

A tight loop simulating a sequencer session. Each tick prints the register state and the current note.

use turingmachine::{TuringMachine, Scale};
use std::thread;
use std::time::Duration;

fn main() {
    let mut tm = TuringMachine::with_seed(123);
    tm.set_scale(Scale::dorian());
    tm.set_root(0);          // C
    tm.set_length(8);
    tm.set_write(0.8);       // mostly looping, occasional mutation

    for step in 0..32 {
        let out = tm.tick();

        print!("step {:>3}  reg {}  ", step, tm);

        if out.gate {
            println!(
                "NOTE {:>3}  vel {:>3}",
                out.note.unwrap_or(0),
                out.velocity.unwrap_or(0),
            );
        } else {
            println!("--rest--");
        }

        // Simulate a 120 BPM clock (500 ms per beat).
        thread::sleep(Duration::from_millis(500));
    }
}

MIDI I/O example (feature-gated)

Enable the midi-io feature to get MidiTuringMachine, which wraps the engine and a midir output connection. Each tick() sends Note On / Note Off and CC messages to a real MIDI port.

[dependencies]
turingmachine = { path = "crates/turingmachine", features = ["midi-io"] }

use turingmachine::{TuringMachine, Scale};
// MidiTuringMachine is only available with the "midi-io" feature.
// use turingmachine::MidiTuringMachine;

use std::thread;
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let midi_out = midir::MidiOutput::new("turingmachine")?;
    let ports = midi_out.ports();
    let port = ports.first().expect("no MIDI output port found");
    let conn = midi_out.connect(port, "tm-out")?;

    let engine = TuringMachine::new();
    // let mut mtm = MidiTuringMachine::new(engine, conn, 0); // channel 0

    // mtm.route_noise_to_cc(1);   // modulation wheel

    for _ in 0..64 {
        // let out = mtm.tick()?;   // sends MIDI automatically
        thread::sleep(Duration::from_millis(500));
    }

    // mtm.all_notes_off()?;        // clean up
    Ok(())
}

Parameter reference

Scale reference

Fourteen built-in scales are available as constructors on Scale:

Custom scales can be created with Scale::new(intervals, name).

Output reference

Every call to tick() returns a StepOutputs struct. The table below lists each field with its type and the hardware jack it models.

Hardware-to-MIDI mapping

For the complete mapping between hardware signals and this crate's types:

Features

License

MIT OR Apache-2.0