MusaLCE

At its core, MusaLCE is a toolkit: a TCP-based REPL server (Musa::REPL, shipped inside the MusaDSL gem) that you wrap around a Ruby session of your own making. You set up the sequencer, the clock, the voices and any other inputs and outputs your piece needs; you start the REPL inside that context; and from that point on, anything you can talk to from Ruby — in either direction — becomes part of the session. MIDI hardware (synths you play, controllers that feed parameters), OSC applications like SuperCollider or Max/MSP, sockets to custom electronics or mechanical instruments — anything you can wire up. The price is that you assemble the pieces yourself; the gain is that nothing is off-limits. This is where the deeper experimentation happens.

For the most common case — driving Bitwig Studio or Ableton Live from a code editor — MusaLCE ships the MusaLCE Server Suite, a ready-made version of that assembly. The musalce-server gem packages the sequencer, transport, surface and DAW link into a single command; a small DAW connector (one for Bitwig, one for Live) bridges to your DAW; the VSCode extension is your editor client. Tracks are exposed by symbolic name, the sequencer locks to the DAW's clock automatically, and a daw object gives you transport, voices and — with an elgato Stream Deck — physical surface controls. Internally the suite is the toolkit pre-wired for you; you skip the assembly step.

The toolkit is centred on Musa::REPL, a small server that ships inside the MusaDSL gem.

It listens on TCP port 1327 and waits for the editor to send Ruby code; when code arrives, it evaluates it in the context you've given the REPL — the same context where your sequencer, voices and helpers live. Everything that was running keeps running: the sequencer doesn't pause between evaluations, your scales and patterns stay in scope, and your puts calls echo back into the editor's status panel so you can debug while the music plays.

What you build is the frame around the REPL: a sequencer, a clock (timer-based, locked to an inbound MIDI clock, or driven externally), voices for whatever instruments you're playing, and the DSL helpers and scales your piece uses. Then you open the REPL inside the sequencer DSL context, like this:

require 'musa-dsl'
require 'midi-communications'

include Musa::All

output    = MIDICommunications::Output.gets        # or any other destination
clock     = Musa::Clock::TimerClock.new(bpm: 120, ticks_per_beat: 24)
transport = Musa::Transport::Transport.new(clock, 4, 24)
voices    = Musa::MIDIVoices.new(sequencer: transport.sequencer,
                                  output: output, channels: [0])

transport.sequencer.with do
  # Define any helpers, scales, patterns and DSL methods your piece needs…
  # everything visible here will be reachable from the REPL.

  Musa::REPL::REPL.new(binding)   # opens TCP/1327 in this context
end

transport.start

Connect from VSCode and you have a custom live coding environment, tuned to whatever you're building.

A worked example with a Tidal-Cycles-style d(n) / hush / solo API: musadsl-demo/_demo-13-live-coding.

The MusaLCE Server Suite takes that same toolkit and pre-builds it for you — and adds a daw object that gives you direct, named access to your DAW. You install three components (the musalce-server gem, a small DAW connector for Bitwig or Live, and the VSCode extension), launch the server with one command, and the REPL is ready on port 1327. From the editor you can now talk to your DAW like this:

# Sent from VSCode while the server runs and Bitwig (or Live) is open:

# In Live, point the clock-receiving virtual bus:
daw.midi_sync('IAC Driver Bus 1')

# Tracks by their symbolic name (configured on the DAW connector side):
daw.track('Drums').out.note 36, duration: 1/4r, velocity: 100

# Schedule and loop — the sequencer is already running:
at 4 do
  daw.track('Bass').out.note 48, duration: 1r
end

every 1 do |i|
  daw.track('Synth').out.note 60 + (i % 7), duration: 1/8r
end

# Callbacks that survive Stop/Play (after_stop wipes the sequencer state
# by default; on_start/after_stop/before_begin re-install your scaffolding):
daw.transport.on_start do
  puts 'Transport started!'
end

# Stuck notes? Hit panic — All Notes Off to every track.
daw.panic!

Two practical notes specific to each DAW:

On Bitwig (the preferred DAW today), the connector extension can launch the server for you. A toggle in its preferences (Start Server) spawns and supervises a child process, so you don't need a separate terminal open. The extension also forwards Bitwig's MIDI clock to the server (Clock Sender) and exposes per-project symbolic names for the 16 MIDI channels it manages on each virtual port. If you need more than 16 named channels, enable a second instance of the extension and you get another 16.

On Ableton Live, Live's MIDI Remote Script API doesn't expose the transport directly to the server, so MusaLCE has to send MIDI clock through a virtual bus (IAC Driver on macOS) that Live then syncs to. The Live connector currently has a narrower feature set than the Bitwig one — feature parity is on the roadmap.

If you have an elgato Stream Deck, Pulso can wire physical buttons and encoders into your live coding session. Pulso is yeste.studio's upcoming Stream Deck workflow system for DAWs (Bitwig today; Ableton planned), and most of what it does has nothing to do with MusaLCE — it controls transport, track navigation, devices, parameters, the browser. One of Pulso's features is the MusaLCE Surface protocol, exposed through the Pulso Workflow plugin: physical buttons and encoders that fire MusaDSL Sequencer Events in your running score, and that receive their display state (labels, on/off state, encoder values) back from your code.

Each control is identified by an event name. That same event is what the sequencer launches when the user touches the control — so you subscribe to it from your score with on :event do |parameters| … end. And surface[:event].set … pushes label, state, value and range back to the physical button or encoder:

# Set up a toggle (rendered with on / off / inactive palettes on the Stream Deck):
surface[:launch_chorus].set(message: 'Chorus', enabled: :inactive)

on :launch_chorus do |payload|
  surface[:launch_chorus].toggle!
  # … fire your section, swap a pattern, whatever
end

# Encoder with a range:
surface[:cutoff].set(range: 0..127, value: 64, message: 'Cutoff')

on :cutoff do |value|
  # value is the encoder's current integer
end

Three control types live in this protocol: Toggle (on / off / inactive states), Trigger (momentary press), and Encoder (integer in a range, like a fader value). The MusaLCE Surface relay ships in MusaLCEforBitwig today; the Live connector doesn't have it yet, so Stream Deck integration with MusaLCE is Bitwig-only at the moment. Pulso itself is in private development and the public release is still pending.