Integrated Voice Over Net
High-Performance Network Audio for Games & Simulations
A real-time, multi-party voice communication library for games and simulation/training. It runs on your own infrastructure and integrates directly with 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 with server-controlled codec profiles per voice group, network distribution over UDP, and mixed spatial output. All traffic is encrypted by default with per-group key isolation.
IVON is modular: projects can ship a standalone client, a dedicated server, an audio processor, or the full suite. It is cross-platform across Windows and Linux, with a stable C API for engine compatibility and header-only C++ wrappers for straightforward integration.
IVON covers audio processing, networking, security, and engine integration in a single library.
Server-defined codec profiles let each voice group run its own Opus encoding rate and frame duration, so bandwidth and quality can be set per channel.
Audio remains intelligible on lossy and high-latency connections, and loss handling can be tuned to each deployment's network conditions.
All traffic is encrypted, with independent keys per connection and per voice group, and automatic key rotation.
Control traffic runs over TCP while audio is distributed over UDP on dedicated worker threads, and per-group codec profiles keep bandwidth manageable as participant counts grow.
The pipeline exposes three dedicated hook points for positional audio, where you can plug in your own HRTF, panning, or spatial engine.
The library exposes a stable C API and loads dynamically at runtime, so it places no build-time requirements on your engine or toolchain.
The high-level VoiceSession API bundles the client, audio processing, and networking into a single object. The example below shows a complete connection.
// 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 →
The audio pipeline uses a lockless, phased processing model: decode and DSP stages run in parallel and hand off to the mix stage through barriers, which keeps latency predictable. All network I/O is asynchronous and non-blocking. Pre-allocated memory pools avoid per-packet allocation, and audio moves from the network socket to the output buffer without intermediate copies.
Tactical radio simulations can use server-controlled codec profiles to model degraded channels. Training exercises on air-gapped networks benefit from per-group encryption isolation. Games can attach spatial voice to characters for squad or proximity chat, with up to 256 concurrent speakers in a single voice group. In each case, IVON runs on your own servers with no 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.
The plugin exposes over 40 Blueprint-callable nodes and 12+ event delegates, so a basic voice chat integration requires no C++.
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.
Voice output can be attached to any actor, with 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.
Clients can join multiple voice channels at once, such as squad comms, team chat, and proximity voice, with 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 and creates remote voice sinks on pawns automatically, without 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. Positional voice follows characters without any manual RPC setup.
The plugin runs as a LocalPlayer subsystem with automatic lifecycle management, and loads the IVON library dynamically with no compile-time dependency.
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.
Microphone capture is lock-free, callbacks are bridged asynchronously, and audio is routed per sender. 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 ships as a library that you host on your own servers. Voice data stays on your network, there is no dependency on external cloud services or third-party accounts, and licensing involves no per-user fees.
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.