Rust Audio Visual Engineering Toolkit — a Rust framework in development for audio plug-ins and standalone audio applications.
Version 0.1.0 exports one product description as CLAP, VST3, AUv2, AAX and LV2 plug-ins on macOS, Windows and Linux. See the release notes, the changelog and the support matrix for what is included, which hosts and platforms have recorded evidence, and the limits. APIs may still change in 0.x minor releases under the compatibility policy.
The tempo-synced delay plug-in shows a complete effect: one portable processor, a product description and a web editor, exported as CLAP, VST3, AUv2, AAX and LV2 through the prototype generic plug-in layer. The portable mono/stereo gain processor remains the minimal reference, with sample-timed automation, linear smoothing and deterministic offline tests. A loadable CLAP gain prototype is now implemented and tested on macOS arm64. Reusable parameter/state primitives are implemented, with complete CLAP gain/bypass recall and a prototype macOS embedded editor. Additional VST3, AUv2, AAX and LV2 gain references and explicit audio-device adapters have scoped prototype evidence. See the catalogue for their limits and the broader DSP/state/file/MIDI/OSC components.
Start with the documentation index for setup, architecture, API reference, and the feature catalogue. Documentation is updated alongside implementation; maintenance describes the registry, generation, and continuous checks.
Plug-in editors are ordinary HTML pages hosted in the platform web view. These
are WebKit snapshots of the built CLAP bundles' editors on macOS, captured with
ravet-editor-smoke's capture example.
Tempo-synced delay (examples/delay-plugin/editor)
Minimal gain editor with an asset stylesheet (examples/gain-plugin/editor)
python3 scripts/bundle-clap.py --plugin delay
cargo run -p ravet-clap-smoke --locked -- --delay "target/clap/release/RAVET Delay.clap"This builds an ad hoc signed RAVET Delay.clap into Cargo's target directory
on macOS and checks it in the development smoke host. It is not installed into a
plug-in folder. Copy it to ~/Library/Audio/Plug-Ins/CLAP to try it in a CLAP
host. Named-host Delay runs and their limits are recorded in the
support matrix. Its source is in
examples/delay-plugin.
From the workspace root:
cargo run -p ravet-gainThis runs an eight-frame stereo fixture, applies gain events at frames 0 and 4,
checks both channels against known outputs, and prints the result. It does not
open an audio device. The reusable processor is in
examples/gain/src/lib.rs. The CLAP adapter uses the
same Processor implementation as the explicit device adapters.
For MIDI synth and effect WAV renders, MPE expression and MIDI 2.0 packet walkthroughs, see Small examples.
python3 scripts/bundle-clap.py
cargo run -p ravet-clap-smoke --locked -- "target/clap/release/RAVET Gain.clap"The bundle command requires Python 3.11+ and builds an optimized plug-in into
Cargo's target directory. On macOS it creates an ad hoc signed .clap bundle.
--profile debug selects a debug build. It does not install the plug-in into a
system or user plug-in folder. The printed path reflects CARGO_TARGET_DIR.
Delay packaging and host runs on Windows/Linux are recorded in the
support matrix; generic editors remain macOS-only.
The smoke host loads the built bundle and checks mono/stereo ports, gain parameter metadata/text, sample-timed automation, inactive/active parameter flush, reset, session state recall, and six activation cycles. Audio processing runs on a separate thread. Use this command only with the trusted RAVET bundle built here.
With CLAP validator installed, also run:
clap-validator validate "target/clap/release/RAVET Gain.clap"Current validator, audio smoke-host and native editor probe evidence is recorded in work status. Native editor checks use a Cocoa main loop and do not establish DAW compatibility. See the CLAP backend decision for adapter limits.
RAVET Foundry creates and builds independent offline, application and effect/instrument plug-in projects using the RAVET UI. The guide includes source-build instructions for Foundry on macOS, Windows and Linux, and validation limits for generated targets.
The generated package list follows Cargo workspace manifests. See architecture for crate boundaries and feature status for implementation scope.
Portable processing stays independent of host, device and editor backends; optional codecs and drawing/text backends have their own dependencies and notices. Foundation uses pure-Rust libm for no_std parameter math. Portable processing crates forbid unsafe code. The CLAP adapter also forbids unsafe code and uses Clack. The export/host packages isolate ABI export, dynamic loading, and raw test fixtures behind narrow unsafe allowances. The explicit macOS WebKit binding is isolated from portable DSP; Xcode is required for native workspace builds. Gain tests use a development-only allocation counter.
Prepare a processor with a sample rate, channel layout, maximum frame count, and event capacity. Processing accepts variable block sizes, including zero frames. Audio is planar f32, with distinct constructors for in-place and separate input/output storage. Views expose only active frames and preserve unused backing tails.
Input events must fit the prepared capacity and arrive in nondecreasing frame order. Same-frame events keep their input order. Events take effect before the sample at their offset; an offset equal to a nonempty block's size is invalid and belongs at offset zero of the next block. A zero-frame block accepts offset-zero events without advancing smoothing. Invalid blocks are rejected as a whole and their active outputs are silenced.
The gain parameter uses the stable GAIN_ID, a physical amplitude multiplier
from 0 to 4, with 1 representing unity. Finite out-of-range values are clamped;
nonfinite parameter values reject the block. Unknown IDs and valid note
events are ignored by gain. Default smoothing is 5 ms. Set it to zero with
GainProcessor::new(0.0) for immediate automation. Smoothing advances once per
frame across both channels and preserves output when block partitions change.
See the executable API example in the gain crate's Rust documentation and the processing decision for lifecycle, reset, event, and failure semantics. Public APIs are provisional.
python3 scripts/check-docs.py
cargo fmt --all -- --check
cargo check --workspace --locked
cargo test --workspace --locked
cargo clippy --workspace --all-targets --locked -- -D warnings
RUSTDOCFLAGS="-D warnings" cargo doc --workspace --no-deps --lockedSee Contributing for documentation updates and checks appropriate to a change. The documentation workflow checks the catalogue and builds API reference artifacts when pushed to GitHub.
The allocation tests measure only the processing thread, including repeated callbacks, buffer view construction, events, smoothing, resets, and faults. They check both allocation and deallocation and include a concurrently allocating worker. CLAP tests also measure 10,000 callbacks through the host ABI and 10,000 in-place bridge callbacks, including malformed-event paths. The counter replaces the allocator only in the test binary that uses it; preparation and assertions happen outside measured callbacks.
Tested development environment: Rust/Cargo 1.99.0 on macOS 27.0.1, arm64. This is an observed toolchain; the declared minimum Rust version is 1.88. The support matrix separates actual Delay host runs from format validators on macOS arm64, Windows 11 x64 and Arch Linux x86_64. A silent UMC1820 output probe exercised standalone callbacks; audible output and deadlines remain unvalidated by that probe. Hosted CI configuration alone supplies no runtime evidence. Offline tests do not establish real-time deadlines.
Work status records the implementation and next work. The architecture guide and decision records describe the design and its reasons.
Extended processing, MIDI short messages and standalone output have scoped implementations and validation. The feature catalogue separates these capabilities from planned integrations. VST2 is outside the project's scope. Packages remain unpublished.
RAVET uses GPLv3 plus separate commercial licensing. The repository's
open-source edition is GPL-3.0-only; see LICENSE.
Commercial licences for proprietary distribution are available at https://djwaudio.co/ravet/licences/: Starter: free (company revenue up to $50,000), Indie: $199 per developer per year (above $50,000, up to $500,000), and Pro: $699 per developer per year (above $500,000, unlimited). Prices are in USD; no VAT is charged. Paid licences include twelve months of updates and permanent commercial rights to the versions received; renewal is optional. All tiers include all supported features, unlimited products, and no royalties. Commercial rights come from an accepted Order under the RAVET Commercial Licence Agreement; this README grants none. These thresholds do not restrict GPL-compliant use.
See LICENSING.md for the commercial policy, how an Order works, and contribution and dependency requirements.
Run the live documentation portal for searchable guides, feature limits and the workspace API reference.

