NO ACCOUNT • NO TRIAL • NO PRICE
Fourteen synthesizers, eighteen effects, a sampler, a mixer and AI stem separation — all in the download, all running at 64-bit float, with sandboxed, crash-proof VST3, CLAP, LV2 and VST2 plugin hosting. Windows and Linux.
THE FREE DAW
Everything below ships in the free download. Nothing is a demo, a tier or an add-on.
Launch clips in a quantized session grid, then lay them out on a sample-accurate timeline. Both views share one engine, one mixer and one piano roll.
Every voice is computed, never played back: waveguide pianos and violins, a physically modelled drum engine, spectral image synthesis and a synth driven by the periodic table.
Sympathetic string resonance, hammer-strike impulse noise and a continuous damper pedal model.
Drop a loop, slice it on transients, warp it to tempo and modulate every hit. Polyphonic, and free of clicks.
Drawer-based modulation. Classic LFOs and envelopes sit next to cellular automata, chaotic attractors, orbital mechanics and audio followers, and everything can patch to anything.
Tempo-synced LFO with Hermite interpolation and a hand-drawn shape editor.
Split any clip into vocals, drums, bass and other with htdemucs on the GPU, without leaving the arranger. Warp settings and fades carry over to the new tracks.
Ten instruments and effects built for OMNi: memory-isolated, GPU-drawn, and crash-proof by design. Free to download from the hub.
Also from OMNi Audio
Master of rhythm. TOMiC 0.6 is a hardware-style groovebox workstation for beats, basslines, melodic synthesis, and modular sound design you play like an instrument, not a plugin. Bought once, updated for life.
A workstation should never drop a buffer because a plugin misbehaved or the UI redrew. These are the four hard problems of a real-time audio engine, and how OMNi solves each one.
Standard multi-threaded communication relies on Mutexes or channels that allocate heap memory. In an audio thread, acquiring a lock or triggering an allocation will cause priority inversion or garbage collection pauses, producing audible dropouts (buffer underruns).
All UI control changes and MIDI triggers are serialized into fixed-size enums and passed to the audio thread via lock-free ringbuffers (crossbeam-channel). The audio thread polls these queues using non-blocking calls (try_recv), guaranteeing zero locks and zero allocations.
pub struct AudioQueue {
sender: crossbeam_channel::Sender<AudioCommand>,
receiver: crossbeam_channel::Receiver<AudioCommand>,
}
impl AudioQueue {
// Called on the audio thread — zero alloc, zero locks
pub fn process_commands(&self, state: &mut AudioThreadState) {
while let Ok(cmd) = self.receiver.try_recv() {
match cmd {
AudioCommand::SetParam(id, val) => {
state.set_parameter(id, val);
},
AudioCommand::TriggerNote(note) => {
state.trigger_voice(note);
},
}
}
}
}Standard thread pools (like Rayon) use work-stealing algorithms. While highly efficient for batch operations, they introduce severe scheduling jitter (100μs+) due to OS thread sleeping, which ruins low-latency audio processing cycles.
A custom thread pool (RtThreadPool) using spinning barriers. Worker threads never sleep or yield during buffer calculation; they spin-wait on a shared atomic sequence counter. This keeps threads awake and synchronized, achieving near-zero scheduling overhead.
pub struct SpinBarrier {
counter: AtomicUsize,
target: usize,
}
impl SpinBarrier {
// Spin-wait prevents OS thread sleeping
pub fn wait(&self) {
let mut spins = 0;
while self.counter.load(Ordering::Acquire) < self.target {
if spins < 1000 {
std::hint::spin_loop();
spins += 1;
} else {
std::thread::yield_now();
spins = 0;
}
}
}
}Third-party plugins are notorious for memory leaks, null pointer dereferences, and access violations. Because plugins conventionally run in the host process, a single plugin crash will instantly terminate the DAW, causing projects to be lost.
Omni isolates external plugins into a separate, sandboxed subprocess or protects the audio thread with a sub-millisecond Circuit-Breaker. Audio and MIDI blocks are streamed via shared memory (mmap) and IPC ringbuffers. A plugin crash merely bypasses that node, maintaining DAW stability.
pub struct SandboxedPlugin {
ipc_channel: IpcConnection,
shared_memory: MmapMut,
}
impl SandboxedPlugin {
pub fn process_block(&mut self, input: &[f32], output: &mut [f32]) {
self.shared_memory.write_input(input);
self.ipc_channel.send(IpcSignal::ProcessBlock);
// Wait for signal from sandboxed process
self.ipc_channel.wait_for_signal(IpcSignal::ProcessComplete);
self.shared_memory.read_output(output);
}
}The operating system dynamically swaps RAM pages to disk. If the audio thread requests memory that has been swapped out, a page fault occurs, causing a massive CPU stall. Additionally, denormal floats slow down calculations by 100x.
During engine initialization, we call mlockall to lock all current and future DAW memory pages in physical RAM. Simultaneously, we modify the MXCSR CPU register to enable Flush-To-Zero (FTZ) and Denormals-Are-Zero (DAZ) states on the audio thread.
pub fn configure_realtime_thread() {
// 1. Lock memory pages against swap
#[cfg(target_os = "linux")]
unsafe {
libc::mlockall(libc::MCL_CURRENT | libc::MCL_FUTURE);
}
// 2. Configure MXCSR register (FTZ + DAZ)
#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe {
use std::arch::x86_64::*;
let mxcsr = _mm_getcsr();
_mm_setcsr(mxcsr | 0x8040);
}
}Linux AppImage and Flatpak, or a Windows installer. About a minute from here to your first clip.
Free forever. Pre-alpha builds ship every few weeks.
Questions, bug reports, feature ideas or a track you made in OMNi. Every message is read by the person who wrote the DAW.
Or join the Discord