We’d like to kick things off by expressing our deepest gratitude to everyone in the ODIN Voice community - our early adopters, integration partners and beta testers - whose feedback and enthusiasm have driven us to push the boundaries of real-time voice chat SDKs. Our community has gone above and beyond, creating integrations for popular game engines like Godot alongside our official Unreal and Unity Engine plugins. These contributions demonstrate the power of collaboration and extend ODIN’s reach into even more development environments.
We’re also thrilled to celebrate a major milestone: Ghosts of Tabor, the award-winning VR title from Combat Waffle Studios, was the first game to integrate ODIN Voice on PC and Meta Quest. On May 7th, this pioneering title has launched on PlayStation VR2 with ODIN Voice seamlessly integrated, marking the first PS VR2 release featuring our technology and highlighting Combat Waffle Studios’ integral role in our journey from day one.
Building Toward ODIN Voice 2.0
Today, we’re proud to announce the availability of an updated ODIN Voice Core SDK - version 1.8, an intermediate milestone on the road to ODIN Voice 2.0. With 1.8, you get early access to three cornerstone features that not only solve long-standing pain points but also pave the way for the even richer, more powerful 2.0 experience that’s coming soon.
Let’s dive into the technical details:
A New Foundation with Connection Pooling
With 1.8, we’re introducing transparent pooling of connections. A Connection Pool in ODIN is a core component that manages all communication between your application and the ODIN server infrastructure. Think of it as your networking command center - handling connections, routing voice data, dispatching control messages and joining multiple rooms - all in a thread-safe, efficient manner.
In practice, this means you can:
- Share connections across multiple rooms, reducing overhead and complexity.
- Receive voice data and control messages through centralized callbacks, which makes it easier to scale and manage your app’s audio logic.
- Coordinate shutdowns safely, so you don’t have to micromanage cleanup routines.
Here’s how you’d typically initialize a new Connection Pool:
OdinConnectionPool* pool;
OdinConnectionPoolSettings settings = {
.on_datagram = &on_datagram, // Handles voice packets
.on_rpc = &on_rpc, // Handles control messages
.user_data = &state // Passes context to callbacks
};
odin_connection_pool_create(settings, &pool);
The on_datagram and on_rpc callbacks are your hooks into the ODIN world. Voice data packets and control messages (such as room events) are pushed here, and from there, you route them to the appropriate logic - like feeding packets into audio decoders or parsing incoming RPC messages.
Once the pool is initialized, you can create and join a room like so:
OdinRoom* room;
odin_room_create(pool, "<SERVER_URL>", "<TOKEN>", &room);
This immediately begins the asynchronous process of joining the specified room via the provided token and server URI. Under the hood, ODIN automatically handles authentication, connection establishment, and resource synchronization across rooms that share the same pool.
Customizable Audio Pipelines and Effects
In ODIN Voice, all audio capture and playback is handled by dedicated encoders and decoders, each responsible for transforming raw PCM data to and from compressed network datagrams. These components seamlessly integrate with ODIN’s runtime and automatically manage tasks like sample rate conversion and stream routing. But the real power lies in the audio pipeline that sits inside every encoder and decoder.
An audio pipeline is a dynamic, modular chain of effects that process your audio in real time. Whether it’s suppressing background noise, detecting voice activity or fine-tuning gain levels, each effect in the pipeline contributes to delivering clean, intelligible voice communication - regardless of device or environment.
Up until now, ODIN has shipped with powerful built-in filters like:
- Voice Activity Detection (VAD) to intelligently decide when a user is speaking
- Audio Processing Module (APM) to apply enhancements like echo cancellation, noise suppression and automatic gain control
These features continue to improve with each release. But with version 1.8, we’re giving developers even more flexibility with Custom Effects - a new addition in ODIN Voice - to open the door to entirely new audio processing use cases.
You can now inject your own signal processing logic directly into the ODIN audio pipeline. These callbacks run inline with the sample stream, allowing you to modify, analyze or monitor audio in real time - before it’s encoded for transmission or after it’s decoded for playback.
Here’s what it looks like at a high level:
void my_effect_callback(float* samples, uint32_t sample_count, bool* is_silent, const void* user_data) {
// Custom DSP logic here
}
uint32_t effect_id;
odin_pipeline_insert_custom_effect(pipeline, index, my_effect_callback, user_data, &effect_id);
This gives you total control over the audio stream - from building your own noise detection heuristics to logging silence thresholds or even experimenting with AI-based filters. Better yet, the effect chain is fully thread-safe and can be modified at runtime: insert, reorder or remove effects on the fly.
Whether you’re prototyping experimental audio features or integrating with an in-house DSP engine, custom effects make ODIN more extensible than ever before.
Built-In Privacy Without Server Trust
With version 1.8, ODIN Voice takes a major step forward in security and privacy by introducing native End-to-End Encryption (E2EE) through a pluggable OdinCipher module.
This means your application can now encrypt all voice data, signaling messages and peer metadata with a shared room password - ensuring that no one but your users can decrypt the content, not even 4Players’ servers.
Here’s how it works:
OdinCipher* cipher = odin_crypto_create(ODIN_CRYPTO_VERSION);
odin_crypto_set_password(cipher, (const uint8_t*)"secret", strlen("secret"));
odin_room_create_ex(pool, "<SERVER_URL>", "<TOKEN>", NULL, user_data, user_data_length, position, cipher, &room);
Behind the scenes, ODIN Voice derives a master key from your shared password. For each peer, it then generates unique session keys using random salts. These salts are exchanged within the room so that all participants can reconstruct each other’s keys - but crucially:
- The master password never leaves the device
- No long-term keys are stored or transmitted
- Keys are automatically rotated every 1 million packets or 2 GiB of data
This design minimizes the risk of both passive eavesdropping and active attacks. As long as your password stays secret, your communications remain private - without needing to trust the infrastructure or manage external key exchanges. Whether you’re building secure enterprise tools, private social spaces or games where confidentiality matters, E2EE in ODIN Voice gives you the cryptographic foundation you need - with minimal overhead and full control.
What’s Next for You?
While 1.8 delivers these foundational capabilities, ODIN Voice 2.0 will be a generational leap forward.
We’ve re-architected our entire API to be fully asynchronous and non-blocking, delivering performance boosts that will be immediately apparent in demanding, real-time environments. But most importantly, we’ve re-imagined ODIN’s voice routing from the ground up. We don’t want to spoil everything just yet, but let’s just say… our upcoming Channel Mask system opens up entirely new ways to control how, where and to whom audio is delivered. If you’ve ever wanted precise, layered, signal-aware communication - it’s coming.
Over the coming weeks, we’ll share beta previews, tutorials, and migration guides to help you make the leap to ODIN Voice 2.0. We’d love to hear what you think. Your insights today will shape what 2.0 becomes tomorrow. Let’s keep building the future of real-time voice - together.
Stay tuned!