Skip to content
solvyxtechPublic

About

justDAW — a native digital audio workstation

Resources

Stars

0 stars

Watchers

0 watching

Forks

Repository files navigation

justDAW

An original, cross-platform desktop digital audio workstation written in C++20 on JUCE 8. Native UI, real-time-safe audio engine, human-inspectable JSON projects.

Status: 0.9.0 beta on macOS. Project model and JSON manifest with migrations; real-time transport with count-in, loop, punch points, quantized play and ramped tempo; an audio graph with tracks, groups, returns, sends and path-aware plug-in delay compensation; sample-accurate MIDI and audio clip playback with warping (Beats / Tones / Repitch, warp markers, tempo detection); Performance Grid launching and Composition View editing with a tempo lane and take lanes with comping; MIDI and audio recording; twenty-five internal devices (including Mono Bass, Super Pad, Tine Piano, a master Limiter and a Phaser) with presets and Control Lanes; VST3 / Audio Unit hosting; per-track MIDI output to hardware and MIDI clock in and out; mixdown, stems, MIDI export, archives, autosave; a video window that follows the transport; floating / dockable panels; a .dmg package; five factory demos; and 193 unit-test cases, also clean under AddressSanitizer + UBSan. Windows and Linux are written for but not yet built. See docs/roadmap.md for the per-feature status and docs/user-guide.md for how to use it.

This is a beta (0.9.0): everything listed is implemented and tested on macOS, and what was verified for the beta — and what still stands between it and 1.0 — is in docs/beta-checklist.md. Known gaps are tracked in docs/polish-backlog.md; the most recent review pass, including how its fixes were verified, is written up in docs/2026-09-29-review.md.

Vocabulary

justDAW term Meaning
Performance Grid The clip-triggering workspace (track columns × Trigger Rows)
Trigger Row A horizontal row of cells that can be launched together
Composition View The linear, timeline-based arrangement workspace
Device Chain The ordered instruments and effects on a track
Signal Path A routing connection between tracks, sends, buses and outputs
Control Lane An automation lane for one parameter

Building

Requirements: CMake ≥ 3.22, a C++20 compiler, and Ninja (recommended). Dependencies (JUCE 8.0.15, nlohmann/json 3.12.0, Catch2 3.16.0) are fetched automatically as hash-pinned release archives, or picked up from ThirdParty/<name>/ if you unpack them there for an offline build. Ableton Link is optional and offline-only: copy Link 4.1's include/, cmake_include/, AbletonLinkConfig.cmake, licence files and modules/asio-standalone/include into ThirdParty/link/ (see docs/packaging.md); configure prints Link: Link-4.1 ... when it is found.

macOS

xcode-select --install          # Command Line Tools are sufficient
brew install cmake ninja
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build build --target justDAW sgs_tests
./build/sgs_tests
open "build/justDAW_artefacts/Release/justDAW.app"

Windows 11

# Visual Studio 2022 with the "Desktop development with C++" workload
cmake -S . -B build -G "Visual Studio 17 2022" -A x64
cmake --build build --config Release --target justDAW sgs_tests
build\Release\sgs_tests.exe
build\justDAW_artefacts\Release\"justDAW.exe"

Linux (Debian/Ubuntu shown)

sudo apt install build-essential cmake ninja-build pkg-config \
     libasound2-dev libfreetype-dev libfontconfig1-dev libx11-dev libxrandr-dev \
     libxinerama-dev libxcursor-dev libxext-dev libgl1-mesa-dev libcurl4-openssl-dev
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release
cmake --build build --target justDAW sgs_tests
./build/sgs_tests
"./build/justDAW_artefacts/Release/justDAW"

Linux is a "where practical" target: it builds and runs against ALSA; JACK support is off by default (JUCE_JACK=0 in CMakeLists.txt).

Options

CMake option Default Purpose
SGS_BUILD_TESTS ON Build sgs_tests (Catch2) and sgs_demo_export
SGS_BUILD_APP ON Build the JUCE application (off = core library + tests only, no JUCE compile)
SGS_WARNINGS_AS_ERRORS OFF -Werror / /WX on justDAW targets

cmake --build build --target export_demos regenerates Resources/DemoProjects from Source/Project/FactoryDemos.cpp through the real serializer.

./build/sgs_render demo:grid-warmup out.wav (or a .justdaw path) renders a project offline through the same transport + graph code the live engine runs and prints per-track peaks — the way to verify audio without a device or a window.

./build/sgs_plugin_probe_artefacts/Release/sgs_plugin_probe scans the machine's plug-ins out of process, hosts the first instrument and effect it finds, and reports peaks, latency and state size (exit 0 = hosting works).

cmake --build build --target package produces the installer for the host platform; see docs/packaging.md.

Code style

.clang-format and .clang-tidy are at the repository root. run-clang-tidy -p build Source/ works against the exported compile database.

Layout

Source/
  App/           application wiring: Main, AppController, UserSettings, KeyMap, CommandIds,
                 MediaLibrary (import, peaks cache, relink), RecordingManager, PluginWindows
  Core/          Uuid, SpscQueue, SnapshotExchange, RealtimeThread guard, Log, Colour, smoothers
  Project/       data model, validator, factory demos (+ generated demo samples), ProjectDocument, SignalHealth
  Persistence/   JSON serializer, migration registry, on-disk project layout, autosave
  Transport/     TempoMap, TimeSignatureMap, launch quantization, TransportEngine (RT)
  Editing/       UndoableCommand, UndoStack, project / clip / region / device / mixer commands
  Devices/       DeviceProcessor interface, registry, presets, Pulse Synth, Echo Delay,
                 Instruments (Phase Synth, Pad Sampler, Sample Player), WaveTable, StringSynth,
                 TonewheelOrgan, DrumSynth, Effects (EQ, filter, compressor, transient, tape,
                 crusher, pump, reverb, chorus, utility)
  PluginHosting/ PluginManager (out-of-process scan, cache, quarantine), PluginDevice (JUCE host wrapper)
  Sequencing/    ClipData, MidiClipPlayer, AudioClipPlayer (+ stretch voices), WarpMap, GridLauncher (RT), NoteTools
  Dsp/           Fft, TimeStretcher (WSOLA + phase vocoder), AudioAnalysis (onsets, tempo)
  Video/         VideoSync policy (the window is in UI/Video)
  AudioGraph/    GraphSnapshot, GraphBuilder (UI, incl. delay compensation), GraphProcessor (RT), DeviceHost
  Mixer/         SoloResolver, TrackRuntime (meters, ramps, launcher state), StereoDelayLine
  Automation/    Control Lane evaluation
  Recording/     MidiRecorder (captured events -> clips), RecordingRing (audio -> disk)
  ImportExport/  WAV reader/writers, audio media decoding, Mixdown (stereo + stems), MidiFile, OfflineRenderer
  MIDI/          MidiEvent lists, MidiInputCollector (device callbacks -> audio thread), MidiClock (generator + receiver)
  AudioEngine/   device callback, metronome, diagnostics counters
  UI/            JUCE components: Common, MainWindow, Grid, Arrangement, PianoRoll, AudioEditor,
                 MixerView, DeviceChain, Browser, Inspector, Diagnostics, Settings, Palette
Tests/           Catch2 suite (links sgs_core only — no JUCE)
Tools/           sgs_demo_export, sgs_render, sgs_plugin_probe, make_icon.py
Resources/       DemoProjects/, Icon/
packaging/       Linux desktop entry + MIME type, macOS entitlements
cmake/           dependency pins, warning flags, CPack configuration
docs/            architecture, real-time rules, project format, roadmap, user guide, packaging

sgs_core is a pure C++20 static library with no JUCE dependency; the application and audio-device layer sit on top of it. See docs/architecture.md.

Threading model

Thread Owns Crosses to the audio thread via
Message (UI) Project, UndoStack, settings, files, dialogs SpscQueue<EngineCommand> (POD commands) and SnapshotExchange<MusicalTimeMap> (pointer swap of immutable maps)
Audio callback TransportEngine, Metronome, GraphProcessor over the current GraphSnapshot Publishes TransportReadout, EngineDiagnostics and per-track MeterState atomics; UI polls at 10–30 Hz. Captured MIDI goes back through SpscQueue<CapturedMidiEvent>
MIDI input one callback object per enabled device one SpscQueue per device (single producer each), drained by the audio thread with timestamps mapped to sample offsets
Background workers file decoding, peaks caches, recording writer results posted to the message thread, then published as snapshots
Plug-in scanner separate helper process per plug-in file cache file + quarantine list read on the message thread

The audio thread never allocates, locks, logs, touches files, parses JSON or waits on anything. Every service that does any of those calls SGS_ASSERT_NOT_REALTIME(), which aborts in debug builds and increments the "Real-time violations" counter in the Diagnostics panel in release builds. The complete rule set is in docs/realtime-audio-rules.md.

Keyboard

justDAW has its own key scheme. The defaults live in Source/App/KeyMap.cpp; edit them from View → Keyboard Shortcuts… (stored in settings.json). A few to start with:

Key Command
⌘K / Ctrl+K Command Palette
Space / Shift+Space Play–pause / Stop
⌘⇧R Record (with count-in)
L, M, T Loop, Metronome, Tap tempo
Home Return to start
⌘1 ⌘2 ⌘3 ⌘4 Performance Grid / Composition View / Piano Roll / Mixer
⌘⇧N New MIDI clip on the selected track
⌘⇧K / ⌘B Device Chain / Browser
⌘⇧D / ⌘⇧F Diagnostics / Inspector
⌘, Audio & MIDI settings

In the Piano Roll: click adds a note (Draw), drag moves, drag the right edge resizes, ⌥-drag duplicates, double-click deletes, marquee in Select mode, arrows nudge (⇧ = octave), Q quantize, U mute, ⌘D duplicate, ⌘A all.

Projects on disk

A project is a folder:

My Song.justdaw/
  manifest.json     the project (format-versioned JSON, see docs/project-format.md)
  Media/            managed copies of imported audio
  Cache/            waveform thumbnails etc. — safe to delete
  Backups/          manifests preserved before a format migration

Settings, key bindings and logs live in the per-user application-data directory (~/Library/Application Support/justDAW on macOS, %APPDATA%\justDAW on Windows, ~/.config/justDAW on Linux).

License

justDAW's own source is © the justDAW authors. JUCE is used under its own license terms (see ThirdParty/JUCE/LICENSE.md or the fetched archive); nlohmann/json and Catch2 are MIT and BSL-1.0 respectively. Ableton Link (ThirdParty/link, with its bundled asio) is GPL-2.0-or-later, which is compatible with justDAW's AGPL-3.0; a build without that folder leaves Link out. "Ableton" and "Link" are Ableton AG's names; justDAW is not affiliated with or endorsed by Ableton.

About

justDAW — a native digital audio workstation

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors

Languages