A system that grows with you.
Eseq is a fast, extensible DAW made to play live. It starts as a step sequencer and grows into whatever you need, and all of it can change while the music plays.
Eseq is a fast, extensible DAW made to play live. It starts as a step sequencer and grows into whatever you need, and all of it can change while the music plays.
Hardware-style step sequencing with the mixer and effect chains in reach. Pattern, sound, and mix without switching windows.
Open any instrument to see the DSP graph behind it. Rewire it, save a fork, or eject it to code. Patches compile to native code the moment you save them, so a full rack of physical models runs on a laptop.
Per-step parameter locks reach into instruments, sequencer settings, and effects alike.
Five selected steps on the 808 Clap, locked at once: flam on the instrument, frame, cutoff, and resonance on the Filter Table after it, and the track's own timebase, so those five steps run at half speed.
Define a sequencer in a few lines of Lisp and it shows up in the DAW as a first-class instrument, with its own UI, parameters, and per-step control.
A neuron-inspired sequencer, defined in the buffer on the right. Eight nodes are wired all-to-all; a node fires its track when the energy arriving from the others clears its threshold, and every fire feeds back into the network, so triggers cascade through it. Change the update rule and the same eight nodes run a Markov chain instead.
Wire probability, counters, accumulators, and comparators into any parameter lane. Patterns that evolve on their own, without leaving the step grid.
Those lanes are not hard-wired. Each one is a def-process in the Lisp the app ships with, and yours go in the same menu. Here are prob and count exactly as they are defined.
(def-process lane-prob
:doc "Step probability: veto the step when the seeded roll exceeds the lane."
:in ((prob :float 0 1 :default 1 :lane true))
:seed :per-cycle
:run (if (> (rand) (in :prob))
(veto!)
nil))
(def-process lane-count
:doc "Counter: each nonzero step advances the count and wraps from hi back to lo."
:targets ((out :mappable)
(wire :process-inlet))
:in ((step :float -24 24 :default 0 :lane true)
(lo :float -128 128 :default 0)
(hi :float -128 128 :default 8)
(hold :int 0 1 :default 0))
:state ((count 0))
:run (do
(set! count (+ count (in :step)))
(if (> count (in :hi)) (set! count (in :lo)) nil)
(if (< count (in :lo)) (set! count (in :hi)) nil)
(if (or (> (in :step) 0) (< (in :step) 0) (> (in :hold) 0.5))
(do
(target-add! :out count)
(target-set! :wire count))
nil)))