Integrated Voice Over Net
High-Performance Network Audio for Games & Simulations
A real-time, multi-party voice communication library purpose-built for gaming and simulation/training. Encrypted, scalable, and ready to drop into your engine.
Get in Touch API DocumentationFrom IDI-Systems, the team behind ACRE
IVON (Integrated Voice Over Net) is a voice communication library built specifically for games, training simulations, and virtual environments. It is not a repurposed VoIP stack or a hosted service with per-user fees. It runs on your infrastructure with no external dependencies.
The library covers the full voice pipeline: capture, variable-rate Opus encoding at up to 48 kHz with server-controlled codec profiles per voice group, network distribution via dedicated UDP fanout workers, and mixed spatial output. All traffic is encrypted by default with per-group key isolation.
IVON is modular: ship only what your project needs. A standalone client, a dedicated server, an audio processor, or the full suite. Cross-platform across Windows and Linux, with a stable C API for engine compatibility and header-only C++ wrappers for straightforward integration.
Everything you need to ship production voice communication: audio processing, networking, security, and engine integration in one library.
Variable-rate Opus encoding at up to 48 kHz fullband. Server-defined codec profiles per voice group let you balance bandwidth and quality exactly where it matters.
Built for the real internet. Lost packets and jittery connections won't break your voice channel.
Encryption is mandatory. Every connection, every group, every packet — each with independent keys and automatic rotation.
Separated control and data planes with server-defined codec profiles per group and dedicated UDP fanout workers — voice traffic scales independently while optimizing bandwidth per channel.
First-class hooks for positional audio. Plug in your HRTF, panning, or spatial engine at three dedicated points in the pipeline.
A stable C API and a runtime dynamic loader mean zero friction with your engine and toolchain.
The high-level VoiceSession API bundles client, audio, and networking together. Connect, capture, and start speaking in just a few lines.
// Load the library at runtime
ivon_client_loader_open("bin/libivon_client.dll");
// Configure connection
ivon::VoiceSessionWrapper::Config config;
config.client.server_address = "192.168.1.10";
config.client.server_port = 9129;
config.client.client_id = "player-1";
config.voice_group_id = "squad-alpha";
// Connect and start talking
ivon::VoiceSessionWrapper session(config);
session.set_pcm_source([](std::span<float> pcm) { /* feed mic capture */ });
session.on_tofu_verify([](auto...) { return true; });
session.connect();
session.start_audio();
session.start_speaking(IVON_SPEAKING_MODE_VAD);Need more control? The standalone Client + Audio API gives full independent access to networking and audio processing. Browse the full API reference →
IVON is built on a lockless architecture designed for real-time constraints. The audio pipeline uses a phased processing model with parallel decode, parallel DSP, and mix stages separated by barriers, guaranteeing zero data races with predictable latency. All network I/O runs on C++20 coroutines via ASIO, fully non-blocking. Pre-allocated memory pools eliminate per-packet allocation, and a zero-copy data path moves audio from network socket to output buffer without unnecessary copies. The result is deterministic, low-latency performance that stays consistent under load.
Whether you're wiring up tactical mil-sim radio nets with server-controlled codec profiles simulating degraded channels, running classified training exercises on air-gapped infrastructure with per-group encryption isolation, shipping squad voice in a co-op shooter with spatial audio following every pawn, or running proximity chat with up to 256 concurrent speakers in a single voice group, IVON handles it on your servers with zero per-user fees.
The first in a series of engine plugins. Unity, Godot, and custom engine integrations are planned. Get in touch to discuss your integration needs.
Full voice chat from Blueprint alone. Over 40 callable nodes, 12+ event delegates, and zero C++ required for basic integration.
The plugin exposes the entire IVON voice pipeline through BlueprintCallable methods and BlueprintAssignable delegates. Connection management, group membership, mic capture, push-to-talk, muting, and typed messaging are all accessible from the Event Graph. Designers can prototype working voice chat without opening a C++ file. For teams that do work in C++, the same API is available with additional hooks for TOFU verification, password authentication, and custom audio-thread DSP processing.
Attach voice output to any actor. Built-in 3D spatialization, distance attenuation, and per-sender DSP hooks for custom spatial processing.
The plugin ships three voice components. SingleVoiceComponent binds one speaker to one actor with full UE spatialization via attenuation assets and 3D positioning. MultiVoiceComponent mixes multiple speakers with constant-power stereo panning or passes mono output to UE's own spatial pipeline. SpeakerComponent ties a voice identity to a pawn and replicates it across the network, automatically creating voice sinks on remote clients. All three support editor-configured auto-binding: set a ClientId and group filter in the Details panel, and voices route themselves at runtime.
Multiple simultaneous voice channels. Squad comms, team chat, proximity voice. Per-group muting and transmit control from Blueprint.
Voice groups are server-side chat rooms that clients join and leave at runtime. A single client can be in multiple groups at once, each with independent muting and transmit control. Group membership changes fire delegates that voice components listen to for auto-binding. The plugin also supports typed messaging (point-to-point, broadcast, or group-scoped) alongside voice, useful for gameplay signaling that should travel the same network path.
SpeakerComponent replicates voice identity across all clients. Remote voice sinks auto-create on pawns with no manual networking code.
When you add a SpeakerComponent to a pawn, the owning client's IVON ClientId is automatically filled in and replicated to the server and all remote clients. On each remote machine, the component creates a SingleVoiceComponent bound to that speaker, with optional sound attenuation settings for distance-based falloff. When the pawn is destroyed or the speaker clears, the voice sink is cleaned up automatically. The result is positional voice that follows characters around the world without any manual RPC setup.
LocalPlayer subsystem with automatic lifecycle. Dynamic library loading with no compile-time dependency. Installs cleanly alongside your project.
The plugin is a single Runtime module that loads the IVON client library dynamically at startup. There is no build-time dependency on the IVON SDK beyond what ships inside the plugin folder. The core API lives on a per-LocalPlayer subsystem that is created and destroyed automatically with the player. One subsystem instance manages one IVON session: connection state, audio capture, group membership, and audio routing. The subsystem is globally accessible from any Blueprint or C++ class via the local player.
Lock-free mic capture, async callback bridging, per-sender audio routing. The audio pipeline never blocks the game thread.
Microphone capture runs on a dedicated platform thread and pushes frames into a lock-free ring buffer. The IVON audio thread consumes those frames without contention. Incoming decoded audio is intercepted by an audio router that dispatches per-sender PCM to registered voice component sinks. All IVON callbacks are bridged to the game thread via AsyncTask with weak-pointer guards to prevent stale references. DSP hooks (pre-spatial mono, post-spatial stereo) execute on the audio thread for low-latency custom processing.
IVON is a library, not a service. Host your own server, keep your data on your own network, and pay zero per-user fees. No cloud dependency, no third-party accounts, no surprises on your invoice.
IVON is licensed as self-hosted commercial middleware for games and simulation systems. Licenses are available for evaluation, single-project production use, or broader program/enterprise deployment. All tiers avoid per-seat pricing; production rights are based on project or organizational scope, with redistribution permitted only when shipped as a component of a licensed application.
Integration support and non-recurring engineering services are available for teams that need help bringing IVON into an existing codebase or adapting it to a specific platform or workflow.
Interested in licensing IVON for your project? Whether you need a single integration or a custom deployment, we are happy to discuss options.