_____                       _____
 |  __ \                     |  __ \
 | |  | |   __ _  __      __ | |  | |  _ __    ___    __ _   _ __ ___     ___   _ __
 | |  | |  / _` | \ \ /\ / / | |  | | | '__|  / _ \  / _` | | '_ ` _ \   / _ \ | '__|
 | |__| | | (_| |  \ V  V /  | |__| | | |    |  __/ | (_| | | | | | | | |  __/ | |
 |_____/   \__,_|   \_/\_/   |_____/  |_|     \___|  \__,_| |_| |_| |_|  \___| |_|

* * Digital Audio Workstation with Python * *

DawDreamer

Read the introduction to DawDreamer, which was presented as a Late-Breaking Demo at the 2021 ISMIR Conference.

DawDreamer is an audio-processing Python framework supporting core DAW features and beyond:

• Composing graphs of multi-channel audio processors
• Audio playback
• VST instruments and effects (with UI editing and state loading/saving)
• FAUST effects and polyphonic instruments
• Time-stretching and looping, optionally according to Ableton Live warp markers
• Pitch-warping
• Parameter automation at audio-rate and at pulses-per-quarter-note
• Parameter automation saving in absolute audio-rate time
• MIDI playback in absolute time and PPQN time
• MIDI file export in absolute time
• Rendering and saving multiple processors simultaneously
• Support for the Faust Box and Signal APIs
• Transpiling Faust code to JAX/Flax and other target languages (C++, Rust, Wasm, etc.)
• Machine learning experiments with QDax
• Multiprocessing support
• Full support on macOS, Windows, Linux, Google Colab, and Ubuntu Dockerfile

DawDreamer's foundation is JUCE, with a user-friendly Python interface thanks to nanobind. DawDreamer evolved from an earlier VSTi audio "renderer", RenderMan.

Installation

macOS requirements:

• 64-bit Python 3.11-3.14
• Apple Silicon (arm64) or Intel (x86_64)
• macOS 11.0 or higher

Windows requirements:

• x86_64 CPU
• 64-bit Python 3.11-3.14

Linux requirements:

• x86_64 or aarch64 CPU
• 64-bit Python 3.11-3.14

Install with PyPI:

pip install dawdreamer

API Documentation

https://dbraun.github.io/DawDreamer/

Basic Example

Using Faust, let's make a stereo sine-tone at 440 Hz and -6 dB. You can run this code as-is.

import dawdreamer as daw
from scipy.io import wavfile
SAMPLE_RATE = 44100
engine = daw.RenderEngine(SAMPLE_RATE, 512)  # 512 block size
faust_processor = engine.make_faust_processor("faust")
faust_processor.set_dsp_string(
    """
    declare name "MySine";
    freq = hslider("freq", 440, 0, 20000, 0);
    gain = hslider("vol[unit:dB]", 0, -120, 20, 0) : ba.db2linear;
    process = freq : os.osc : _*gain <: si.bus(2);
    """
    )
print(faust_processor.get_parameters_description())
engine.load_graph([
                   (faust_processor, [])
])
faust_processor.set_parameter("/MySine/freq", 440.)  # 440 Hz
faust_processor.set_parameter("/MySine/vol", -6.)  # -6 dB volume

engine.set_bpm(120.)
engine.render(4., beats=True)  # render 4 beats.
audio = engine.get_audio()  # shaped (2, N samples)
wavfile.write("sine_demo.wav", SAMPLE_RATE, audio.T)

# Change settings and re-render
faust_processor.set_parameter("/MySine/freq", 880.)  # 880 Hz
engine.render(4., beats=True)
# and so on...

Next, let's make a graph with a VST instrument and effect. This graph will be simple, but you can make more complicated ones.

import dawdreamer as daw
from scipy.io import wavfile
SAMPLE_RATE = 44100
INSTRUMENT_PATH = "path/to/instrument.dll"
EFFECT_PATH = "path/to/effect.dll"

engine = daw.RenderEngine(SAMPLE_RATE, 512)
engine.set_bpm(120.)

synth = engine.make_plugin_processor("synth", INSTRUMENT_PATH)
print("inputs:", synth.get_num_input_channels())
print("outputs:", synth.get_num_output_channels())
print(synth.get_parameters_description())

synth.set_parameter(7, .1234)

# (MIDI note, velocity, start sec, duration sec)
synth.add_midi_note(60, 100, 0.0, 2.)

# optionally capture intermediate audio
synth.record = True

effect = engine.make_plugin_processor("effect", EFFECT_PATH)

engine.load_graph([
  (synth, []),
  (effect, [synth.get_name()])  # effect needs 2 channels, and "synth" provides those 2.
  ])

engine.render(4.)  # render 4 seconds.
audio = engine.get_audio()
wavfile.write("synth_demo_wet.wav", SAMPLE_RATE, audio.T)
synth_audio = engine.get_audio("synth")
wavfile.write("synth_demo_dry.wav", SAMPLE_RATE, synth_audio.T)
synth.clear_midi()
# add midi again, render again, and so on...

Known Issues

Compatibility with JAX and other LLVM-based libraries

DawDreamer must be imported before JAX or other LLVM-based libraries (such as PyTorch with TorchScript, Numba, etc.) to avoid LLVM initialization conflicts that can cause segmentation faults:

# CORRECT:
import dawdreamer as daw  # Import DawDreamer first!
import jax

# WRONG - May cause segfault:
import jax
import dawdreamer as daw  # Importing after JAX can crash!

Why? Both DawDreamer (via Faust's LLVM backend) and JAX use LLVM internally. When JAX initializes LLVM first (e.g., by calling jax.devices()), importing DawDreamer afterward can cause conflicts in LLVM's global state, resulting in a crash.

Workaround: Always import dawdreamer at the top of your Python file, before any JAX or related libraries.

Documentation

Full documentation: https://dbraun.github.io/DawDreamer/

• Installation Guide
• Quick Start
• User Guide
• API Reference
• Examples
• Tests
• Changelog

License

DawDreamer is licensed under GPLv3 to make it easier to comply with all of the dependent projects. If you use DawDreamer, you must obey the licenses of JUCE, nanobind, Libsamplerate, Rubber Band Library, Steinberg VST2/3, and FAUST.