Legato
a Rust audio graph framework with a minimal DSL
Last verified:
What is Legato?
Legato is a realtime audio framework and domain-specific language for quickly building audio applications in Rust. It focuses on graph-based audio design, where the DSL is used only for defining signal graphs and mapping directly to runtime builder operations. Users can define custom nodes in Rust and reuse them inside the DSL, which keeps complex DSP logic in Rust while preserving a minimal orchestration language.
The tool also supports patches, which act like reusable macros of nodes that get inlined into the same graph. This makes it easier to build repeated structures such as synth voices, chorus blocks, and effect chains without recreating everything manually. Legato emphasizes a flat allocation model and a workflow that is closer to graph orchestration than to writing a full programming language.
Legato is aimed at technical audio developers who want more control than drag-and-drop tools while still avoiding the complexity of larger audio languages or UI-heavy systems. It is designed to run anywhere Rust can run, and the site positions it as useful for software synths, grooveboxes, creative audio apps, and other realtime DSP projects.
The documentation also suggests it is a good fit for users who want to compose larger audio systems in Git, extend the engine with their own Rust nodes, and keep the audio architecture understandable and modular. The project frames itself as a minimal but extensible foundation rather than an all-in-one music production environment.
Legato pricing
Pricing model: Freemium
The website does not list pricing, free tiers, or paid plans. Based on the documentation, Legato is available as an open-source project under AGPLv3, with additional permissions mentioned for many creative projects such as VSTs, software synths, grooveboxes, and similar applications. The site points users to the LICENSE, CONTRIBUTING, and ADDITIONAL_PERMISSIONS files in the repository for the actual terms, but it does not describe commercial subscription plans or included paid packages.
Legato pros
- Realtime audio framework
- Built for Rust
- Minimal DSL
- Graph-based workflow
- Custom nodes in Rust
- Reusable patches
- Patches are inlined
- Direct mapping to runtime builders
- Flat allocation reuse
- Good for modular DSP
- Avoids learning a new audio language
- Can be used as a library
- Supports CPAL audio backend
- Works cross-platform through Rust
- Suitable for synths and grooveboxes
- Good for performance optimizations
- Composable in Git
- Can sidestep CPAL if needed
- Designed for extension
- Lower cognitive load than heavier tools
Legato cons
- Not a full programming language
- No loops in the DSL
- No branching in the DSL
- No evaluations in the DSL
- Audio setup may require tuning sample rate
- Audio backend behavior varies by OS
- CPAL may need workarounds
- Documentation is still evolving
- Feature set is still limited
- Planned features are not yet available
- Technical users are the main target
- May be less friendly for beginners
- Not a visual drag-and-drop tool
- Does not aim to replace full DAWs
- Some features depend on Rust knowledge
Frequently asked questions about Legato
What is Legato?
Legato is a realtime audio framework and DSL for quickly building audio applications in Rust. It is centered on graph definitions rather than on a general-purpose language, so the DSL is used to describe audio routing and node connections while the runtime handles execution.
How does the DSL work?
The DSL is intentionally minimal and is only meant for graph definitions. It does not include evaluations, loops, or branching, and those definitions map directly to builder operations on the runtime, which keeps the orchestration layer simple and predictable.
Can I write my own audio logic in Rust?
Yes. Users can define custom nodes in Rust and then use those nodes inside the DSL. The site presents this as a way to keep advanced DSP logic in Rust while avoiding the need to learn a separate audio programming language.
What are patches in Legato?
Patches are reusable macros of nodes that can be instantiated in the graph. They are inlined into the same graph and reuse the same underlying flat allocation, which makes them useful for repeated structures like synth voices or effect blocks.
Should I use a custom node or a patch?
Use a custom node when you want better performance or want to wrap complex logic into one reusable Rust-backed unit. Use a patch when you want a reusable graph structure, such as a chorus, a synth voice, or another repeated audio block.
Does Legato support CPAL?
Yes. The documentation says Legato currently uses CPAL for cross-platform audio, and it also notes that CPAL can be bypassed if desired. It warns that usable audio may require tuning sample rate, block size, or backend-specific settings depending on the operating system.
What kind of developers is it for?
Legato is aimed at somewhat technical users who want control over audio architecture without the overhead of a complex UI-driven system. The site says it hopes to become more accessible over time, but the current target audience is still technical Rust and DSP users.
Can I use Legato as a library?
Yes. The site explicitly says Legato can be used as a library, allowing users to take only the parts they need rather than adopting it as a complete all-in-one environment.
What does the license allow?
The project says the source of truth is the LICENSE, CONTRIBUTING, and ADDITIONAL_PERMISSIONS files in the repository. It states that the software follows AGPLv3, while also suggesting that many creative projects, including VSTs and software synths, may be able to deploy or monetize without source disclosure under the additional permissions.
What features are planned?
The planned features include more node types, graph metadata tooling such as LSP support, better images for embedded Linux deployment, oversampling logic, possible UI tooling, and VST examples. These are listed as future goals rather than current capabilities.