OwnAudioSharp 4.0 · Now powered by Rust
A Rust audio engine
with a C# soul.
The entire audio path — decode, mix, effects, resample, playback and capture — now runs in a purpose-built native Rust engine. You still write 100% C#. The result: a fully native real-time path, and audio that never stutters.
The 4.0 idea
One unchanged API.
A completely new engine.
Your code doesn't change — 4.0 is fully backward compatible. What changed is everything underneath it. From the first sample to the last byte, your audio is now processed by a native Rust core written specifically for this package. Nothing like it exists for C# today.
OwnaudioNet, AudioMixer, sources, effects — unchangedownaudio-ffi + ownaudio-core — decode, mix, DSP, resample, I/OWhy the Rust + C# pairing wins
Native performance,
managed developer experience.
The hardest problem in .NET audio is a managed processing stage — one pause at the wrong moment and the buffer underruns. 4.0 removes that failure mode entirely by moving every sample into native code.
Fully native, zero dropouts
Not a single sample is processed in managed code. No matter what your surrounding C# code is doing, the audio never stutters.
A purpose-built Rust core
Lock-free ring buffers, SIMD converters, pre-allocated DSP and a sinc resampler — engineered to strict real-time constraints, not adapted from a general-purpose library.
Zero external dependencies
One NuGet package. The native engine — including the audio decoder — is bundled and built specifically for it. Nothing else to install, no system codecs to configure.
Low CPU & memory
Real-time headroom on desktop and mobile alike, with a small memory footprint — engineered to professional, industry-standard behaviour.
Backward compatible
The public C# API is unchanged. Upgrade to 4.0 and keep your existing code — you get the new engine's guarantees without a rewrite.
Truly cross-platform
Windows, macOS, Linux, Android and iOS from a single API and a single codebase — the same Rust engine everywhere.
Familiar C#, native speed
Five lines to playing audio.
The API you already know. The engine you always wanted underneath it.
using OwnaudioNET;
using OwnaudioNET.Mixing;
using OwnaudioNET.Sources;
// Initialize (async — safe for all UI frameworks)
await OwnaudioNet.InitializeAsync();
OwnaudioNet.Start();
// Create the mixer — backed by the native Rust engine
var mixer = new AudioMixer(OwnaudioNet.Engine!.UnderlyingEngine);
mixer.Start();
// Play a file — decoded by the built-in Rust decoder, no FFmpeg required
var track = new FileSource("song.mp3");
mixer.AddSource(track);
// Add reverb — real-time DSP running natively, off the managed heap
var reverb = new ReverbEffect { RoomSize = 0.7f, Mix = 0.3f };
mixer.AddMasterEffect(reverb);
// Cleanup
mixer.Dispose();
await OwnaudioNet.ShutdownAsync();Four generations
The road to 4.0.
A truly real-time-safe audio API took four generations — each one solved a problem the last one exposed.
MiniAudio + PortAudio + FFmpeg
Proved the core idea and shaped the API — but left performance on the table.
Fully managed, zero native dependencies
Clean and portable, but the managed runtime's impact on the real-time audio path could not be eliminated.
Optimized native I/O, managed DSP
Fast — until the host application put the runtime under load, which stalled the managed processing stage.
The entire audio chain runs in native Rust
A C# audio API that is completely unaffected by the managed runtime — professional, industry-standard behaviour for real-world .NET audio apps. This is the payoff.
Everything in the box
A complete audio toolkit.
Recommended for music players and DAWs, DJ software, music-education tools, broadcast and podcast pipelines, live-performance apps, and low-latency game audio.
Pick your build
One API. The right footprint.
Choose the package that fits your platform and size budget. Add-ons attach only when you need them.
dotnet add package OwnAudioSharp # Desktop — everything
dotnet add package OwnAudioSharp.Mobile # Android / iOS
dotnet add package OwnAudioSharp.Basic # Desktop — minimal engine.NET 10.0 or later. The native Rust engine — including the built-in decoder for MP3, FLAC, WAV, AAC, ALAC, MP4/M4A, OGG/Vorbis and AIFF — is bundled in the package. There are no external codecs to install and no FFmpeg involved anywhere.
Documentation
Start anywhere. It's in order.
Three minutes to first sound, five concepts that explain the rest, and an API walked through in the order you actually meet it.
Behind the code
Development tools.
OwnAudioSharp is developed with the following tools.
Native audio, without leaving C#.
Free and open-source. If it ships in your product, consider supporting its development.