isobar

Isobar supports three primary categories of events:

1. Note events: Trigger discrete MIDI notes. They typically include properties for duration and amplitude.
2. Control events: Handle MIDI messages such as control change, program change, and pitchwheel. These can be used to apply quasi-continuous control curves.
3. Action events: Allow you to call arbitrary Python functions at scheduled times.

Capabilities

• Event Triggering: Send MIDI, OSC, SocketIO, or trigger Python functions.
• Real-time & Offline: Trigger events in real-time or generate patterns for serialization into .mid files for use in a DAW.
• Synchronization: Synchronize to or from external devices using MIDI clock sync or Ableton Link.
• MIDI Processing: Load existing patterns from MIDI files for manipulation.

Limitations

• No Audio Generation: isobar does not generate audio itself. It is a sequencing and control engine that must be connected to an external output device (like a synthesizer or DAW) responsible for sound synthesis.

isobar supports several different types of output devices for sending and receiving events. Depending on your workflow, you can target hardware or software via:

• MIDI: Send/receive live MIDI notes, control, and clock events to external hardware or software hosts (like a DAW).
• MIDI file: Generate and save sequences directly to .mid files.
• OpenSoundControl (OSC): Send events over the network using the OSC protocol.
• SignalFlow: Trigger events within the SignalFlow synthesis engine.
• SuperCollider: Send events to a SuperCollider synthesis server.
• FluidSynth: Trigger notes in the FluidSynth software synthesizer.

isobar is a Python library for algorithmic composition and generative music. It provides a framework for sequencing and triggering events (MIDI, OSC, SocketIO, or Python functions) to be used in real-time or serialized as MIDI files.

Key Mental Model:

1. Timeline: The central scheduler that handles timing and triggers events. It can run on its own internal clock or synchronize with external MIDI clocks or Ableton Link.
2. Events: The data packets sent or received. An event is typically a dictionary of properties, such as { "note": 60, "amplitude": 127 }.
3. Patterns: Generators used to define the properties of events. Patterns produce sequences of values (fixed, random, or statistical) and can be composed (e.g., using one pattern to transform another).
4. Devices: The interfaces used to send or receive events, such as MIDI or OSC outputs.

Warp patterns allow you to modulate the timeline tempo:

• PWarp: Requests a new target warp value from a pattern every length beats.
• PWSine: A sinusoidal warp with a period of length beats and an amplitude of +/-<amp>.
• PWRallantando: An exponential deceleration to <amp> times the current tempo over length beats.

isobar is built around a hierarchical model for algorithmic composition:

1. Timeline: The central engine that schedules events at a specific tempo. It can control its own tempo or sync to an external clock. Events are sent to an OutputDevice (by default, the system's default MIDI output).
2. Patterns: These are templates used to generate values. Patterns can represent note sequences, control events, program changes, or arbitrary data via lambda functions. They can be combined using mathematical operators or transformed using specialized pattern classes.
3. Events: When a Timeline schedules a pattern, it generates Events. An event contains properties (like note, duration, or amplitude) derived from the assigned Patterns.

Workflow Summary: Patterns $\rightarrow$ Timeline.schedule() $\rightarrow$ Events $\rightarrow$ OutputDevice (MIDI/OSC).

Markov patterns use Markov chains to generate sequences based on probabilities:

• PMarkov: A first-order Markov chain generator.
• MarkovLearner: A class that learns a Markovian sequence by sequentially registering new values.
• MarkovGrapher: A helper class used to graph the structure of a PMarkov object.

Chance patterns (subclasses of PStochasticPattern) introduce randomness into your sequences. Common patterns include:

• PWhite: White noise between min and max.
• PBrown: Brownian noise.
• PCoin: Returns 0 or 1 based on a probability.
• PRandomWalk: A random walk around a list.
• PChoice: Picks a random element from values, optionally weighted by weights.
• PSample: Picks multiple random elements from values, optionally weighted by weights.
• PShuffle: Returns a shuffled list.
• PSkip: Skips events with a probability of 1 - play.
• PFlipFlop: Flips a binary bit with a given probability.
• PRandomExponential: Random uniform on an exponential curve between min and max.

Fade patterns allow you to introduce or remove notes gradually over time:

• PFadeNotewise: Fades a pattern in/out by introducing notes at a gradual rate.
• PFadeNotewiseRandom: Fades a pattern in/out by gradually introducing random notes.

When passing a dictionary to Timeline.schedule(), the presence of specific keys determines the event type:

• Note events: Identified by the presence of a note or degree key.
• Control events: Identified by the presence of a control or program_change key.
• Action events: Identified by the presence of an action key.