The Community Edition of a modern open-source Digital Audio Workstation, built with Rust, GPUI, TypeScript, WebAssembly, and native audio/plugin infrastructure.

Architecture · Getting Started · Build · Debugging · Translations · Contributing · Forks & Trademarks

MIDI Editor

Mixer

Workspace

This public repository contains Futureboard Community Edition source code, licensed under the MIT License. A normal Community build does not contain the private Professional Edition crate, ASIO provider, license activation client, or other separately licensed commercial components.

Authorized private checkouts may add the Git-ignored crates/ExclusiveEdition source and use build-private.ps1. The presence of shared extension hooks or the public professional build-feature name does not grant access to, a license for, or redistribution rights in Professional Edition.

# Public Community Edition
cargo build -p futureboard_native

# Authorized private checkout only (PowerShell)
.\build-private.ps1

# Equivalent direct Cargo command
cargo build --release -p futureboard_native --features professional

# Fully temporary LLVM + ASIO SDK setup (downloads about 822 MiB)
python .\build-private-temporary.py --accept-asio-license

# Build all default workspace targets with Professional enabled for Studio
python .\build-private-temporary.py --accept-asio-license --workspace

Futureboard Studio is a Digital Audio Workstation whose primary maintained surface is a native Rust application built on GPUI (the rendering framework behind the Zed editor), driving an in-process Rust audio engine. A secondary web (WASM DSP) surface shares layout and engine concepts, but the native app is the main development target.

Also: plugins/ (stock-plugin editors), modules/ (noise removal, stem extraction), extensions/ (extension templates), packages/ (shared fonts/icons/assets), external/ (vendored SDKs). See ARCHITECTURE.md for the full breakdown.

Prerequisites: Bun · Rust 1.85+ (edition 2024) with the wasm32-unknown-unknown target · CMake 3.20+ · a C++ toolchain (MSVC / Xcode CLT / GCC / Clang).

git clone --recursive https://github.com/futureboard/Futureboard
cd Futureboard
bun install                               # JS workspace dependencies
rustup target add wasm32-unknown-unknown  # web audio core target

Run a surface:

bun run dev:native   # native GPUI client   (= cargo run -p futureboard_native)
bun run dev:web      # React web app
bun run dev:server   # collaboration server

The native client is a Rust binary linking the GPUI UI kit, the direct audio engine, and the plugin host (CMake + a C++ toolchain are required for the native plugin/SDK bridge). The bun run scripts wrap the equivalent cargo commands.

bun run build:native:debug   # debug    (= cargo build -p futureboard_native)
bun run build:native         # release  (= cargo build --release -p futureboard_native)

The release binary is emitted to target/release/FutureboardNative (.exe on Windows).

Package distributables (scripts in packaging/native/):

bun run bundle:native:mac       # macOS .app
bun run bundle:native:mac:dmg   # macOS .dmg installer
bun run bundle:native:win       # Windows portable / installer
bun run build:all               # all surfaces (WASM + native)

CEF publishes macosx64 and macosarm64 as separate distributions — there is no universal one — so a universal app is produced by packaging each architecture and merging the two trees with lipo:

rustup target add x86_64-apple-darwin aarch64-apple-darwin
cargo run -p SphereWebView --example install_cef --features installer -- --target universal-macos

for triple in x86_64-apple-darwin aarch64-apple-darwin; do
  cargo run -p xtask -- package --profile release --edition community --plugin all --target "$triple"
done

bash packaging/native/merge-universal-macos.sh \
  out/release/community/macos-x64 out/release/community/macos-arm64 \
  out/release/community/macos-universal

bash packaging/native/bundle-macos.sh out/release/community/macos-universal
bash packaging/native/bundle-macos-dmg.sh

bundle-macos.sh prefers macos-universal when no package directory is passed, reports the architectures it shipped, and fails on a single-architecture bundle when FUTUREBOARD_REQUIRE_UNIVERSAL=1 (release CI sets it). The DMG filename carries the architecture: …-macos-universal.dmg, …-macos-arm64.dmg, or …-macos-x86_64.dmg.

Releases ship all three: both single-architecture packages already exist as a by-product of the universal merge, so bundling them separately costs no extra compile. Point bundle-macos.sh at macos-arm64 or macos-x64 (with distinct output directories, since every bundle is named Futureboard Studio.app) to produce them locally.

The in-app updater ranks these: it takes the image matching the running architecture first, falls back to the universal one, and never installs the other architecture's image.

Several subsystems expose verbose logging and debug behavior through environment variables — set the logging variables to 1 to enable them.

# bash
FUTUREBOARD_PLUGIN_VIEW_DEBUG=1 cargo run -p futureboard_native
# PowerShell
$env:FUTUREBOARD_PLUGIN_VIEW_DEBUG=1; cargo run -p futureboard_native

Futureboard
├─ apps/         native · web
├─ crates/       SphereDirectAudioEngine · SphereWebAudioCore · SphereUIComponents · SpherePluginHost · SphereAudioPlugins
├─ packages/     assets · shared
├─ plugins/      modules/      extensions/
├─ external/     vendored SDKs
└─ packaging/    native bundle scripts

Toward a usable native DAW foundation: a stable native GPUI shell, audio clip editing, timeline & MIDI editing, mixer routing, native plugin hosting (VST3 editor embedding, CLAP support), a project file format, automation lanes, audio export, and cross-platform packaging. See ARCHITECTURE.md for current status.

Help translate Futureboard Studio through the Futureboard Studio project on Crowdin. The English source catalog and downloaded locale files live under packages/shared/locales; see the translation guide for the catalog format and maintainer workflow.

Contributions are welcome — bug reports, build testing, documentation, UI fixes, plugin-hosting and audio-engine work, and platform support. Please read CONTRIBUTING.md before opening a pull request; UI work also follows DESIGN.md and AGENTS.md.

The MIT License permits forks and modified distributions of covered Community Edition source code. It does not authorize third parties to present modified software as an official Futureboard product or to imply endorsement.

Third-party forks that refer to Futureboard in product-facing materials must use distinct product branding and prominently display this notice:

This project is an independent third-party fork of Futureboard Community Edition. It is not affiliated with, endorsed by, sponsored by, or supported by the Futureboard project or its maintainers.

Factual statements such as "based on Futureboard Community Edition" are allowed when accurate and when the fork's own branding is more prominent. See TRADEMARKS.md for the complete naming, logo, redistribution, fork, and Professional Edition policy.

Futureboard Community Edition source code is licensed under the MIT License. Required third-party notices and licenses remain applicable; see NOTICE.md and the relevant dependency directories.

The Futureboard names, logos, product identity, and trade dress are not licensed for use as the branding of modified products merely because the source code is open source. See TRADEMARKS.md. Futureboard Professional Edition components are separately licensed and are not part of the public Community Edition repository.