4Players Blog

Fleet DNS: Clean, Secure Service Addresses in ODIN Fleet

Fri, 03 Jul 2026 00:00:00 +0000

IP port to service link – Fleet DNS enables clear addresses

IP addresses and ports are a nightmare for teams. Players forget the ports, testers share incorrect links, and communities document non-professional addresses. To eliminate this technical hassle, we have integrated DNS into ODIN Fleet. This makes your services easier to access, safer and easier to manage.

Technology holding you back?

Anyone who’s ever wanted to run a game server, a dashboard or an admin panel will be familiar with this: instead of making things easier, technology slows you down. Players, for example, have to memorize IP addresses and ports, or fail to join because they’ve entered the wrong details. To prevent this, communities take it upon themselves to document the addresses on Discord, in launchers or on websites. However, these are so complicated and cumbersome that nobody can really remember them. Even development teams waste valuable time repeatedly answering the same questions: “What was the IP and port again?” or “Why isn’t the link working?”

Technology should work without needing to be constantly explained. It should run in the background whilst users can concentrate on what matters most, whether that’s playing, testing or managing servers.

But more importantly you need secure connections for your users and your team. If anyone who remembers the access to a port or enters by chance the correct number can join, you have clearly a security problem, especially when your connection isn’t secured with the HTTPS standard.

Opening the curtain for Fleet DNS

With Fleet DNS, technical server ports are transformed into simple service addresses. No more chaos of numbers and protocols, just clear links that anyone can share, remember and integrate into workflows. What does this mean in practice? Every access point gets its own, clean address, whether it’s a game port, dashboard or API.

For UDP services, you can now enable Service DNS in the Server Config. This creates a kind of hybrid link with a port, e.g. <id>.fleet.4players.services:27015. Without Service DNS, the UDP port remains accessible only via the traditional IP:port combination. In the case of TCP ports (e.g. web dashboards), the port is omitted entirely: instead of 123.45.67.89:8080, you have addresses such as <id>.fleet.4players.services.

Where Fleet DNS makes the difference

Dashboard

If you run a server and want to share the web dashboard with your team or friends, you’ve currently had to rely on the IP address and port. With Fleet DNS, you simply enable HTTPS DNS for the dashboard port and share a standard link such as https://<id>.fleet.4players.services. This link can be securely opened in the browser straight away, requiring no technical knowledge and triggering no browser warnings. Everyone can access it with a single click, and once bookmarked, it’s easy to come back.

Community servers

A community wants to document its server on Discord, on its website or in the launcher. For TCP ports (e.g. for web services), this results in a clear address without a port number – professional and easy to remember. For game/UDP ports, Service DNS generates a link such as <id>.fleet.4players.services:27015. Both variants are easier to remember than a raw IP address and can be shared in any channel. No guesswork, no need to ask for details, and it just works.

Test server for Teams

Developers, modders and QA teams are all familiar with the problem: test builds need to be shared quickly and easily. Without Fleet DNS, this often involves a back-and-forth exchange of IP addresses and ports that nobody ever manages to keep track of. With Fleet DNS, every test build gets its own address. The web dashboard runs over HTTPS (without a port), the game port is accessible via Service DNS with a port, and everything is ready to use straight away.

But Fleet DNS is more than just a subdomain

Other providers promote ‘free subdomains’ or ‘dedicated IPs’. This is well known and understandable. However, Fleet DNS offers not just a single address for the entire server, but individual addresses for every port and every use case. It is not just a subdomain, rather it is DNS per port, HTTPS for web services and service DNS for UDP ports.

So the most important part here, is that you are making your whole access a lot more secure. Fleet DNS now delivers encrypted connections via SSL which will not only protect your ports even better but will raise trust. Current browsers often warn users when visiting pages without SSL encryption. Fleet DNS has this on board naturally.

If you also want to restrict external access, you can use the Private DNS feature. When activated in the ServerConfig for a port, that port is no longer directly accessible from external IP:Port, but only via the Fleet DNS address. This limits the vulnerability and gives you full power of who can enter. Particularly with HTTPS links, this provides the advantage that communication is encrypted and protected against tampering, which is a crucial difference compared to unencrypted HTTP connections.

Whilst other providers give you subdomains, Fleet DNS gives you control over every service, every port and every use case.

Although Fleet DNS is extremely powerful, there are clear limitations that you should be aware of. For instance, Fleet DNS does not allow you to use your own custom domain, such as my-server.com, nor does it replace authentication or a firewall: whilst private ports reduce the attack surface by preventing direct IP:port access, they do not provide complete protection.

Less technology, more focus on the essentials

But ultimately, the benefits outweigh the drawbacks. Players want to play. Teams want to test. Communities want to grow. Admins want to manage. Nobody wants to mess around with IPs, ports or connection details. Fleet DNS takes that burden off your shoulders.

Check out Fleet DNS for yourself

Bringing ODIN Voice Chat to FMOD: A Complete Toolkit for Studio and Runtime

Wed, 03 Jun 2026 00:00:00 +0000

Bringing ODIN Voice Chat to FMOD: A Complete Toolkit for Studio and Runtime

Voice chat is a must-have for modern multiplayer games—but integrating it into FMOD? That’s like trying to fit a square peg in a round hole. Real-time peer audio isn’t your average baked asset. You can’t import a sound file, preview an event in the editor, or even find a clear spot for your audio team to tweak it like the rest of your mix. Until now.

With the release of our FMOD Studio Plugin, ODIN’s FMOD toolkit is now feature-complete across both the design-time and runtime sides of the pipeline. This post walks through every component, who it’s for, and when to reach for it.

TL;DR Why use ODIN Voice?

You’re using FMOD. You want to add voice chat. Most voice SDKs treat audio output as a black box and push you back to Unity’s or Unreal’s built-in audio engine — undoing the pipeline your team has built around FMOD. ODIN is different:

Voice chat lives inside FMOD. On both Unreal and Unity, peer audio routes through FMOD — so your mix bus structure, effects, attenuation, and spatialization apply to each single voice the same way they apply to every other sound in the game.
Your audio team mixes voice in FMOD Studio. Our new Studio Plugin lets sound designers join a live ODIN room and tune the mix in the tool they already know — before a single line of game code is touched.
Built for real-time games. Low-latency, managed voice service with SDKs for every major engine and platform.
Open-source integration code. Every FMOD integration is published on GitHub — fork it, extend it, or ship it as-is.

The Toolkit at a Glance

Tool	Target	Stage	Best For
FMOD Studio Plugin	Engine-agnostic	Design-time	Audio engineers previewing ODIN streams inside FMOD Studio
FMOD Adapter Plugin (Unreal)	Unreal	Runtime	Teams that want a drop-in plugin with Blueprint support
FMOD Integration Guide (Unreal)	Unreal	Runtime	Teams that want full source control over the DSP path
FMOD Integration Guide (Unity)	Unity	Runtime	Unity teams that use FMOD as their audio solution

1. FMOD Studio Plugin (New)

The newest addition to our toolkit, the ODIN FMOD Studio Plugin is a DSP-based plugin that connects FMOD Studio directly to ODIN rooms.

Why this matters for audio engineers: until now, the only way to hear what voice chat sounds like through your project’s FMOD mix was to run the game. With the Studio Plugin, you can join a live ODIN room from inside FMOD Studio, route peer audio through your event’s signal chain, and apply the same DSP, mixing, and spatialization you would for any other sound source.

How it works:

Drop the ODIN Playback Plugin into an FMOD event’s signal chain.
Enable Persistent on the event.
In the Deck, enter your Access Key, Room Id, and an optional User Id.
Hit Connect, then Play — remote peers are mixed live into the event output.

Cross-platform testing: pair it with the 4Players Web App to join the same room from a browser and validate your mix against real input, without needing a build.

Studio-only by design. This plugin is intended for design-time work. Do not ship it in console, mobile, or web runtime builds — keep Studio-only event variants so your runtime banks don’t depend on the Studio DSP. For runtime, use the engine-specific integrations below.

2. FMOD Adapter Plugin (Unreal)

The FMOD Adapter Plugin for Unreal is the fastest path to voice chat in an Unreal project that already uses FMOD. Under the hood it uses the same DSP Plugin and Programmer Sound techniques covered in the integration guide below — packaged as a ready-to-use plugin so your team doesn’t have to build them from scratch.

The plugin ships two key parts:

UOdinFmodAdapterComponent — a drop-in replacement for the default UOdinSynthComponent. It routes peer audio from ODIN Voice through FMOD instead of built-in audio engine.
UFmodOdinSubsystem — starts ODIN with FMOD’s configured sample rate automatically.

For audio engineers: the FMOD Event is defined in FMOD Studio with any effects, sends, and 3D attenuation your project needs. The Unreal side just plays it. Your audio team owns the sonic behavior of voice chat the same way they own everything else in the mix.

For developers: drop the component on a Player Character, call Play Odin Voice from your OnMediaAdded event handler, and you’re done. No custom DSP code to maintain.

This is the recommended path for most Unreal teams.

3. FMOD Integration Guide (Unreal)

If you need full control over the DSP path — custom mixing logic, per-peer channel groups, specialized spatialization — the FMOD Integration Guide for Unreal walks through building a UOdinFmodAdapter from scratch using the same two techniques the Adapter Plugin is built on:

DSP Plugin (recommended): writes ODIN audio directly to the master channel group via a custom DSP. Low latency, full control over the signal flow.
Programmer Sound (alternative): uses FMOD’s Programmer Sound API. Easier to wire up, but adds roughly 500ms of latency — generally not acceptable for live voice.

The accompanying sample project is a working reference implementation, including the UOdinFmodAdapter source, a Pan DSP for spatialization, and attenuation parameters exposed to Blueprints.

Reach for this option when the Adapter Plugin’s behavior doesn’t match your needs and you’d rather fork the implementation than work around it.

4. FMOD Integration Guide (Unity)

The FMOD Integration Guide for Unity shows how to wire ODIN into a Unity project that uses FMOD — whether alongside Unity’s built-in audio or as the sole audio engine.

The centerpiece is FMODMicrophoneReader, a drop-in replacement for ODIN’s default MicrophoneReader:

Captures microphone audio through FMOD’s recordStart API in PCMFLOAT format.
Reads the recording buffer continuously and pushes the data to the ODIN servers.
Handles sample rate and channel count matching between FMOD’s recording device and ODIN’s media streams.

Paired with FMODPlaybackComponent for output, this gives Unity teams a complete capture-and-playback path through FMOD.

Heads up: the Unity playback path is based on FMOD Programmer Sounds and adds roughly 500ms of latency. If lower latency is critical, the FMOD Studio Plugin above is a great place to prototype your mix while we expand the runtime options.

Which One Should You Use?

A quick decision tree:

Audio engineer prototyping the mix? → FMOD Studio Plugin.
Unreal team shipping production voice chat? → FMOD Adapter Plugin (Unreal).
Unreal team that needs custom DSP behavior? → FMOD Integration Guide (Unreal), forked from the sample project.
Unity team using FMOD for audio? → FMOD Integration Guide (Unity).

These are not mutually exclusive. Your audio team can iterate inside the Studio Plugin while your engineers integrate the runtime plugin in parallel — both connect to the same ODIN rooms with the same access key, so the mix your audio engineer signs off on in FMOD Studio is the mix that ships.

Getting Started

FMOD Studio Plugin → docs.4players.io/voice/fmod/fmod-studio-plugin
FMOD Adapter Plugin (Unreal) → docs.4players.io/voice/unreal/guides/odin-fmod-adapter-unreal
FMOD Integration Guide (Unreal) → docs.4players.io/voice/unreal/guides/odin-fmod-unreal
FMOD Integration Guide (Unity) → docs.4players.io/voice/unity/guides/odin-fmod

Using another audio engine or sound tool?

Checkout our Wwise integration guide and Wwise adapter plugin for using ODIN with Wwise in Unreal or our atmoky guide with sample project for using ODIN with atmoky trueSpatial in Unity.

These docs should give you a hint to integrate ODIN into any other audio engine or 3rd party sound tool. Feel free to ask us about special development support for your custom integration!

Questions, feedback, or feature requests? Join us on Discord — we’d love to hear how you’re integrating voice into your project.

A Perfect Match: ODIN Fleet Meets Your Matchmaking System

Fri, 06 Mar 2026 00:00:00 +0000

Modern multiplayer backends are modular. You might already use Amazon’s GameLift Servers FlexMatch, or build your matchmaking on Heroic Labs’ Nakama Server.

Instead of replacing these systems, ODIN Fleet integrates with them.

This article explains:

What becomes possible when you combine ODIN Fleet with external matchmaking systems
How the architecture works on a high level
Where to find full step-by-step implementation guides

What’s Possible

Modern multiplayer architectures don’t need to bundle everything into one provider.

With ODIN Fleet, you can separate two core responsibilities:

🧠 Matchmaking system → decides who plays together
🖥 ODIN Fleet → runs the dedicated game servers

This separation gives you flexibility without sacrificing scalability.

Why This Matters for Decision Makers and Developers

Infrastructure independence
Use AWS matchmaking features or Nakama logic — without being locked into their compute layer.

Clear cost control
Matchmaking and server infrastructure scale differently. Separating them gives better transparency and optimization potential.

Long-term flexibility
You can evolve or replace your matchmaking system without redesigning your server deployment model.

Clean architecture
Matchmaking stays in your backend.
Game servers run independently on ODIN Fleet.

Works with your stack
Already using:

Amazon GameLift Anywhere
Amazon GameLift FlexMatch
Nakama

You don’t need to rewrite anything — you simply connect ODIN Fleet as the compute layer.

The Core Idea

Across all setups:

Matchmaking remains intelligent and provider-specific
ODIN Fleet provides scalable, global compute
Systems communicate through clearly defined interfaces
Players connect directly to ODIN-hosted servers

This results in a modern multiplayer backend that is:

Composable. Replaceable. Scalable.

How It Works Technically

Let’s look at the structure without diving too deep.

1️⃣ ODIN Fleet as the Compute Layer

ODIN Fleet runs your dedicated game server as a Docker container.

Each server:

Exposes a public game port
Can receive environment variables
Can update metadata (e.g., idle/occupied)
Can integrate SDKs like GameLift

ODIN Fleet does not do matchmaking.
It runs your game reliably and globally.

2️⃣ External Matchmaking Layer

Depending on your setup:

With GameLift Anywhere (+ FlexMatch)

FlexMatch handles via agents. ODIN provides.

Your game server includes the GameLift Server SDK
A GameLift Agent runs inside the game server’s docker container
AWS handles matchmaking and session placement
ODIN provides the actual compute resources to run your game server
Dynamic scaling based on real-time player counts to save costs

With Nakama

Nakama matches via modules.
ODIN runs.

Nakama implements matchmaking logic
A FleetManager module connects Nakama to ODIN Fleet
Nakama lists available servers
Game servers update their state via metadata

3️⃣ State Synchronization

All integrations rely on simple state communication:

Server becomes available → marked as idle
Match starts → marked as occupied
Match ends → marked as idle
Scale up or down on demand

This keeps orchestration deterministic and transparent.

Full Implementation Guides

If you want to go deeper, we provide complete technical guides:

🔹 GameLift FlexMatch (builds on Anywhere) + ODIN Fleet

Step-by-step setup including:

Unreal Server SDK integration
GameLift Agent in Docker
Backend example
Rule sets & Placement queues
SNS notifications
Client integration
Autoscaling

👉 https://docs.4players.io/fleet/guides/gamelift-flexmatch/

GitHub repository: https://github.com/4Players/OdinFleet_GameLift_Unreal (Game Server) https://github.com/4Players/Odin_GameLift_GameBackendService (Agent & Autoscaling)

🔹 Nakama Fleet Manager

Includes:

Go-based FleetManager module
ODIN Fleet API integration
Metadata-based orchestration
Example implementation

👉 https://docs.4players.io/fleet/guides/nakama-fleetmanager/

GitHub repository: https://github.com/4Players/odin-nakama-fleet-manager

🔹 Other Matchmaking System?

No worries - let’s talk!

👉 https://odin.4players.io/company/contact_us/

Ready to Build?

Explore the full documentation:

👉 https://docs.4players.io/fleet/

Or talk to us about your backend architecture:

👉 https://odin.4players.io/company/contact_us/

Let’s build scalable multiplayer systems —
with flexible matchmaking and independent infrastructure.

Introducing ODIN Voice 2.0

Fri, 17 Oct 2025 00:00:00 +0000

We’re pleased to introduce ODIN Voice 2.0 - a major update to our core SDK that simplifies integration, improves flexibility and provides a cleaner foundation for building multiplayer voice experiences. This release refines the way you work with channels and positional audio, updates the SDK core API and lays the groundwork for more advanced routing and spatial setups - all while staying true to ODIN’s minimal, low-overhead design.

ODIN Voice Core SDK on GitHub

Shaped by Developer Feedback

When we launched ODIN, the goal was to make high-quality, low-latency voice chat straightforward to integrate into multiplayer games and applications. Over time, as developers built more complex systems - from proximity chat to dynamic team routing - we noticed recurring patterns and workarounds. Many of you were combining multiple rooms or implementing your own filtering layers just to achieve richer spatial behavior or more granular control.

With version 2.0, we wanted to address these use cases directly. Instead of adding more surface area or more abstractions, we focused on simplifying the underlying model while making it more powerful. The result is a leaner core SDK that still does the heavy lifting, but gives developers more direct control over routing, proximity and audio behavior.

Evolving Positional Audio and Routing

Previous versions of ODIN already offered a solid foundation for proximity chat and positional audio, enabling developers to build convincing spatial voice experiences out of the box. But as projects grew more ambitious, we saw opportunities to make this system even more flexible and easier to scale. ODIN Voice 2.0 builds on that foundation with a new channel mask–based architecture that simplifies routing and unlocks more advanced spatial setups without adding complexity.

Each room now supports up to 64 independent audio channels, represented by a 64-bit mask. Clients can transmit on multiple channels simultaneously, with each channel carrying its own 3D position and scaling. On the receiving end, peers can adjust their masks to decide exactly which peers and channels they want to hear. By clearing or setting individual bits, you can switch between global, team or proximity modes without spinning up multiple rooms or adding custom filtering layers.

This new model makes it easy to combine localized spatial audio, team communication and broadcast voice within a single room. It’s a more scalable, cleaner approach that adapts well to large multiplayer environments, cooperative gameplay, social spaces and any scenario where audio context matters.

Cleaning Up the Edges

Alongside the new routing model, the SDK’s API has been streamlined to make integration more intuitive. Connection pooling is now handled internally - voice rooms automatically share underlying connections, removing the need for manual pool management. Signaling has moved to plain JSON, replacing the previous MessagePack RPC format, which makes it easier to debug and integrate ODIN with different languages, engines and frameworks. Audio encoders and decoders now play a central role in media handling and authentication supports both raw JWTs and JSON-based configuration, giving you more flexibility in how you structure tokens and initial state.

Use Cases and Integration Scenarios

These improvements make it easier to build sophisticated communication systems without extra infrastructure. Competitive games can define separate team, squad and broadcast channels with server-enforced routing. All open world or social experiences can rely on positional audio to scale naturally as player counts increase. Simulation and training environments can define structured radio networks using the same primitives. Because channel masks and positions can be updated at runtime, developers can script complex routing behavior without touching the underlying transport layer.

A Note of Thanks

This release was guided by feedback from developers, studios and early adopters who built real projects with ODIN. Your experiences with proximity chat, routing and spatial voice at scale played an important role in refining the SDK’s direction. We always appreciate your input and support and we’re super excited to see what you’ll create with these new capabilities.

Looking Ahead

2.0 is a foundational update. By simplifying the core and expanding routing capabilities, we’ve set the stage for new features, deeper integrations and more ambitious use cases. As the SDK evolves, we’ll continue refining it with a focus on real-world development needs and long-term stability.

We’re excited to see how developers will use these new tools to push the boundaries of in-game communication. Whether it’s large-scale multiplayer worlds, tightly coordinated competitive play or immersive social spaces, ODIN is built to give you the control and performance you need to make voice a seamless part of your experience.

We’re just getting started.

ODIN Voice Core SDK on GitHub

How to deploy your Unreal Engine game server to ODIN Fleet

Fri, 15 Aug 2025 00:00:00 +0000

Is your multiplayer game project ready to start into the next phase, and now you need to host a couple of game server instances or more, but you do not want to get caught up in infrastructure problems or intransparent pricing policies with high operating costs after going into production phase?

In our new guide , we will show you how to set up and build your Unreal Engine game server, upload it to a Docker Image Registry and configure it to deploy to our server hosting platform ODIN Fleet, a comprehensive platform that combines cutting-edge voice communication with reliable and scalable server hosting solutions.

Checkout Our Guide

Easy & step by step

No knowledge about server administration or how to operate servers is necessary. Here is what we cover in our guide:

Building a Dedicated Server Distributable

Building the Unreal Engine from Source
Switch Unreal Engine version to Source-Built
Configuring the Project for Dedicated Server Builds
For Windows: Installing the Linux Cross-Compile Chain
(Cross-)Compile the Dedicated Server for Linux

Creating a Docker Image

Install Docker Desktop
For Windows: Enable WSL (Windows Subsystem for Linux) or Hyper-V
Create a Dockerfile
Build the Docker Image
Test Locally (Optional)
Push to a Container Registry

Deploy a Server with your Game

Create a Fleet Project on Odin
Reference your Container Registry
Create an Image Reference
Create a Server Config
Server Deployment

Connecting to your Server

Testing with Command Line Options
Creating an HTTP Request in Unreal
Connect to a Server via Blueprint

Need a Shortcut?

Checkout how we deploy our Unreal Tech Demo for ODIN Voice to our own service and run a dedicated game server on ODIN Fleet: ODIN Fleet Online Subsystem

Not using Unreal Engine?

The parts in the guide related to ODIN Fleet and its web app dashboard are pretty much the same, e.g. for a Unity game server. If you need help setting up the game server with your engine or networking framework, please contact us to see how ODIN can support your game development journey.

You can also visit our Discord community server and talk to other developers already using ODIN.

What is ODIN Fleet?

ODIN Fleet is at the heart of our B2B offering. We view it as a partner designed to make the whole process of deploying and managing game servers on a global scale much easier. So, whatever you’re doing - whether you’re setting up stateful servers for those really immersive, world-building titles or you’re handling stateless deployments for match-based games - ODIN Fleet has got you covered, thanks to decades of hosting experience through our B2C service 4Netplayers.

Empowering the Next Generation of Game Experiences

ODIN is an exciting step forward in the way game servers and communications are managed. Hey, we totally get it: your backend needs to scale globally, and you need to do it in a way that’s transparent and cost-effective . Well, let us help you!

Paired with the state-of-the-art ODIN Voice Chat SDK, this means your players can enjoy lag-free, real-time interactions that bring every match, mission, or multiplayer session to life.

We provide all the infrastructure, reliability, and support you need to focus on creative innovation rather than technical constraints. You’re either a seasoned game developer or you’re just starting out? Either way, it’s time to let your game’s potential speak for itself and we’ll be there to manage the rest!

Discover more about our services, join our growing community, or schedule a consultation to see how ODIN can support your game development journey.

Ready to explore more? Dive into our detailed developer documentation or check out our use cases

ODIN Voice from UE4.26 up to UE5.6

Wed, 23 Jul 2025 00:00:00 +0000

Continuous development

Over the past several versions, the ODIN Voice Chat SDK has seen a wave of improvements focused on performance, flexibility, and deeper Unreal Engine integration. From enhanced audio quality and loopback support to robust device handling and expanded compatibility with UE 5.5, each update has refined the developer and end-user experience. Whether you’re building immersive in-game communication or a scalable voice solution for simulations or virtual worlds, these updates bring increased control, reliability, and quality to your audio pipeline. Let’s walk through what’s new and why it matters.

Unreal Engine 5.6 and ODIN Voice v1.11.2

We improved performance by pushing audio data now in a separate audio push thread. After updating the Unreal plugin to use the latest native Odin version, we also refactored internal subsystems and increased stability when using APMs (Audio Processing Modules) for reported edge cases. Also, several bug fixes were incorporated for situations with multiple audio captures, activating the pause function or using Apple’s AirPods on Mac platform.

Many developers might be interested to know that we are now officially supporting Unreal Engine 5.6. You can download our latest version v1.11.2 of the ODIN Voice Unreal plugin from fab or from GitHub .

What is ODIN !?

For more details on ODIN and how it powers real-time, low-latency voice communication across platforms, visit the official ODIN Voice Chat product page . There you’ll find in-depth documentation, platform integration guides, and everything you need to get started — whether you’re working in Unreal, Unity, web, or native environments. Dive in and discover how ODIN can bring crystal-clear, scalable voice to your project.

Overview of the last major version changes

Versions 1.10.0 to 1.10.2

… focused on improved audio stream handling, cleaner device management, and general stability updates. The gain control system was simplified, and internal components were refined for better performance and compatibility.

Versions 1.9.0 to 1.9.3

… introduced enhanced audio device control, new loopback playback capabilities, and better runtime configurability. Stability and safety were improved with stricter thread management, while new interface support and settings exposed more control to developers.

Versions 1.8.3 to 1.8.15

… focused on audio quality improvements, expanded Unreal Engine support, and greater flexibility in audio input. Stability was enhanced across platforms, with better error handling, improved echo cancellation, and new utility features. Device management and async behavior were also made more robust.

Complete changes in detail going back till v1.8.4

v1.11.2 Latest

Fixes

Fixed an issue with capturing Audio from Air Pods on Mac

v1.11.1

Fixes

Fixed an issue when using multiple UAudioCapture objects at the same time
Corrected SetIsPaused logic in Audio Capture

v1.11.0

Changes / Improvements

Pushing audio data is now performed in a seperate audio push thread
Renamed internally used subsystems to better reflect functionality
Improved submixer shutdown for echo cancellation. This should handle rare crashes during development.
Updated Odin Native version

v1.10.2

Changes

Fixed issue with Unreal Audio Capture Implementation not returning Device Ids on some Devices and UE4.X, aborting automatic device selection
It is now possible to connect multiple Odin Synth Components to the same Playback Media Stream, without resulting in undersampling
Improved Submix Listener cleanup
Changed log verbosity where needed

v1.10.0

Changes

Gain Controller is now controlled using an enum. Can now choose between “None”, “V1” and “V2”.
Removed Pre Amplifier APM Setting
Updated native Odin binaries
Updated pointer references in SynthComponent
Updated cleanup procedure in OdinRoom

v1.9.3

Changes

Can now set the Token Life Time when generating room tokens
Updated comments of apm config structure
Exposed current selected device and default device info in OdinAudioCapture
Exposed StartCapturing success result to Blueprints in OdinAudioCapture
Fixed issue with platform definitions in v1.9.2

v1.9.1

Added

Added new Odin Audio Generator Loopback Component, which allows loopback of generated audio, such as voice capture, in the game.
Can now switch to the System’s Default Capture Device by calling ChangeToDefaultCaptureDevice on the OdinAudioCapture object.
Added possibility to change Global Min Pitch and Global Max Pitch values for the Loopback playback to resample mismatch between capture and playback correctly. Use the config file in Odin/Config/Odin.ini to change the values.

Improvements

Capture Device Disconnect Recognition will now also notice if the format of a capture device has been changed and automatically reconnect

v1.9.0

Added

Added IOdinAudioControl and implemented Interface in OdinAudioCapture and OdinCaptureMedia. The interface defines the Get/SetIsMuted and Get/SetVolumeMultiplier functions for both classes. Interface is also used in the PixelStreamingGenerator implementation.

Changes / Improvements

Deprecated Async GetCaptureDevices and ChangeCaptureDevice functions due to non-thread-safe code in the Unreal Audio Capture implementation
Added checks to ensure non-thread-safe functions can only be called on Game Thread
Deprecated Get/SetIsPaused functions of OdinAudioCapture

1.8.15

Changes

Updated Odin initialization settings to use 48khz stereo instead of 48khz mono. This should solve issues with sound quality on some devices.
Audio Capture Mono Mixing is now disabled by default

1.8.14

Added

Now compatible with UE 5.5

Changed

Improved error handling in OnGenerateAudio
Fixed issue with compilation on Mac for Unreal Versions 5.1 and below

1.8.13

Added

Odin Audio Capture: Can now deactivate automatic device disconnect recognition (i.e. to recognize when a player removes a USB microphone). Could be relevant on mac, as moving an application window on Mac can lead to very high frame time spikes, making a false positive more likely
Odin Synth Component: Added logging to the GenerateAudio code, if odin_audio_read_data doesn’t work. Requires Log Verbosity Level “Verbose”

Changes

Will now use default Odin initialization, making initialization independent of whether Unreal Audio Engine is enabled or not

Fixes

Odin Audio Capture: increased time before a device disconnect will be recognized, this will help avoiding false positives.
Odin Capture Media: Fixed an issue where the media was not correctly reset, if the channel count changed. Also avoids calling the reset stream function multiple times when detecting a situation where we have to reset

1.8.12

Improvements / Bugfixes

Updated Destroy Room Handle logic to avoid logging errors when provided with invalid Room Handles. This will also remove Error Logs during the Packaging Process.
Echo Cancellation will now use the correct Audio Device for Submix Listening. This will fix an issue with Echo Cancellation not being active after changing APM Settings or in certain scenarios after loading a new level.
Generally improved error handling and error logging throughout the plugin

Changes

Can now use UAudioGenerator parent class for generating audio, instead of having to use UAudioCapture. This allows developers more flexibility to i.e. use soundfiles as input to an Odin audio capture stream
Can now enable or disable mixing multiple channels into one mono channel on UOdinCaptureMedias before sending audio data to Odin.
Echo Cancellation: APM Stream Delay is now initialized to 200ms when no custom value was set
Added missing documentation to public api

1.8.11

Fixed

Fixed issue occurring during User Data decoding in UE4.27

Added

Added convenience function to access Playback Media stream generating data on an Odin Synth Component

1.8.10

Improvements / Bugfixes

Improved Error Handling
Improved Error Logs and Feedback
Add Media is now performed on background thread
Fixed String Casting and conversion

1.8.9

Improvements / Bugfixes

Updated Odin Synth Component to restart automatically after a Seamless Server Travel
Fixed and improved error reporting of the Remove Media from Room Async function

1.8.8

Improvements / Bugfixes

Now allows disconnecting events to be fired, when manually calling destroy local room handle
OdinRoom now recognizes reconnects after loosing connection temporarily and automatically sets up Capture Stream again.
Fixed broken blueprint nodes issue, due to late loading of the plugin

New Features

Added newer Room State Changed Event to also broadcast reason for disconnect. Old Event is marked as deprecated.
Added IsConnected Function to Odin Room object

1.8.7

New Features

Added support for Unreal Engine 5.4 releases

Bugfixes / Improvements

Changed access to UOdinRoom references to avoid potential crashes with async event handling

1.8.6

Bugfixes / Improvements

Added world validity checks for async events synchronizing to game

v1.8.5

General

Core SDK has been updated to version 1.6.5 (details)

Bugfixes / Improvements

Fixed build issues on iOS with Unreal Engine 5.3

1.8.4

Bugfixes / Improvements

Fixed an issue where echo cancellation did not work on iOS and Android

FMOD and ODIN: using voice chat in a state-of-the-art audio engine

Tue, 01 Jul 2025 00:00:00 +0000

FMOD and ODIN Voice

Are you using Unreal or Unity with a state-of-the-art audio engine like FMOD and wondering if it works together with our proximity voice chat ODIN? Yes, it does! We offer a helper plugin and extensive guides to set everything up for using our voice chat together with FMOD - even letting you stay independent of the built-in audio engine from Unreal or Unity. Using the DSP plugin approach you can benefit from low latency and extended mixing flexibility. This way you can take advantage of the high quality built-in features from FMOD and apply them to your voice chat signal, e.g. spatial audio, sound occlusion or environmental effects.

Read our Unreal Guide and the optional Unreal Adapter Plugin or our Unity Guide :

FMOD Unreal Guide

FMOD Unity Guide

Check out our Unreal Sample Project or the Unity Sample Project :

FMOD Unreal Sample Project

FMOD Unity Sample Project

What is ODIN Voice?

If you are new to ODIN, read all about our flexible and dev-friendly voice chat solution here: https://odin.4players.io/voice-chat/

If you want to know how to integrate ODIN Voice into your project, read this »Unreal Starter Guide « or watch our »Unreal Video Tutorial Series « or this »Unity Starter Guide « or watch our »Unity Video Tutorial Series «

Using Wwise? We got you covered with this »Guide for Wwise «

Do you need help with another sound plugin or did you already find a solution to make it work with Odin? Please tell us on Discord !

Discord Community

The Engine Behind the Action: What is ODIN Fleet?

Fri, 06 Jun 2025 00:00:00 +0000

Here at 4Players, we think that game development should be all about creativity and building amazing gaming experiences, not about getting caught up in infrastructure problems. That’s why we built ODIN, a comprehensive platform that combines cutting-edge voice communication with reliable and scalable server hosting solutions.

A Platform Designed by Developers, for Developers

Key Benefits at a Glance

No More Dev-Ops Worries: ODIN Fleet takes care of the heavy lifting. With a focus on service and an easy-to-use dashboard, you can leave the day-to-day server management to us and get on with what matters most: your game.
Rapid Scaling: Need to change your server capacity at short notice? You can easily scale up or down using our API integrations or manual intervention, making sure your game stays responsive during busy times without costing you more than you need to.
Global Reach & Transparent Pricing: ODIN Fleet has a global network of data centres, so you can deploy your servers wherever your players are. And our pricing model is straightforward: no extra fees for IPs, traffic, or storage. This way, you can keep a tight control on costs while making sure you’re always performing at your best.
Streamlined Integration: Whether you provide your custom server binaries or use our Docker-based workflows, ODIN Fleet makes integration a breeze. We’ve got you covered, from setting things up to fully automated CI/CD pipelines. Our process is designed to be efficient and reliable.

How ODIN Fleet Works: From Concept to Launch

The beauty of ODIN Fleet lies in its simplicity and flexibility:

Understanding Your Needs: We’ll start by having a chat to find out what your project needs and what your performance targets are. This makes sure that the final setup matches your game’s architectural needs perfectly.
Bringing Your Binaries & Configurations: No matter if you’re using your own binary or the images we provide, ODIN Fleet works perfectly with your development environment. Our team is here to help you with everything from setting up Steamworks integration to creating Dockerfiles.
Comprehensive Setup and Deployment: Once you’ve got your configurations sorted, the platform does the rest - like setting up servers all over the world, installing cost control tools, managing storage, and providing logs and stats as they happen.
Empowerment Through Control: At the end of the day, you decide how involved you want to be. You’ll have full control with our transparent dashboard, or we can take care of everything with a service contract that keeps your operations running smoothly when you need it most.

This end-to-end approach makes server management a lot less complicated, giving you more time and resources to focus on your creative vision.

We know how important it is for developers to be able to create experiences that are as interconnected as they are innovative. That’s why ODIN Fleet works seamlessly with our ODIN Voice Chat SDK, delivering high-qualityvoice communication to your project.

Empowering the Next Generation of Game Experiences

Paired with the state-of-the-art ODIN Voice Chat SDK, this means your players can enjoy lag-free, real-time interactions that bring every match, mission, or multiplayer session to life.

Discover more about our services, join our growing community, or schedule a consultation to see how ODIN can support your game development journey.

Ready to explore more? Dive into our detailed developer documentation or check out our use cases

What’s Next for ODIN Voice

Fri, 16 May 2025 00:00:00 +0000

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.

ODIN Voice Core SDK on GitHub

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!

atmoky trueSpatial and ODIN: voice chat with superb spatial audio in your Unity game

Thu, 15 May 2025 00:00:00 +0000

atmoky trueSpatial and ODIN Voice

Are you using ODIN with Unity and wondering if you can improve the proximity voice chat? Yes, you can! There just some small additional steps to take, but they are worth it. Take advantage of the high quality true spatial audio features from the atmoky trueSpatial plugin and apply them to your voice audio. In this special tech demo, we teamed up with the spatial audio experts at atmoky to integrate their trueSpatial engine, enhancing our voice chat with advanced spatial audio rendering for a deeply immersive experience that strengthens the sense of presence.

Read our guide and check our modified Unity tech demo :

atmoky Guide

Tech Demo

If you are new to ODIN, read this »Starter Guide « or watch our »Video Tutorial Series «

Using Unreal? We will release a guide for that soon. Stay tuned!

Do you need help with another sound plugin or did you already find a solution to make it work with Odin? Please tell us on Discord !

Discord Community

Why In-Game Voice Chat Matters: Lessons from Nintendo Switch 2

Thu, 01 May 2025 00:00:00 +0000

Nintendo’s unveiling of the Switch 2 highlights a significant shift in gaming: the prioritization of universal in-game communication. With the introduction of the C-Button, players can access features like voice chat, screensharing, and even video chatting - whether they’re playing the same game or entirely different ones. By embedding these tools directly into the system, Nintendo moves away from the usual dependency on external apps like Discord, opting for integration that spans across all gaming titles available on the system.

This isn’t just about convenience; it underscores a growing demand for social interaction in games. For developers, the question isn’t whether in-game voice chat matters, it’s how to make it meaningful and easy to use for their audiences.

GameChat: Redefining Connection in Gameplay

GameChat, accessible via the C-Button, offers players various ways to stay connected during gaming sessions:

Voice Chat Without Restrictions: Built into the console, GameChat allows players to communicate naturally without needing extra devices or third-party platforms.
Screensharing for Collaborative Play: Whether troubleshooting puzzles or strategizing victories, sharing gameplay in real time fosters collaboration.
Video Chat Integration: Through an optional USB-C camera, players can video chat while gaming, blending interaction and immersion into a single experience.

Unlike traditional voice solutions tied to specific games, GameChat expands beyond those boundaries, letting users communicate regardless of what they’re playing.

Why Developers Should Prioritize In-Game Communication

The Switch 2’s focus on universal voice tools reflects an undeniable trend: players crave deeper social connectivity within their gaming experiences. Developers should consider the following impacts when evaluating voice chat integration:

Building Stronger Communities: Voice chat encourages real-time collaboration, strengthening player bonds and fostering inclusive communities.
Enhancing Gameplay Dynamics: Integrated communication, such as screensharing and strategy-focused chats, boosts the sense of teamwork in multiplayer environments.
Meeting Player Expectations: As systems like GameChat set new standards, games and gaming systems lacking communication tools may feel outdated and disconnected.

For developers, adding voice chat tools isn’t merely about staying relevant, it’s about cultivating spaces where players connect emotionally and socially through their games.

The Impact of Shared Experiences

Nintendo’s GameChat can be viewed as an acknowledgment of the central role that shared experiences play in gaming. Real-time voice and video features allow players to turn solitary activities into collaborative adventures, whether it’s coordinating strategies or simply chatting casually. This functionality serves as a reminder that gaming isn’t inherently isolating—it thrives on interaction and shared joy.

At its core, in-game communication transcends gameplay; it becomes the fabric of lasting memories and stronger player relationships.

Conclusion

Nintendo’s approach with the Switch 2 highlights the power of built-in voice tools in shaping modern gaming experiences. However, developers have the flexibility to decide how they want to incorporate voice and social systems into their own titles. Whether through universal solutions or tailored add-ins, communication features have the potential to elevate gameplay, foster community, and deepen the connection between players.

For developers looking to quickly integrate a comparable system into their own platforms or games, 4Players’ ODIN infrastructure provides all the necessary tools to make this a seamless reality. The ODIN Voice Chat SDK enables seamless integration of high-quality voice communication into games, while the ODIN Fleet platform provides robust and scalable server hosting to ensure smooth, lag-free experiences for players. Together, these tools equip developers with the resources to create exceptional social gaming systems to keep players engaged.

Developers face a vital choice: adapt to the shift toward interactive social systems or risk being left behind in an increasingly connected gaming landscape. The possibilities for meaningful integration are endless, but the message is clear: voice chat isn’t just a feature anymore. It’s the foundation of the future of gaming.

ODIN Voice Chat now on Fab, Epic’s New Unified Content Marketplace

Wed, 30 Oct 2024 00:00:00 +0000

ODIN Voice Chat is now available on Fab , former Unreal Engine Marketplace. Head over to download and install the SDK for free on Epic’s New Unified Content Marketplace.

You can download , install and use the SDK for free for up to 25 concurrent users by either generating a free access key in our developer documentation or directly in the Unreal Editor using a simple blueprint.

Using the plugin

We have created a guide to get your started quickly.

We also have an extensive Blueprint Reference Documentation that describes every node that ODIN offers in great detail.

What’s next?

We will prepare our Unreal Tech Demo and also SDKs for other engines on Fab, now that Epic made this possible. Stay tuned!

We can’t wait to see what you are developing with ODIN on the amazing Unreal Engine.

Please contact sales if you need additional information on pricing and get in touch with our Customer Success Team if you want to be part of our “Showcase”.

Get ODIN on Fab

ODIN Voice Chat is back in Unity Asset Store

Thu, 24 Oct 2024 00:00:00 +0000

Now in Unity Asset Store!

ODIN Voice is now available again in the Unity Asset Store . Head over to download and install the SDK for free!

You can download , install and use the SDK for free for up to 25 peak concurrent users by either generating a free access key in our developer documentation or directly in the Unity Editor using the Odin Manager Prefab.

4Players becomes partner of Unity

We thank Unity for the frictionless and thorough verification process to make ODIN Voice Chat a Verified Solution, meaning it meets Unity’s highest quality and compatibility standards. They were very responsive and did an amazing job getting our Odin Plugin reviewed for public release in the Unity Asset Store.

More to come

Our Unity Tech Demo has been further developed and will also be released on the Unity Asset Store soon. In addition, we are working on the new version 2.0 of our plugin with many improvements and webGL support, among other things.

We can’t wait to see what you are developing with ODIN on the amazing Unity Engine.

Please contact sales if you need additional information on pricing and get in touch with our Customer Success Team if you want to be part of our “Showcase”.

Get ODIN from Unity Asset Store

ODIN brings support for Unreal Engine 5.4

Mon, 06 May 2024 00:00:00 +0000

We are thrilled to announce the release of the latest update for our ODIN Software Development Kit (SDK), now fully supporting Unreal Engine 5.4. This update brings a series of enhancements and fixes that solidify ODIN’s position as a leading voice communication solution for game developers and digital creators. Here’s everything you need to know about the ODIN SDK v1.8.7 update:

What’s New in v1.8.7?

Core SDK Upgrade: The heart of ODIN, the Core SDK, has been upgraded to version 1.6.5. For a detailed view of the enhancements and new capabilities, check out the release notes on our GitHub page .
iOS Build Fixes: We’ve addressed and fixed build issues that previously affected iOS, enhancing stability and compatibility across all supported Apple devices.
Enhanced Asynchronous Event Handling: The update introduces world validity checks for asynchronous events to ensure smooth synchronization with the game environment, minimizing disruptions during gameplay.
Improved Safety with UOdinRoom References: Changes have been made to how UOdinRoom references are accessed, which now prevents potential crashes related to asynchronous event handling—boosting the overall robustness of the SDK.
Support for Unreal Engine 5.4: Last but not least, we’ve added support for the latest Unreal Engine 5.4 releases, allowing developers to integrate ODIN’s cutting-edge voice communication technology with the newest features from one of the most powerful game engines available today.

Why Update? Updating to ODIN SDK v1.8.7 ensures that developers can take full advantage of the latest improvements in voice communication technology. Whether you’re developing an interactive game, a VR experience, or an educational tool, this update is designed to enhance your application’s performance and stability.

Stay ahead of the curve by integrating the latest version of ODIN SDK into your applications and deliver exceptional audio experiences to your users. Download the updated SDK today and start making the most out of Unreal Engine 5.4!

Download ODIN SDK v1.8.7 Download the latest version of ODIN SDK v1.8.7 from our GitHub repository or directly from the Unreal Engine Marketplace. For more information on the ODIN SDK and its features, visit our official website .

Go to Unreal Marketplace

Revolutionizing gaming Communication: ODIN by 4Players supports Gray Zone Warfare with next-gen Voice Chat

Mon, 29 Apr 2024 00:00:00 +0000

Hamburg, 29. April 2024 - The globally operating software company 4Players GmbH announces its partnership with MADFINGER Games, the developer behind the highly anticipated tactical first-person shooter Gray Zone Warfare. The collaboration aims to level up in-game communication by integrating 4Players’ next generation Voice Chat SDK, ODIN, into MADFINGER Games’ upcoming title.

MADFINGER Games’ goal is to create a complex and realistic gaming experience that allows players to embark on an adventure alone or in a team. To ensure excellent communication during tactical approaches, ODIN was the best choice for MADFINGER Games’ Technical Director Johanny Clerc-Renaud:

“Selecting ODIN as the voice chat in our upcoming title, Gray Zone Warfare, was a pivotal decision driven by both technical and business considerations. Technically, ODIN ticks a lot of our criteria with its support for spatial audio, a ready-to-deploy Unreal Engine 5 plugin and the ability to meet any player load thanks to their cloud hosting. From a business perspective, the agility and openness of partnering with a company like 4Players meant we could work hand-in-hand to tailor the solution to our specific needs. This includes a seamless integration with Wwise, allowing us to modulate voice data for a more immersive and engaging player experience. Together, these factors made ODIN the undeniable choice for Gray Zone Warfare, enabling us to make our game even more memorable.”

By natively integrating ODIN Voice Chat into Unreal Engine 5 , MADFINGER Games’ developers could focus on creating ultra-realistic game content instead of managing complex data sets. By leveraging ODIN’s scalable cloud hosting, MADFINGER Games can also ensure seamless service delivery to players worldwide, improving accessibility and the gaming experience.

With features such as real-time 3D spatial audio – including audio occlusion and ambient effects – for the global voice chat as well as full-volume radio communication, ODIN sets a new standard for multiplayer engagement and promotes immersive and crystal-clear interactions between players. This level of immersive communication not only enhances gameplay, but also strengthens the social fabric in the gaming community.

“ODIN represents the future of in-game communication. We combine cutting-edge technology with decades of expertise in the gaming industry to create a product that is fun and designed to improve gamers’ communication,” says Phillip Schuster, CEO at 4Players GmbH. “We are excited to be working with MADFINGER Games to further optimize the immersion of Gray Zone Warfare. The partnership highlights our shared goal of driving social interaction and creating a unique gaming experience.”

With the release of Gray Zone Warfare for Early Access on 30th April 2024 , players will experience unparalleled realistic gaming communication with ODIN.

About ODIN

4Players’ next generation voice chat SDK, ODIN, offers unrivalled audio quality. ODIN supports full engine integration for Unity, Unreal Engine (4.x/5.x) and web applications and works cross-platform. In addition, the voice chat provides crystal-clear communication for more than s users per room simultaneously and can be scaled horizontally almost indefinitely.

About 4Players

4Players is a provider for multiplayer services and creates metaverse-ready, cross-platform, safe and interactive experiences with ODIN, an ultra-immersive voice chat tool, including full 3D spatial audio support. The sub brand 4Netplayers is one of the largest game server providers in Europe and offers ultra-low latency hosting worldwide. The server fleet is represented in 18 locations (USA, EU, Asia, Australia) and is always equipped with the latest server technology.

About MADFINGER Games

MADFINGER Games is a globally renowned independent game studio with a rich portfolio of award-winning titles played by millions of people worldwide.
Gray Zone Warfare is an immersive tactical FPS with a maximum focus on realism. Join a Private Military Company and navigate a vast open world setting alone or in a squad. Adapt to your surroundings, use tactics to your advantage, and fight against other human operators and AI-controlled enemies.

Encoding ODIN audio data to FLAC for realtime transcription

Tue, 30 Jan 2024 00:00:00 +0000

Leveraging AI tools for transcription is a great way to enhance voice chat applications. While some AI services like Whisper from OpenAI use WAV, other services like Google Speech to Text recommend using FLAC instead.

We already have provided a sample on how to use our NodeJS SDK to transcribe audio streams in real-time using OpenAIs whisper . It encodes the audio data to WAV. In this article, we will show you how to encode audio data to FLAC for realtime transcription.

Getting started with ODIN

Please refer to the Transcribe sample for the overall script and how to get started with ODIN. Using the information provided here it should be easy to change it to use FLAC instead of WAV.

Why FLAC?

FLAC is a lossless audio format. This means that the audio data is compressed without any loss in quality. This is important for transcription because the quality of the audio data is crucial for the transcription quality.

How to encode audio data to FLAC

We will use the libflacjs module to encode the audio data to FLAC. The module is a wrapper around the libflac library. The library is written in C and compiled to WebAssembly.

First thing we need to do import the module (in TypeScript - please refer to the libflacjs Github page on how to import it in JavaScript):

import * as Flac from 'libflacjs/dist/libflac';
import {Encoder} from "libflacjs/lib/encoder";

Next, we need to create an instance of the Encoder class. The constructor takes a Flac object and an options object.

const encoder = new Encoder(Flac, {
channels: 1,
sampleRate: 48000,
bitsPerSample: 16,
verify: false,
compression: 0
});

Tip

Please remember the bitsPerSample setting, as it will have an important part in the next section.

Understanding audio data

Once you have created the encoder, you can start encoding audio data. The encode method takes an ArrayBuffer as input. In ODIN, you subscribe to the AudioDataReceived event and receive raw audio data there. Let’s have a look at the event structure you get:

/**
* The payload for the AudioDataReceived event.
*/
export declare interface OdinAudioDataReceivedEventPayload {
/**
* The ID of the peer that sent the audio data.
*/
peerId: number;
/**
* The ID of the media that sent the audio data.
*/
mediaId: number;
/**
* The audio data received from the peer as 16-bit PCM samples ranging from -32768 to 32767 as a byte array.
* Use `const samplesArray = new Int16Array(samples16.buffer)` to get an actual array
*/
samples16: Uint8Array;
/**
* The audio data received from the peer as 32-bit PCM samples ranging from -1 to 1.
* Use `const floats = new Float32Array(samples32.buffer)` to get an actual array
*/
samples32: Uint8Array;
}

Most audio libraries expect the audio data to be in a specific format. But most formats are just different ways to express the same thing. In the NodeJS SDK, we provide the audio data in two different formats: 16-bit PCM samples and 32-bit PCM samples.

Info

PCM stands for Pulse-Code Modulation. It is a method used to digitally represent sampled analog signals. The samples are stored as a sequence of binary numbers. The number of bits used to represent each sample is called the bit depth. The higher the bit depth, the more accurate the representation of the signal. The bit depth is also called the resolution or the word length.

The bit depth is important because it determines the dynamic range of the audio signal. The dynamic range is the ratio between the loudest and the quietest sound. The higher the dynamic range, the more accurate the representation of the signal. The dynamic range is also called the signal-to-noise ratio.

The sample rate is the number of samples per second. The higher the sample rate, the more accurate the representation of the signal. The sample rate is also called the sampling frequency.

In our SDK, samples16 is a raw byte array with 2 bytes per sample. The samples are signed 16-bit integers. The range is from -32768 to 32767. samples32 is a raw byte array with 4 bytes per sample. The samples are signed 32-bit floats. The range is from -1 to 1.

Some audio libraries - like the WAV encoder used in the example code accepts these Uint8array objects directly. Others, like the FLAC encoder - expect the audio data to be in a Int32Array. So, how do we convert the Uint8Array to a Int32Array?

Converting Uint8Array to Int32Array

The Int32Array constructor takes an ArrayBuffer as input. So, we need to create an ArrayBuffer from the Uint8Array first. We can do that by using the buffer property of the Uint8Array:

const samples32 = new Float32Array(event.samples32.buffer);
const samples16 = new Int16Array(event.samples16.buffer);

The Flac library expects the audio data to be in a Int32Array. So, we need to scale the range of -1 to 1 to either -32768 to 32767 for 16 Bit (see 256*256=65536 which split into half for positive and negative numbers is 32768) or -8388608 to 8388607 for 24 Bit. So, all we need to do is getting the samples as Float32Array scale each sample to the desired range and convert it to a Int32Array:

This is the function that does the heavy lifting for us:

 convertAudioSamples = function(samples32: Uint8Array, bitDepth: number): Int32Array {
// Samples from Odin are 32 bit floats encoded in a Uint8Array, that is 4 elements of the Uint8Array form one sample
// which is a 32-bit float value. So we need to convert every 4 elements to one 32 bit float value. This can be
// done with a Float32Array view on the Uint8Array buffer
const floats = new Float32Array(samples32.buffer);
// We now have a Float32Array with the samples ranging from -1 to 1. We need to convert them to signed integers
// with the range of the bit depth. So for 16 bit, we need to convert the floats to integers in the range of
// -32768 to 32767. For 24 bit, we need to convert the floats to integers in the range of -8388608 to 8388607.
const scale = Math.pow(2, bitDepth - 1) - 1; // calculate scale based on bitdepth
// Create a new Int32Array with the same length as the Float32Array and convert the floats to integers using
// the scale calculated above
const intArray = new Int32Array(floats.length);
for (let i = 0; i < floats.length; i++) {
intArray[i] = Math.round(floats[i] * scale);
}
return intArray;
}

Encoding the audio data

Now that we have the audio data in the correct format, we can encode it to FLAC. The encode method of the Encoder class takes an Int32Array as input, so we can pass the result of the convertAudioSamples function to it:

 // Add an event filter for audio data received events and write the audio data to the file using the FLAC encoder
room.addEventListener('AudioDataReceived', (data) => {
const intArray = convertAudioSamples(event.samples32, 16);
encoder.encode(intArray);
});

Please note: You’ll need to use the same bit depth as you have used when creating the encoder. In our example, we have used 16 bit. If you want to use 24 bit, you need to change the bitsPerSample setting of the encoder to 24 and change the convertAudioSamples function to use 24 bit as well.

As you can see that is pretty simple. Once you have finished encoding enough data, i.e. when the user stops talking, you can call the encode method of the Encoder class to finish the encoding process:

// Finalize the encoding process
encoder.encode();
//get the encoded data:
const encData = encoder.getSamples();
// Write file to disc
fs.writeFileSync("./test.flac", encData);

Conclusion

In this article, we have shown you how to encode audio data to FLAC for realtime transcription. We have also shown you how to convert the audio data from the ODIN SDK to the format required by the FLAC encoder. We hope this article was helpful.

Unleashing the Power of Seamless Communication: 4Players ODIN SDK v1.8.2 for Unreal Engine

Mon, 22 Jan 2024 00:00:00 +0000

The world of real-time communication in gaming and digital applications is constantly evolving, and staying ahead of these changes is crucial for developers. That’s why we’re thrilled to announce the release of version 1.8.2 of our ODIN Software Development Kit (SDK) for Unreal Engine, packed with enhancements that promise to elevate your development experience.

What’s New in v1.8.2?

Improved Plugin Compatibility: In our ongoing effort to ensure smooth integration with a wide range of Unreal Engine projects, we’ve renamed the odin.h core SDK header file. This change addresses and prevents naming conflicts with other plugins, ensuring a more streamlined development process.
Crucial Bug Fix: We’ve addressed a significant bug related to the BytesToString and StringToBytes functions in Unreal Engine, which previously disrupted the peer/room user data byte array format. This fix is based on detailed community feedback (see the forum post for more details ). Our commitment to community-driven improvements continues to shape the ODIN SDK, making it more robust and developer-friendly.

Looking Back: v1.8.1 Enhancements

While we didn’t announce it separately, version 1.8.1 also brought a subtle yet impactful change:

Streamlined Codebase: We removed the unused ConstructJsonValue function. This refinement aligns with our philosophy of lean and efficient code, ensuring that every element of the ODIN SDK is essential and purpose-driven.

Why Choose 4Players ODIN SDK for Unreal Engine?

Our SDK stands at the forefront of real-time communication solutions, offering unparalleled voice communication integration into your digital applications. Whether you’re working on a gaming project, an educational platform, or a VR/AR application, the ODIN SDK empowers you with:

Cutting-edge technology for superior communication experiences.
Cross-platform compatibility, from desktop to mobile.
A focus on privacy and security, respecting user data.
Scalability to meet the needs of any project size.
Comprehensive documentation and support for effortless implementation.

Embark on Your Next Project with Confidence

We’re committed to providing developers with the tools they need to create immersive, interactive, and connected experiences. The release of ODIN SDK v1.8.2 for Unreal Engine is a testament to this commitment, reflecting our dedication to continuous improvement and responsiveness to community feedback.

Stay ahead in the dynamic world of application development with 4Players ODIN SDK. Download version 1.8.2 today, and experience the difference in your Unreal Engine projects.

Unity SDK v1.6.0: Elevating Your Development Experience with Core SDK v1.6.4 and Essential Fixes

Thu, 18 Jan 2024 00:00:00 +0000

In the world of game development and interactive applications, continuous improvement is key to creating outstanding user experiences. That’s why we’re excited to announce the release of Unity SDK version 1.6.0. This latest update encapsulates our commitment to providing developers with robust, efficient tools for integrating top-tier real-time communication features.

Core SDK Integration: A Leap Forward

Core SDK Version 1.6.4: The heart of this update lies in the integration of Core SDK version 1.6.4. This advancement brings with it a suite of enhancements and optimizations, ensuring that your Unity projects benefit from the latest developments in real-time communication technology.

Focused Bug Fixes and Improvements:

Serialization Build Error Resolution: In response to feedback from our developer community, we’ve addressed and fixed the potential FindObjectOfType serialization build errors. This fix significantly improves the build process, providing a smoother and more reliable development experience.
UserData Handling Optimization: Another crucial fix in this update is the resolution of an issue where user data was incorrectly replicated across multiple rooms when using OdinHandler.JoinRoom. This fix ensures that user data is handled accurately and securely, maintaining the integrity of room-based operations.

Implications for Developers:

The release of Unity SDK v1.6.0 marks a significant step in enhancing the efficiency and reliability of game development and interactive applications. By addressing key issues and integrating the latest Core SDK, we empower developers to focus on what they do best - creating immersive, interactive experiences without worrying about the complexities of real-time communication integration.

Join the Evolution:

Ready to take your Unity projects to the next level? Incorporate Unity SDK v1.6.0 into your development workflow today. Explore the detailed changelogs and begin leveraging these latest enhancements for a superior development experience. Visit our GitHub repository to download the update and start transforming the way you integrate communication in your applications.

Get Started with Unity today

Wwise and ODIN: how to integrate a voice chat into your Unreal game using both plugins

Fri, 15 Dec 2023 00:00:00 +0000

Wwise and ODIN

Are you using Unreal with Wwise and wondering if it works together with our proximity voice chat ODIN? Yes, it does! It’s not even hard to do. It needs a little different setup for the voice playback, though. After that you can take advantage of the high quality built-in features from Wwise and apply them to your voice audio, e.g. spatial audio.

Read our guide and check our sample project :

Wwise Guide

Sample Project

If you are new to ODIN, read this »Starter Guide « or watch our »Video Tutorial Series «

Using FMOD? We got you covered with this »Guide for FMOD «

Do you need help with another sound plugin or did you already find a solution to make it work with Odin? Please tell us on Discord !

Discord Community

Introducing Our AI-Powered Chatbot for ODIN SDK Support – Your 24/7 Development Companion

Mon, 04 Dec 2023 00:00:00 +0000

Dear Developers,

We’re thrilled to announce an exciting addition to our ODIN Software Development Kit (SDK) resources – an AI-powered chatbot, designed to provide round-the-clock support for developers working with the ODIN SDK. This innovative tool is now accessible through our developer documentation at 4Players ODIN and is ready to assist with Unreal, Unity, and Web SDK queries. Swift SDK support is on the horizon as well.

Understanding the AI Chatbot

Our AI assistant is not just any chatbot. It’s been meticulously trained with extensive ODIN documentation, SDK references, guides, and sample code. This means that it’s equipped to offer detailed and specific support, mirroring the expertise you’d expect from our developer team.

Why Use the AI Chatbot?

24/7 Availability: Whether you’re burning the midnight oil or working in a different time zone, our AI chatbot is always on standby to help you out.
Instant Support: Get immediate answers to your queries without waiting for human support, enabling a smoother and faster development process.
Comprehensive Knowledge Base: With training based on our vast repository of ODIN documentation, the chatbot can handle a wide array of questions, from basic to complex.

Your Feedback Matters

As exciting as this beta release is, we acknowledge that perfection is a journey. That’s why we’re inviting you, our valued user community, to actively participate in this journey. Test out the chatbot and use the feedback buttons to rate answers as useful or not. Your input is crucial for us to continually refine and enhance the chatbot’s capabilities.

Continuous Improvement

We’re committed to making this AI chatbot an invaluable tool for developers. Based on your feedback and ongoing chats, we will constantly update its training material and fine-tune its responses, with the help of our experienced development team.

Future Plans

Expanding the AI chatbot’s support to include other SDKs is a priority for us. We’re working diligently to extend its capabilities so that no matter which part of the ODIN ecosystem you’re working with, expert assistance is always a chat away.

Get Started

Experience the future of developer support now. Head over to our ODIN documentation and start chatting with the AI assistant. We can’t wait to hear about your experiences and look forward to growing together in this exciting new chapter of development support.

Thank you for being a part of our community and for joining us in this innovative journey.

Happy Developing!

ODIN Unreal SDK 1.8.0: New API Features and Critical Improvements

Thu, 16 Nov 2023 00:00:00 +0000

Hello ODIN Developers!

We are excited to bring you the latest update for the ODIN Unreal SDK - version 1.8.0. This release comes with important enhancements and new API features that further streamline your development process. Let’s delve into what 1.8.0 has to offer:

Core SDK Update

The core SDK has been advanced to version 1.6.4. This update is pivotal in ensuring that our SDK remains at the forefront of technology. You can find more details on this update here .

API Enhancements

RestartCapturing in UOdinAudioCapture: This new addition allows for a more flexible control over audio capturing, enabling developers to restart capturing with ease.
GetIsPaused and SetIsPaused in UOdinAudioCapture: These functions provide greater control over audio capture management, allowing for a pause and resume mechanism.

Bugfixes and Improvements

Unreal Engine 5.3 Compatibility: We’ve addressed build issues and deprecation warnings associated with Unreal Engine 5.3, ensuring smoother integration.
Crash Fix on Capturing Restart: Resolved a potential crash that could occur when trying to restart capturing after stopping it.
CanContainContent Disabled: In response to community feedback (as noted in issue #1), we’ve disabled CanContainContent, focusing on enhancing user experience.

Join Us in Shaping the Future

As always, your feedback is invaluable to us. It helps us tailor our SDK to meet your needs and expectations. We encourage you to dive into version 1.8.0 and share your thoughts with us.

Together, let’s continue to push the boundaries of real-time communication in game development!

Download the Unreal SDK today

Introducing ODIN Unreal SDK 1.7.0: A Leap Forward in Real-Time Communication

Wed, 08 Nov 2023 00:00:00 +0000

Hello ODIN Community!

We are excited to announce the release of ODIN Unreal SDK 1.7.0, marking a significant step forward in our commitment to providing the best real-time communication solutions. This release builds upon our previous updates in the 1.6.x branch, bringing new features and critical improvements. Let’s take a look at the journey from 1.6.1 to our latest 1.7.0 update:

1.6.1 & 1.6.2: Core SDK Updates and Stability Enhancements

Core SDK Progression: Both 1.6.1 and 1.6.2 versions focused on updating the core SDK, enhancing overall performance and stability. Detailed insights can be found here for 1.6.1 and here for 1.6.2 .
1.6.2 Specific Improvements:
- Resolved build issues related to missing includes in Unreal Engine 5.3.
- Addressed a bug causing crashes with invalid reference handling during MediaRemoved events.
- Fixed potential crashes during seamless travel, ensuring smoother transitions and reliability.

1.6.3: Direct API Access and Bug Fixes

Enhanced API Functionality: Updated the API to allow direct access to the internal media sound generator, offering more control and flexibility.
Audio Capture Optimization: Fixed a bug where UAudioCapture was initialized with an invalid sample rate or channel count, ensuring more accurate audio processing.

1.7.0: A New Milestone with Enhanced Audio Control

Input Volume Adjustment: The highlight of version 1.7.0 is the addition of input volume adjustment functionality for capture media. This feature allows developers to fine-tune audio input levels, providing better control over the user experience in real-time communication scenarios.

Moving Forward Together

As we continue to evolve the ODIN Unreal SDK, we remain dedicated to enhancing your development experience. These updates reflect our commitment to addressing community feedback and advancing our technology.

We encourage you to explore these new updates and share your experiences. Your feedback is instrumental in guiding our future developments.

Thank you for being a part of our journey. Here’s to many more milestones with ODIN!

Download the Unreal SDK today

Introducing Unreal SDK 1.6.1: New features, many bugfixes, some small API changes

Tue, 17 Oct 2023 00:00:00 +0000

Introduction

We are happy to announce the release of our Unreal SDK 1.6.1. This version brings new features and bugfixes, but also some small API changes.

What’s new in Unreal SDK 1.6.1 compared to 1.5.6 ?

General

The Core SDK has been updated to version 1.6.1.

New Features

Added Pause Playback Media to instruct the server to pause the specified media stream, ceasing the reception of data
Added Resume Playback Media to instruct the server to resume the specified media stream, re-initiating the reception of data
Added Get Output Media Peer ID
Added Set Room APM Stream Delay for scenarios where audio output and input are not synchronized to ensure that the echo canceller can align both streams

API Changes

Updated Join Room and Update Peer Position to support 3D coordinates
Removed Update Room User Data (use RoomUpdate RPC on an ODIN gateway instead)

Bugfixes / Improvements

Fixed build issues and deprecation warnings with Unreal Engine 5.3
Fixed a potential crash when switching capture devices
Added functions to allow listening to audio buffer changes in OdinMediaSoundGenerator
Update default build settings for compatibility with engine versions 4.24 or later
Updated include path in OdinMediaSoundGenerator
Fixed an issue where stereo output interfered with the functioning of echo cancellation
Updated initial APM settings
- Enabled Voice Activity Detection
- Enabled Noise Suppression
- Enabled Gain Controller
Updated static library format on iOS and macOS for Unreal Engine Marketplace compliance
Fixed a bug where capture device selection always picked the default device

Conclusion

The Unreal SDK 1.6.1 brings convenience and bandwidth saving features along with many bugfixes and improvements. Upgrade to Unreal SDK 1.6.1 today and benefit from the new improvements in your projects. We look forward to your feedback and to continually refining our SDKs for your needs.

Download Odin Voice SDK 1.6.1
ODIN SDK @ Unreal Marketplace (update available soon!)
Join our Discord
Read the Documentation

Unveiling New Enhancements: ODIN Unreal SDK Update from 1.5.6 to 1.6.0

Wed, 11 Oct 2023 00:00:00 +0000

Greetings, ODIN Developers!

We are excited to share the latest updates to our ODIN Unreal SDK, covering the advancements from version 1.5.6 to the newly released 1.6.0. This update marks significant improvements and new features that will enhance your development experience. Let’s dive into the details:

1.5.7: Streamlined Compliance and Device Selection

Browser Clients Update: It’s important to update your browser clients to version 0.15.0 or later of the @4players/odin package.
Core SDK Update: Upgraded to version 1.5.7. Check the details here .
iOS and macOS Enhancements: We’ve updated the static library format for better compliance with Unreal Engine Marketplace standards.
Capture Device Selection Fix: Resolved an issue to ensure the correct capture device is selected, rather than defaulting to the system’s choice.

1.5.8: Advanced Audio Processing and Echo Cancellation

Core SDK Update: Progressed to version 1.5.8. Full details are available here .
New Features:
- Set Room APM Stream Delay: This feature assists in syncing audio output and input, vital for effective echo cancellation.
Stereo Output and Echo Cancellation: Fixed a crucial issue where stereo output was impacting echo cancellation.
APM Settings Update: We’ve enabled Voice Activity Detection, Noise Suppression, and Gain Controller for optimized audio processing.

1.5.9: Audio Buffer Enhancements and Engine Compatibility

OdinMediaSoundGenerator Updates: Added functions for monitoring audio buffer changes and updated include paths for improved usability.
Engine Compatibility: Ensured default build settings are compatible with Unreal Engine versions 4.24 and later.

1.6.0: Pioneering Media Stream Control and API Enhancements

Server Requirements: This update necessitates ODIN server version 1.3.0 or newer. Cloud-hosted servers are updated automatically.
Core SDK Update: Advanced to version 1.6.0. Full release notes can be found here .
New Features:
- Pause Playback Media & Resume Playback Media: These commands allow for precise control over media stream reception.
- Get Output Media Peer ID: A new addition for enhanced media stream management.
API Updates:
- Join Room and Update Peer Position now support 3D coordinates.
- Update Room User Data has been removed in favor of the RoomUpdate RPC.
Compatibility and Stability Improvements: Fixed build issues and addressed deprecation warnings with Unreal Engine 5.3. Also resolved a potential crash related to capture device switching.

Join Us in This Exciting Journey

These updates represent our commitment to providing you with a robust and efficient development environment. We encourage you to explore these new features and improvements. Your feedback is invaluable in our quest for continuous enhancement.

Stay tuned for more updates, and happy developing with ODIN!

Download the Unreal SDK today

Introducing Unreal SDK 1.5.6: Expanding iOS Support and Enhanced Stability

Wed, 28 Jun 2023 00:00:00 +0000

Introduction

We are thrilled to announce the release of our Unreal SDK 1.5.6. This version brings robust support for iOS, various new features, significant improvements in system stability, and compatibility for upcoming Unreal Engine 5.3 releases.

What’s New in Unreal SDK 1.5.6?

General

The Core SDK has been updated to version 1.5.5.
We’ve now switched to static linking on iOS and macOS, making your development process more streamlined.

New Features

iOS Support: We have expanded our platform reach to include iOS, enabling more users to experience high-quality voice communication.
Reset Function: The new Reset function resets media handles on ODIN synth components, offering greater control over media handling.
Room User Data Changed Event: The SDK now broadcasts a ‘Room User Data Changed’ event, providing real-time information about changes in user data.
Support for Unreal Engine 5.3: We are ensuring your projects stay ahead of the curve with support for the upcoming Unreal Engine 5.3 releases.

Bugfixes / Improvements

Unreal Engine Build Issues: Fixed potential build issues with Unreal Engine 5.1 and later.
Garbage Collection of Handles: Resolved an issue where handles were unexpectedly garbage collected, resulting in closed connections.
Invalidated Structures Access: Fixed issues causing application crashes due to accessing pointers linked to invalidated structures.
Asynchronous Access Violations: Resolved crashes resulting from asynchronous access violations.
Game-Thread Synchronization: Enhanced system stability by wrapping each event with game-thread synchronization tasks.
Event Handling Update: Event handling now uses task-launching on a per-event basis, offering more efficient processing.
AVAudioSession Configuration: To mitigate potential crash issues on iOS, we’ve ensured the proper configuration of AVAudioSession.
Linker Issues: Fixed linker issues caused by the use of a newer clang version in Unreal Engine 5 projects.

Conclusion

The Unreal SDK 1.5.6 brings significant enhancements and expanded platform support, ensuring a more robust voice communication experience for users across various platforms. Upgrade to Unreal SDK 1.5.6 today and benefit from the new features and stability improvements in your projects. We look forward to your feedback and to continually refining our SDKs for your needs.

Announcing Unity SDK 1.5.5: Enhanced Audio Performance and Android Support

Sat, 17 Jun 2023 00:00:00 +0000

Introduction

We are excited to announce the release of our Unity SDK 1.5.5. This new update brings improvements to the audio handling, bug fixes, and support for Android on ARMv7a devices, ensuring a seamless and high-quality voice communication experience across multiple platforms.

What’s New in Unity SDK 1.5.5?

General Update

The Core SDK has been updated to version 1.5.5. For more detailed information on the core updates, please refer to the Core SDK release notes.

New Features

Android ARMv7a Support: We’ve broadened our Android device support with the inclusion of ARMv7a, expanding the reach of your voice communication capabilities to even more users.

API Changes

SilenceCapturedAudio Addition: We’ve introduced the SilenceCapturedAudio method on the audio sender, giving you more control over the audio capture process.
Deprecated Properties Removal: To streamline our API, we’ve removed the IsPaused and IsMuted deprecated properties from media streams.

Bugfixes and Improvements

Device Reset Fallback: To ensure smoother recovery, we’ve added a fallback to the default device during reset.
OnMediaActiveStateChanged Event Update: We’ve fixed the update for this event for input streams, ensuring accurate status updates.
Echo Cancellation: Echo cancellation has been improved for enhanced audio clarity during conversations.
PlaybackStream Connection Reset: We’ve ensured that the media handle resets upon connecting to the PlaybackStream for a clean state.

Conclusion

Our Unity SDK 1.5.5 brings significant improvements to audio handling and broadens device support, ensuring a more robust and inclusive voice communication experience for users across various platforms. We are committed to continuous refinement of our SDKs and look forward to hearing your feedback.

Upgrade to Unity SDK 1.5.5 today and unlock enhanced voice communication features in your projects!

Get Started with Unity today

Revolutionizing Multiplayer Gaming with ODIN: AI-Driven NPCs for Immersive Experiences

Fri, 21 Apr 2023 00:00:00 +0000

Introduction

In the world of multiplayer gaming, one of the biggest challenges faced by developers and players alike is the lack of real human interaction in the gaming environment. This often leads to a “chicken and egg” situation, where the absence of other players makes a game uninteresting, resulting in fewer players joining in. But what if we could change that with the power of AI-driven NPCs (non-player characters)?

Introducing ODIN: The Real-Time Voice and Data Sync SDK

We’ve already made SDKs available for C, C#, Unity, Unreal Engine 4 and 5, the Apple ecosystem, and the web. Our most recent addition is the NodeJS SDK , enabling server-side data and audio reception, which can be used for recording, transcribing, and interacting with other peers via data channels.

AI-Driven NPCs: A New Era of Immersive Gaming

Today’s NPCs in multiplayer games are typically limited in their capabilities, not networked, and unable to replace real players. By leveraging AI-driven NPCs, we can create more interactive and engaging gaming environments that attract and retain players.

For example, imagine a barkeeper in a metaverse-like application. This AI-driven bot could receive and transcribe nearby players’ audio, feed it into a language model like ChatGPT, generate a response, and play it back via text-to-speech in the game.

While there have been experiments using this approach, most have been limited to client-side, single-player experiences. In multiplayer environments, you need a solution that works for all users in the same area.

That’s where ODIN comes in. With our cross-platform real-time voice and data sync SDK, every player in the same room can talk and interact with each other. And now, with the NodeJS SDK, a player can also be an AI-driven bot, with the full potential of a human player. These bots are lightweight, horizontally scalable, and receive individual audio streams and the same data as human players.

When a server spawns an NPC, it can trigger the launch of a corresponding bot running ODIN’s NodeJS SDK, listening to audio and data channels to interact with nearby players. If the NPC is killed or removed from the game, the bot will be stopped. As it’s just a simple NodeJS script, you can run them in a Kubernetes cluster.

Get Started with ODIN Today

If you’re interested in exploring these next-generation applications and experiments, download our SDK and get started for free. Our free tier includes up to 25 concurrent users, more than enough for your experiments. Don’t miss the opportunity to revolutionize multiplayer gaming with AI-driven NPCs and immersive experiences powered by ODIN.

Introducing the ODIN Node.js SDK: Unlock Server-Side Capabilities for Voice Communication

Fri, 14 Apr 2023 00:00:00 +0000

Introduction

We are proud to announce the availability of our native Node.js SDK for ODIN, expanding the possibilities for server-side voice communication in your projects. This powerful new SDK allows developers to access advanced features like recording and transcribing voice per user, building bots that interact with other users through text chat or voice, and more. By leveraging the native Node.js bindings for the ODIN SDK, you can unlock the full potential of voice communication in your games and applications.

ODIN Node.js SDK Overview

The ODIN Node.js SDK is based on the ODIN Native SDK and wraps the C++ code into a Node.js module. While we offer a JavaScript/TypeScript SDK with fallback code for WebRTC that can be used in browsers and Node.js, it is not as performant and has some limitations. The native Node.js SDK addresses these issues and provides additional functionality, making it the perfect choice for bots and other advanced use cases.

Key Differences between ODIN Node.js SDK and Web SDK

While the API for the Node.js SDK is designed to be as similar as possible to the Web SDK, there are some differences:

The Node.js SDK allows you to access raw audio data from the ODIN server, enabling you to record audio or send audio into a room.
The Node.js SDK is optimized for server-side use cases, while the Web SDK is tailored for browser-based applications.

Prerequisites and Dependencies

To use the ODIN Node.js SDK, you will need a C++ compiler installed. For macOS, install XCode and the command line tools; for Linux, install GCC. More information on this can be found in the node-gyp documentation.

The ODIN Node.js SDK depends on the native ODIN SDK. Some precompiled libraries for typical platforms (macOS, Windows, and Linux) are provided in the libs folder.

Usage Examples

We have created two simple usage examples that you can find in the tests folder of the NPM package.

Audio Recording and Transcription

We provide an example that demonstrates how to use the ODIN Node.js SDK to record audio from other users and send it to OpenAI for transcription using OpenAIs whisper model. It also showcases basic bot functionality, such as sending a message to the chat.

Sending Music

This example demonstrates how to use the ODIN Node.js SDK to send music to other users in a room. It loads a sample MP3 file, decodes it, and sends it to the ODIN server.

Detailed instructions on how to run the music sending example can be found in the tests/sending-audio folder of the NPM package.

Conclusion

The ODIN Node.js SDK opens up a world of possibilities for server-side voice communication, providing advanced functionality for developers to create immersive and interactive experiences. With the native Node.js bindings, you can harness the power of the ODIN SDK and bring your projects to new heights.

Get started with the ODIN Node.js SDK today and explore the incredible potential of server-side voice communication in your applications!

ODIN Node.js SDK on NPM

Introducing ODIN Voice SDK 1.5.0: Enhancing 3D Spatial Voice Communication for Unreal Engine Games

Tue, 04 Apr 2023 00:00:00 +0000

Introduction

We are excited to announce the release of ODIN Voice SDK 1.5.0, a significant update to our real-time voice SDK for Unreal Engine-based games. This new version delivers enhanced 3D spatial voice communication, making it even easier for developers to add immersive and realistic voice interactions in their games. With full blueprint support and a range of new features and bugfixes, ODIN Voice SDK 1.5.0 promises to take in-game communication to the next level.

What’s new in ODIN Voice SDK 1.5.0

General

Our core SDK has been updated to version 1.5.0, incorporating a range of improvements and optimizations. For a detailed breakdown of the changes, please refer to our official documentation.

New Features

Unreal Engine 5.2 Support We’re proud to offer support for Unreal Engine 5.2, ensuring that developers can access the latest features, optimizations, and capabilities of this powerful game engine.
Reverse Stream Processing for Echo Cancellation To provide an even clearer communication experience, we’ve added reverse stream processing for echo cancellation. This feature uses the engine master submix to minimize echo and improve overall audio quality.
UOdinAudioCapture Class for Capture Device Selection With the addition of the UOdinAudioCapture class, developers can now enable users to choose their preferred audio capture device, providing a more seamless and customizable experience.

Bugfixes / Improvements

Audio Attenuation Settings Fix We’ve fixed a bug where audio attenuation settings were not being applied correctly, ensuring that distance-based audio adjustments work as intended.
Active Media Stream Objects Garbage Collection Fix We’ve addressed an issue where active media stream objects were being garbage collected, leading to unexpected behavior. This fix ensures more stable and reliable voice communication.
Blueprint Only Builds on Linux Fix Developers working on Linux can now rejoice as we’ve resolved the issue with blueprint-only builds, making it easier to develop and deploy projects across platforms.

Conclusion

ODIN Voice SDK 1.5.0 is a major milestone in our journey to provide the best possible 3D spatial voice communication for Unreal Engine-based games. This update brings new features, performance improvements, and bugfixes that will help developers create even more immersive and engaging in-game experiences.

We’re committed to continuously improving and expanding our SDK, and we can’t wait to see the incredible projects our community will build using these new capabilities. Don’t hesitate to share your feedback and experiences with us, as we value your input in shaping the future of ODIN Voice SDK.

Get started with ODIN Voice SDK 1.5.0 today and elevate your in-game voice communication like never before!

Introducing Web SDK 0.15.1

Tue, 14 Mar 2023 00:00:00 +0000

Introduction

We are thrilled to announce the release of Web SDK 0.15.1, a crucial update that enhances cross-platform interoperability with our latest native SDKs, starting with version 1.4.0 or later. This new version addresses important bugfixes and introduces updated QoS metrics for compatibility, ensuring a seamless voice communication experience between web and native platforms.

What’s new in Web SDK 0.15.1

Bugfixes

Speech Detection Settings in VAD Processor: We’ve fixed a bug where speech detection settings were not being applied correctly in the Voice Activity Detection (VAD) processor. This fix ensures accurate speech detection and a better overall voice communication experience.

Improvements

Updated QoS Metrics for Native Client Compatibility: In this update, we’ve made changes to the Quality of Service (QoS) metrics to ensure compatibility with native clients using version 1.4.0 or later. This improvement guarantees smooth interoperability between web and native platforms, providing a consistent and high-quality voice communication experience for all users.

Conclusion

Web SDK 0.15.1 is a significant step forward in ensuring seamless cross-platform voice communication, allowing developers to create engaging and immersive experiences for users across web and native platforms. This update provides important bugfixes and compatibility improvements, making it easier than ever to connect players and create collaborative gaming experiences.

We are committed to continually refining and expanding our SDKs, and we look forward to seeing the innovative projects our community will develop using these new features. Your feedback is invaluable to us, and we encourage you to share your thoughts and experiences with our team.

Upgrade to Web SDK 0.15.1 today and unlock the full potential of cross-platform voice communication in your projects!

Announcing Partnership with Combat Waffle Studios

Sat, 04 Mar 2023 00:00:00 +0000

We are excited to announce our partnership with Combat Waffle Studios Inc , who will be launching their latest game - Ghosts of Tabor - on 20th March 2023. Ghosts of Tabor is a VR-only survival game that promises to set new standards for immersion, putting you in the heart of a first-person military shooter.

The game takes place on the island of Tabor, where players must explore, loot, and shoot their way through the environment to survive. With crystal clear voice chat, you can coordinate with your friends to overcome the challenges that lie ahead. And with ODIN’s support, voice chat in Ghosts of Tabor will feature 3D spatial audio, proximity chat, environmental effects and audio occlusion, making the gameplay experience all the more immersive.

With its stunning graphics, realistic sound effects, and adrenaline-pumping gameplay, Ghosts of Tabor is sure to provide an unforgettable experience for gamers. So put on your VR headset and get ready for an adventure like no other. Combat Waffle Studios Inc has been working tirelessly to bring Ghosts of Tabor to life and we are proud to be partnering with them to provide our support. We believe that their innovative approach to VR gaming will be a game-changer in the industry and we look forward to seeing the impact that it will have.

As 4Players, we are committed to providing the best audio solutions for gaming with ODIN, so we are thrilled to be part of Ghosts of Tabor’s launch. We can’t wait to hear from the players about their experiences and how they fought their way through the island of Tabor.

In conclusion, if you’re a fan of survival games, first-person shooters, and immersive VR experiences, you won’t want to miss Ghosts of Tabor. Get ready to explore, loot, and shoot your way to survival, and don’t forget to let us know how you fared!

Join the Ghosts of Tabor Discord Server

Announcing Partnership with SpecPixel Entertainment

Tue, 28 Feb 2023 00:00:00 +0000

Today, we’re thrilled to announce our exciting new partnership with SpecPixel Entertainment , in which we will be supporting their latest game - New Citizen - with our state-of-the-art ODIN in-game voice chat and high-performance servers from 4Netplayers!

New Citizen is the highly anticipated RPG multiplayer sim revival set to launch in 2023, and we can’t wait for you to experience this immersive and exciting new world. Whether you choose to explore alone or join a community, you will have the freedom to decide your own path. Will you be a hero, defending your city against the forces of evil, or will you rise through the ranks of the criminal underworld to become a powerful leader? The possibilities are endless!

Our ODIN in-game voice chat and 4Netplayers servers are designed to enhance your multiplayer gameplay experience, providing you with seamless and immersive communication with other players in real-time. With our cutting-edge technology, you’ll feel like you’re truly a part of this thrilling new world.

Check out the latest trailer for New Citizen right here:

To stay up to date with all the latest news and updates on New Citizen, be sure to join their brand new Discord server. Don’t miss out on the chance to experience the game in full immersion mode and become a part of this exciting new community. We’re honored to be a part of this partnership and can’t wait to see what the future holds!

Join the New Citizen Discord Server

Why should game developers offer dedicated game servers to their players?

Thu, 12 Jan 2023 00:00:00 +0000

We all love multiplayer games, and we can’t get enough of the thrill they give us. However, we also can’t ignore all the troubles they pose for developers and players. For most teams, creating a top-tier multiplayer experience requires years of dedication, as well as a larger team, with more comprehensive knowledge.

Today, we would like to discuss how developers can offer a simple solution to players, improving their gaming experience and their safety, without excessively increasing their production costs: premium dedicated game servers. Over time, dedicated game servers have changed from being the only option for playing games to being an option only players interested in avoiding public servers would use. As a result, the games scene has evolved, and not always in a positive way. Unfortunately, the level of exposure the players are subjected to often means they are subject to harassment and trolling as well as psychological and physical threats. As a result of these behaviors, a very negative image of games can be projected onto parents all over the world. This is also a huge deterrent for many prospects when it comes to choosing the games they want to play. It also disrupts the benefits of playing multiplayer games. Even though several games offer dedicated server capabilities directly, the majority (>90%) of game servers currently rented by gamers are public servers (i.e. not password protected).

Moreover, players’ profiles changed significantly, with more players interested in understanding the inner workings of their favorite games, as well as having more control over their gameplay experiences. Players moved from their passive roles as mere spectators to being part of an active community, interested in being heard, respected, and sometimes even influencing design and business decisions.

With the current state of the games industry, it is not advisable to alienate your player base. Therefore, offering private dedicated servers for your community and informing them about their benefits is not only simple but also a monetization opportunity for developers and publishers.

Private dedicated game servers can be a helpful tool to help fight harassment in online games. This is because they can provide a more secure and controlled environment where the community itself can enforce rules and policies. For example, dedicated servers allow players to block or filter out toxic or harassing messages, and they additionally can ban players that violate the rules. When done properly (i.e. using server-side input validation), cheating can also be prevented quite effectively. It is also imperative for game developers and administrators to have clear policies in place. This will enable them to educate players about appropriate behaviour and how to report harassment when it occurs.

Why not use ONLY peer-to-peer servers?

Although the peer-to-peer configuration allows for fast development iteration and its operation is cheap and requires zero maintenance, there are an array of issues that would need to be taken into consideration:

As servers are temporary, there is a lot of bookkeeping involved (i.e. lobbies, friend lists, matchmaking).
Any form of persistence must be implemented in separate cloud services
Networking issues (firewalls, NAT, etc) might be difficult to solve
Risk of low performance (bandwidth and CPU issues on the host)
Anti-cheat measures are very difficult to implement
The game might be blamed for the issues, instead of the host
Works only for a handful of simultaneous players

Moreover, peer-to-peer hosting limits the options for game design, including the number of players and persistence. To work around those limitations, game developers are faced with complex workloads. Even though it is a cheaper solution than dedicated servers, there are ways to decrease costs by working with server hosts.

Why use dedicated servers?

Although developers can use peer-to-peer mode (local network) as a base, there are several additional reasons why game developers should consider deploying dedicated game servers once in production:

Improved performance

Dedicated game servers can provide a more stable and higher-quality experience for players due to devoted resources like CPUs, memory and bandwidth (headless). In addition to preventing rage quitting, this will improve game retention and increase gameplay time. Dedicated game servers can improve game performance in many ways:

Improved stability

Dedicated game servers are dedicated machines specifically designed to run the game, which means they are less prone to performance issues such as lag, dropped connections, and other disruptions. There are no networking issues, as clients connect to the server with exposed and stable IP addresses or domains.

Better hardware

Dedicated game servers are often equipped with more powerful hardware than a player’s personal computer, which can result in a smoother, more stable experience for players.

Optimised network infrastructure

Dedicated game servers are typically hosted in data centres with optimized network infrastructure, which can help reduce latency and improve the overall performance of the game.

Fully Customizable

Dedicated servers give developers the option to offer a more extensive level of customizability to players, such as the ability to mod the game or change certain gameplay settings.

Modding

Many games allow players to create and install mods, which are custom modifications to the game that can add customized features, change gameplay mechanics, or alter the visual appearance of the game. Dedicated game servers can make it easier for players to install and use mods because they do not have to worry about compatibility issues with their personal computers.

Custom game modes and maps

Dedicated servers can allow developers to offer custom game modes or settings that are not available in the official retail version of the game. For example, a developer could create a “hardcore” mode that increases the difficulty of the game, or a “creative” mode that allows players to build and create without the constraints of normal gameplay.

Community building

Dedicated game servers can foster a sense of community among players by providing a central location for them to play and interact. Additionally, it encourages players to do the admin work on their own servers, reducing the workload for developers.

Some other ways in which dedicated game servers can contribute to community building include:

In-game chat

Many games with dedicated servers include an in-game chat function that allows players to communicate with each other while playing in a more private environment. This can help foster a sense of community and encourage players to form friendships and connections with one another. Dedicated game servers also offer the option to use TeamSpeak for communication, creating a more private environment for discussion.

Clan or guild support

Some games with dedicated servers offer support for clans or guilds, groups of players that come together to play and socialise. This can help players feel like they are part of a larger community and give them a sense of belonging.

Server-specific events

Some dedicated game servers may host special events or tournaments that are only available to players on that server. This can help bring players together and create a sense of community around the server.

Full Control

By hosting their own dedicated game servers, players have better control over their experience and can manage difficult and/or disturbing situations in a safe and fast manner.

Balancing

Dedicated game servers allow developers to fine-tune the game’s balance, ensuring that it is fair and enjoyable for all players.

Cheating prevention

Dedicated game servers can help prevent cheating by giving developers more control over the game environment. If done right (i.e. server-side input validation) cheating can be prevented quite effectively. This can create a more fair and more enjoyable experience for all players.

More players

Dedicated servers can help attract more players to a game because they offer a more stable and smoother gaming experience, compared to playing on a shared server. Additionally, dedicated servers allow for more customization and can handle larger player capacities. This can make the game more attractive to players who are looking for a more immersive and scalable experience. It can also keep them engaged for a longer period of time

Another benefit of dedicated servers is that they can provide a more secure environment for players, which can be especially relevant for games that involve in-game purchases or other sensitive information.

Cloud services vs. Server Hosts

As explained previously, the use of dedicated game servers can lead to a more stable, high-quality gameplay experience for players. And happier players mean better retention, more spending, and longer gameplay sessions.

Although cloud services in general offer dedicated servers, using server hosts not only decreases operational complexity exponentially but also allows developers to avoid a surprise increase in their expenses. This is because most hosts have fixed pricing.

Additionally, the server hosts:

Are experts in hosting game servers
Handle all the extensive work of deploying updated versions of the server
Typically have specialized web interfaces and APIs for setting up game servers
Most have built-in DDoS protection (not an easy task as most game servers use UDP which is difficult to protect)
Take care of all GDPR issues
Are much cheaper than cloud services as the infrastructure and pricing models are specialized in 24/7 server operations
Work for many simultaneous players
Typically provide support for (Admin-) mods
Most allow gamers to rent their own servers (bringing in that community character)

Are you developing or publishing multiplayer games and would like to offer premium, dedicated game servers to your players? We would love to support you in this! Our product, 4NetPlayers , offers VIP dedicated game servers, powered by a global network, including TeamSpeak server and SinusBot.

Additionally, we might even be able to help you monetize your dedicated servers. Yes, you can earn money working with 4NetPlayers!

Interested? Let’s talk and take your games to the next level together.

ODIN: What the new SDK can do for you

Thu, 05 Jan 2023 00:00:00 +0000

Last year 4Players launched its latest offering, ODIN, revolutionizing gaming experiences with cutting-edge spatial audio features. ODIN is an audio SDK that offers crystal-clear voice chat. It can be seamlessly integrated into apps and games built with Unity and Unreal Engine 4 and 5. Native Swift support for Apple devices and a web SDK for use on websites and web-based applications are available as well.

The ODIN SDK doesn’t only offer immersive experiences in the world of gaming, but it’s also metaverse-ready, supporting voice experiences for the new age of interactive media. ODIN’s prestige is bolstered by the team of veterans who created it - seasoned developers with a true passion and understanding of the games and tech landscapes.

The next generation of in-game audio

Following the success of 4NetPlayers, our high-end, low-latency server hire service, ODIN’s tech levels up in-game multiplayer communications, with spatial audio that makes voice chat feel more real than ever before. These unique features allow users to integrate 3D spatial real-time voice in no time, and without complicated state management. Of course, voice functionality like full-volume radio communication independent of players’ position is also possible with ease, and can even be combined with 3D spatial audio.

Cross-platform functionality and low latency are two of the key tenets that ODIN holds over other voice services. Developers are encouraged to take full advantage of this. With ODIN, users can also select the zero maintenance solution with hosted services in the 4Players Cloud at 14 locations worldwide. However, if you want to host ODIN servers yourself in MS Azure, Google Cloud, AWS, Digital Ocean or any other known service provider, this is possible too.

Pricing structure

Self-server hosting can be incredibly valuable for developers with cross-platform game creation in mind. This service is possible for a monthly fee, based on the running instances in that month (€350 per instance and month plus taxes). ODIN servers report their state - for billing reasons - to 4Players. If a developer wants to run servers in an isolated environment - without the need for an internet connection - this can be done via the perpetual license, a one-time payment of €10,000 per instance.

ODIN’s price is flexible and scalable depending on the scope of the game you are using it for. Not only this, but it is cheaper than leading competitors. For indie projects, such as a small-scale MMO, the price for incorporating ODIN in a cloud hosting capacity is a tenth of that of a competitor, amounting to only €1,200.

Ease of use

Dedicated to privacy and security, ODIN offers end-to-end encryption and is fully GDPR compliant. Truly developer-friendly and quick to integrate, with the process taking under a day to complete - the game engine does the work. With a generic API, the SDK is flexible in its integration, giving ultimate freedom to the developer.

Using the tool is as simple as attaching it to an in-game environment, and then ODIN takes care of the rest. ODIN is not a layer on top of or beside the game engine that developers need to constantly feed with data. Instead, it is deeply integrated into Unity and Unreal, leveraging the native Unity AudioSource API for playback so that voice is part of the game engines´ scene. This, in turn, enables developers to use standard Unity tools like AudioMixer. ODIN is also fully integrated into the Unreal engine’s sound. The ODIN SDK for Unreal enables you to add real-time VoIP communication to your Unreal Engine 4/5 game, thus making it more social and interactive. The audio is played via a synth component and thus integrates natively into the entire Unreal Audio Engine with all the features that come with it.

ODIN also comes with custom-built audio occlusion APIs that will simulate the effect of thick walls and direction. The tool’s servers are horizontally scalable and are a single binary, available for all server platforms such as Windows and Linux (x84 and ARM). Developers can download the server and add a custom license in your dashboard, after this, 4Players will provide extensive documentation on how to run the server.

ODIN is currently being used by developers all over the world, on both small-scale independent games and large-scale, ambitious titles. Make ODIN integration one of your New Year’s resolutions for 2023!

To learn more about ODIN’s technical applications, you can visit our GitHub page here .

Visualizing occlusion in real-time in Unity

Mon, 19 Dec 2022 00:00:00 +0000

As you may have noted, we have been at a lot of events recently, all around the world. Games Convention in Cologne in August, Scottish Games Week, Megamigs in Montreal, and recently we were at the G-Star in South Korea. In all of these conventions we had a booth and showcased our real-time voice SDK - ODIN Voice. Users could enjoy one of our demos in real-time and talk to each other enjoying the 3D spatial audio.

But, it’s 2022, and we still face the same issues and hurdles we faced 10 years ago when attending conventions: Bad internet connection. Although we are able to run the whole ODIN stack on a laptop (i.e. the server and the client running on the same machine without requirement of internet connection) the experience is not as great as you just talk to someone standing next to you.

So, we decided to create a video to show-off what ODIN is all about and what 3D spatial audio is. It’s easier to run a video on a booth and having on-demand demos after the show rather than trying to do everything in a loud, internet-less, crowded environment that is a convention.

Here is the video we came up with:

A very important part of ODIN is its effortless 3D spatial audio system with audio occlusion. So, what does that mean:

If you are standing next to someone, you hear them loud and clear.
If you are standing behind someone, you hear them less loud.
If you are standing behind a wall, you hear them even less loud or you don’t hear them at all, depending on thickness and material of the wall.
If someone stands right next to you, you’ll hear them on your right ear
If someone walks away volume decreases with the distance until you don’t hear them anymore.

So, it’s basically a simulation of voice chatting in the real world. You can hear people around you as you would in real world. Of course, however with all the benefits of a digital, software driving simulation. You can work out the benefits and reduce the caveats.

We believe, that especially in experiences with a lot of people enjoying it at the same time. In a separate voice-chat application, you need to manage channels, people need to be in the right channels, they should be muted when not talking, etc. With ODIN, you don’t need to worry about any of that. You just join a room, and you can literally talk to anyone by just coming close. You can build separate spaces using our audio occlusion system to make sure they can have one-on-one meetings that are private. Of course, you don’t need to use the 3D spatial audio. You can also use radio like voice chat, where you can talk to everyone in the room at the same time always in full volume and without occlusion. It’s up to you, but that 3D spatial audio system sometimes needs some explanation, like I did in the last paragraphs. The video should just show that without many words.

Preparing the video

When creating a video, it’s always important to have a good idea of the goal. In this case, we had these goals:

Visualize audio volume fall-off (i.e. full volume close and silent “far” away)
Visualizing the nature of voice
Visualize audio occlusion
Make users hear the voice of the person simulated in the video

We came up with this idea to achieve these goals:

We have a simple scene in a Tron-style like look & feel
Our player (i.e. the player that “simulates” the viewer of the video) is located at the bottom center of the screen.
Another player is running around and talking at the same time
A few cubes are distributed around our scene acting as walls dampening the sound if between the player and the listener.
We try to visualize the audio and audio effects

We quickly decided to build the video in Unity as it gives as the possibility to provide an interactive demo via WebGL, and we don’t need to fake audio occlusion by putting tons of audio volume key frames in a video editor like Final Cut of Adobe Premiere. Instead, we just fired up Unity and our ODIN Unity SDK and just recorded a real-time editor session using the Unity Recorder. You can experience the demo in real-time by downloading the source-code from Github.

We also used our Audio Occlusion system that is part of our Unity demo . This will be bundled in the next version together with the Unity SDK. I had to copy a few files from the demo into my own project to make Audio Occlusion work. We attached the OcclusionAudioListener script to the listener player at the bottom of the screen and attached AudioObstacle script to the cubes with various different AudioEffectDefition assets like concrete, and fully silence.

As we wanted to create a self-running demo that we could record we used the character of Unitys Third Party Controller demo and created a simple waypoint system feeding the direction to the next waypoint as “joystick” inputs. The waypoints have a small box collider as trigger. Whenever our character gets triggered we select the next waypoint and navigate to that.

Info

One important thing to remember. In Unity you have the Audio Listener component that is typically attached to the main camera. In our scene, the main camera is located way above our third person character. So, we need to attach the Audio Listener to the player standing in the bottom center of the screen as he should be listening to the voice in the scene, not the camera.

Visualizing audio volume fall-off

One of the key principles of 3D audio is that there is a relation between the distance and the volume, i.e. if you are far away from the audio source you here it less loud. Unity has a “fall-off” setting that you lets you adjust in detail how this works. Here is an image of the settings of the Audio Source:

What that means is, that if you are close the audio source plays with full volume, linearly decreases to 0% volume in 5 units. It’s basically the same as a point light that attenuates over distance until it has no effect.

To do that, we created these game objects within Unity:

Player (center of the player)
- Plane (with our audio visualization shader and materials)

We also created a transparent Shader Graph shader and a material. The new shader and material will be used to visualize the audio volume of the simulated player, and it’s attached to the plane.

The plane has a standard scale of 1,1,1 and therefore is 10 units long and 10 units wide and thus extends 5 units from center. As you may have noticed, we set the audio falloff to 5 units, so that’s a good fit. Our plane is large enough to visualize the audio volume fall-off.

This is the simple Shader Graph for this shader and what it looks like:

The shader is very simple. It just takes the distance from the center of the plane and maps it to a color. What we do here is taking the point in object space. We can do that, as the plane is not scaled, and we don’t plan to rotate it. However, of course you could also take the sample point in world space and subtract it from the planes center. This would make things more complicated and for our needs that works great. Once we have the distance to the planes center which is the radius of the audio circle we can multiply it through the radius - which we provide via material variable radius which we set to 5 to be corresponding with the planes width and the fall-off settings of the Audio Source. Calculating the On Minus of that value we have a nice alpha value which is 1.0 in the center of the plane and linearly falls-off to 0.0 at the radius of the audio circle which is also the outer edge of the plane.

Visualizing the nature of voice

Still a little boring. We want to make sure that users watching the video immediately get the idea of the video, showing audio waves and not a nice implementation of a point light or a “fog of war”. I wanted to simulate audio waves moving like waves from the center of the circle to the outside. First, I experimented with a sinus wave and a time variable. That did look quite ok, but it has been missing the dynamics of voice which has ups and downs infrequently as shown in this waveform of a piece of voice saying something:

As you notice, the waveform looks a lot like a mirrored heightmap and this is exactly what we need. What we do is this:

Sample audio in real-time and create a heightmap of the audio. Loud pieces will be white, while silent pieces will be black.
Feed that shader into the shader to visualize the audio ripples.

How do we do that:

Create a texture of 128x1 and make it writable.
Create an array of floats of size 128 that will hold the heightmap (you’ll see later why)
Every few frames
- move the texture by one pixel to the right - this will create the impression of waves moving to the outside
- sample the current audio loundness in the range of 0.0 to 1.0 and write it to the texture at position 0,0

So, why creating an array of floats which is duplicate of what we already have in the texture? The reason is simple: Because as we want to move the pixels by one in the memory it would require us to read from the texture and moving this array by one, writing it back. I thought that reading from textures is slow, reading from memory is fast. So we build the texture in memory and just write the pixels to the texture.

Info

I also experienced with changing UVs on the texture rather that moving pixels. While this is getting a bit smoother animations, in the end it’s more complicated especially at the texture bounds that I rather concentrated on getting the video done rather than optimizing the shader. Perhaps that is good exercise for you.

Here are a few snippets:

AudioVisualizer script

public class AudioVisualizer : MonoBehaviour
{
public AudioVisualizerPlane plane;
public AudioVisualizerRenderOcclusion occlusionRenderer;
public bool sampleAudio = true;
public float loudnessScale = 10.0f;
public int sampleDataLength = 100;
public AudioSource audioSource;
public Transform followObject;
public Texture2D voiceTexture;
private Color[] loundness = new Color[128];
private float nextUpdate = 1.0f;
private float[] clipSampleData;
private void Awake()
{
if (!voiceTexture)
{
voiceTexture = new Texture2D(128, 1, TextureFormat.RGB24, false);
}
for (var i = 0; i < 128; i++)
{
loundness[i] = Color.black;
}
if (!audioSource)
{
audioSource = GetComponent<AudioSource>();
if (!audioSource)
{
Debug.LogError("Voice Texture needs to have an AudioSource assigned or must be part of the Component");
}
}
clipSampleData = new float[sampleDataLength];
}
private void Start()
{
if (!plane)
{
plane = GetComponentInChildren<AudioVisualizerPlane>();
if (!plane)
{
Debug.LogError("You need to create a plane as children and assign the AudioVisualizerPlane component to it");
}
if (sampleAudio)
{
var renderer = plane.GetComponent<Renderer>();
renderer.material.SetTexture("_RippleTexture", voiceTexture);
}
}
UpdateTexture();
}
private void UpdateTexture()
{
voiceTexture.SetPixels(0, 0, voiceTexture.width, 1, loundness);
voiceTexture.Apply();
}
private void Update()
{
if (followObject)
{
transform.position = followObject.transform.position;
}
if (!sampleAudio) return;
//if (Math.Truncate(Time.time) % 500 != 0) return;
if(Time.time>=nextUpdate){
//Debug.Log(Time.time+">="+nextUpdate);
// Change the next update (current second+1)
nextUpdate=Time.time+0.025f;
// Call your fonction
SampleAudio();
}
}
private void SampleAudio()
{
// Move audio out
for (var i = 127; i >= 1; i--)
{
loundness[i] = loundness[i-1];
}
var loudness = SampleLoudness() * loudnessScale;
//float loudness = Random.Range(0.0f, 1.0f);
loundness[0] = new Color(loudness,loudness, loudness);
UpdateTexture();
}
private float SampleLoudness()
{
audioSource.clip.GetData(clipSampleData, audioSource.timeSamples); //I read 1024 samples, which is about 80 ms on a 44khz stereo clip, beginning at the current sample position of the clip.
var clipLoudness = 0f;
foreach (var sample in clipSampleData) {
clipLoudness += Mathf.Abs(sample);
}
clipLoudness /= sampleDataLength; //clipLoudness is what you are looking for
return clipLoudness;
}
}

Sampling audio gives you quite small float values. I used a scale of 10.0f to make it more visible. As we create the average audio volume of all samples we need to make sure that the number of samples is too large as the whole thing blurs too much. A good value for this visualizing has been 100 samples.

This is what the texture looks like:

Looks great, doesn’t it? And the ripples move from left to right. We feed it into our shader. Back in Shader Graph we need to make use of that texture:

We already have a value from 0.0 to 1.0 indicating the radius ratio from the center to the outside, meaning that we are close to the center at 0.0 and close to the outside at 1.0.
Remember that ripple texture with the hightmap moving from left to write. Well, our radius ratio is the x coordinate of the texture.
So, this is basically the u of the texture sample vector. We just feed that value in the texture sampler and multiple that value (which is from 0.0 to 1.0) with a color of the ripples.
We put that value in the emission slot of our fragment shader

That’s it. Looks great, doesn’t it:

Visualizing audio occlusion

We have a pretty cool video already with a player running around a scene, and you can hear the direction of the other player and when a cube is between both players that audio is silent or less loud. And we have a nice circular plane visualizing audio ripples and fall-off. But, we also wanted to visualize audio occlusion. What that means is, that we want an “audio-shadow” to be casted by the cubes.

I try to explain my solution to that in this ugly, little scribble:

This scribble shows our player position in the center of the plane and the audio occluders (which are cubes) around it. In orange is our audio circle around the center of the plane. However, there are areas of that circle that are red, which lie in the shadow of the audio occluders. Audio will not get to this point, because they are blocked by the occluders. The green dots and lines show places where audio can travel to, the have direct line of sight to the center of the plane. The purple dots haven’t got a direct line of sight, as the center of the plance is blocked by the occluders.

How do we know if an occluder is blocking the audio at a specific location on our plane and within our shader? The solution I came up with is a custom 360° depth buffer around the center of our plane holding the distance to occluders. In our shader we can sample that depth buffer and check if the distance to the occluder is smaller than the distance of our point on the plane. If that is the case, we know that the occluder is blocking the audio at that point and don’t render anything. If not, we can render our audio circle with the fall-off and audio ripples as we did before.

Creating the distance buffer

As discussed before, we need to have a 360° depth buffer with the distance between the occluder and the center of the plane. We can use Unitys APIs to render a camera into a cubemap, which will give us exactly what we want, as we can sample that cubemap very easily in our shader. Of course, we only got 50% of what we need, as a normal rendering of the scene will not help us. First, we put a camera as a child to our Player game object. Our hierarchy will look like this:

Player (center of the player)
- Occlusion Camera
- Plane (with our audio visualization shader and materials)

We create a new script and attach it to our occlusion camera:

AudioVisualizer script

public class AudioVisualizerRenderOcclusion : MonoBehaviour
{
// Attach this script to an object that uses a Reflective shader.
// Real-time reflective cubemaps!
bool oneFacePerFrame = false;
Camera cam;
public RenderTexture cubemap;
public int textureSize = 128;
private void Awake()
{
cam = GetComponent<Camera>();
if (!cubemap)
{
cubemap = new RenderTexture(textureSize, textureSize, GraphicsFormat.R32_SFloat, GraphicsFormat.D32_SFloat_S8_UInt);
cubemap.dimension = TextureDimension.Cube;
}
}
void Start()
{
// render all six faces at startup
UpdateCubemap(63);
}
void LateUpdate()
{
if (oneFacePerFrame)
{
var faceToRender = Time.frameCount % 6;
var faceMask = 1 << faceToRender;
UpdateCubemap(faceMask);
}
else
{
UpdateCubemap((int)CubemapFace.PositiveX | (int)CubemapFace.NegativeX | (int)CubemapFace.PositiveZ | (int)CubemapFace.NegativeZ); // all six faces
}
}
void UpdateCubemap(int faceMask)
{
//if (!cubemap) return;
cam.RenderToCubemap(cubemap, 51);
}
}

We create a new RenderTexture and set it to a cubemap. We set the format to R32_SFloat as one float channel for the distance data is enough. Every frame we either render all faces or only one frame per frame to save performance. Depending on how fast the player moves that might be working fine.

However, this will just render the scene as usual. I did not find an API to sample the depth buffer of the Cubemap in shader graph and even if I could do that, there is a difference between the depth in the depth buffer and the distance of the point to the camera center. In fact, it took me a while to figure that out. First, I sampled the depth of the depth buffer at the point. This however resulted in strangely curved shadows. The reason for that is quite complicated, but in the Unity forum bgolus always show this image which shows that very good and that has been very helpful for me:

You know, in our shader we already have a calculation that calculates the distance of the point on our current fragment to the center of the plane. By just feeding that value in our comparison to the depth buffer got me these strange curves that you can see above in the image. That is, because you are comparing apples with pears.

So, what we need is either complicated maths in our shader to calculate the depth buffer to the distance, or creating a customized renderer for our occlusion camera. I went for the second option, as it was easier for me and to be honest, after hours of building huge shader graphs with a lot of maths and custom functions I couldn’t figure it out!

But, I didn’t need to:

As the plane and the occlusion camera will not be rotated or scaled and also not being transformed (as only the player parent object will be translated) we can just work in “object space”, which makes things a lot easier.
So, we don’t need all those transforms and matrix stuff, both pixel spaces will be the same for the occlusion camera and the plane.

I started the project as a Universal Render Pipeline, so I can quickly create my own renderer for the occlusion camera even without writing much code.

I finally came up with this solution:

Create a new Shader Graph for the occlusion camera
Create a new Render Pipeline and render the scene with that shader (I think you could do the same without URP by setting the shader for the camera in script) in the occlusion camera
The shader does not write the depth but the actual distance between the center of plane and the point on the plane, corresponding to the way we do it in the plane shader - this way we compare apple to apples!

So, I created a new renderer asset and set that as the renderer of our occlusion camera. I also created a new Layer Audio Occluder and made the camera to only render audio occluders.

Next, we have to create our “Depth Shader” in Shader Graph. It looks like this:

As you can see, it’s super simple. As in our shader before, we just calculate the distance between the center of the plane and the point on the plane. However, we need to map that value to the range of 0 to 1, so we need to divide by the radius. It’ll be 5 as we set that in our shader before. In this case, we don’t put in a shader variable but we just set the far plane of the camera to 5 and use that value in the depth shader. Setting the far value of the camera made also sense because we don’t need to render the whole scene, just what is in our radius.

Then, we feed that shader in our Render Depth pipeline like this:

So, what this does, is overriding all materials in the scene with our depth shader and rendering the audio occluders into our cubemap.

The cubemap looks like that:

The top and bottom is black, because we don’t render them. In our script we had this line:

cam.RenderToCubemap(cubemap, 51);

51 is the bitflag for front, back, left and right. The typical value you see in the Unity documentation and many examples is 63 which is the bitflag for all six sides. But we only render into a plane, so we don’t care about top and bottom.

Using the distance buffer

Now that we have our distance buffer indicating the distance of all occluders 360° around the center of the plane we need to do something with it. In fact that’s pretty easy. We just sample the point on the plane and on the cubemap and figure out if the point is occluded or not. If it is, we just set the alpha value to 0. If not, we set it to our usual 0.0 to 1.0 distance range that we use to calculate fall-off and ripple intensity. Here is the relevant part of the shader:

Pretty simple, right? We can just use the position of the fragment in object space and feed that as the view direction into our cubemap. Please note, this only works, because we never rotate or scale the plane and the camera.

This is the complete shader. I added normals based on the ripples and a few other things like a base color, highlight color for the ripples and also a base opacity if you want to show the whole radius.

If we use this shader, we get what we wanted, a nice looking circle with audio ripples falling-off to the edges of our audio falloff settings and with “audio shadows” generated by the occluders.

Conclusion

It’s been a lot of fun figuring out all of that. And I think the results are great. If you have any comments or additional info on how to improve that, please tweet me at @ursuppe .

When I created that, I thought that it’s also worth taking into consideration not only for audio occlusion system, but you can also create nice effects. Like spherical explosions that don’t run through buildings but stop behind buildings. A texture map with occlusion could also mask damages to the scene behind buildings, so you would only render the “fire” material only where the explosion could be exposed and not being blocked by buildings. This is why I wrote that blog post. Perhaps it’s inspiration for many other use cases.

Universal Rendering Pipeline in Unity is great for these kind of things. It’s easy to create your own renderers can do a lot more than in the built-in render pipeline.

Last but not least I want to link a few resources that have been very useful for me:

Creating technology based on players’ motivations: why in-game communication?

Fri, 16 Dec 2022 00:00:00 +0000

We all love games, no matter what shape or size they come in. ‘Playing’ is a key component of life, and helps break up mundane activities. We have discussed this aspect in our blog before, but today we will focus on multiplayer gamers - their motivations, how they communicate, and how this drives us to do what we do.

There are roughly 3.2 billion gamers across the globe . When looking at a more precise breakdown, there are around 1.47 billion gamers in Asia. This includes 419 million in Latin America, 284 million in North America and approximately 716 million across Europe.

More than half of the global population plays games (52%), and 77% of them play multiplayer.

With the increased popularity of multiplayer games, it is imperative to analyse the advantages of choosing this modality and the player behaviours they encourage. It is clear that the first and most significant motivation for multiplayer gamers is having a positive games experience together. The social aspect and interactions during multiplayer gaming, where players can help each other and interact, became clearer than ever during the pandemic. This beats the idea that games can cause alienation from society. These social connections are key to team building, boosting competition and strategic thinking, self-reliance, and working as a group.

Another critical factor is the improvement of attention skills. Players need to concentrate deeply in multiplayer gaming - not just on themselves, but on their surroundings and the positioning of their enemies. This is needed in order to always remain one step ahead and achieve success.

The importance of communication in multiplayer gaming

All these things make it clear that the ability to communicate during multiplayer games is of the utmost importance. This is not only for smooth playability but also for the full enjoyment of the player experience. Nothing is more disruptive than being unable to communicate during a multiplayer game session. In a match between two teams with equal skills and equipment, the team with better communication skills and tools will always win.

Players will constantly use in-game and external communications to discuss tactics and strategies to achieve the most optimal gameplay experience. If the in-game voice and text chat is faulty, disruptive and/or inefficient, players will immediately turn to external tools to solve these issues. In some extreme cases, they might even leave the game altogether if the frustration level becomes too high. Therefore, it is critical to choose the right chat tool when developing your multiplayer game.

What part have we played?

When developing ODIN, some of the key focal points we had in mind were:

We wanted to create game communication that was the closest to life-like as possible. As players ourselves, we were fully aware of the importance of a fully immersive experience. This is because we wanted players to feel like they were part of the game. It always disturbed us that we weren’t able to quickly direct our teammates when they were communicating with us in the game. So we created ODIN as a solution to this.

We wanted to make it as fast and simple as possible for developers to offer the most effective in-game communication in their multiplayer games. There are many enjoyable games out there that would be even better if they could take full advantage of in-game chat. Sometimes, especially when dealing with a lack of resources, the cost of implementing this feature and maintaining it becomes too much for the developer. As a result of this, their players suffer, as they can’t fully enjoy the experience. With advances in technology, that should not be an issue.

We also made sure that everything was cross-platform, using the same code and with high performance. This is so the developers can work in peace and the players can enjoy it everywhere.

At 4Players we always keep players’ safety and data protection in mind. Players care about this and so do we - so we make sure our tool doesn’t require any personal data to work properly, making it safe for both developers and the community.

As game developers must have heard a million times, it’s all about the players - the audience. For us, the motivation is the same. It’s all about the players, allowing them to fully connect and immerse themselves, without disruptions. In 2023, we aim to take it even further.

Introducing ODIN Server for On-Premise Hosting

Fri, 09 Dec 2022 00:00:00 +0000

At 4Players, we understand that different businesses have different hosting needs. That’s why we are excited to announce that we now offer on-premise hosting packages for ODIN customers.

Traditionally, the ODIN server software has been available as a cloud-based solution, allowing users to access it from anywhere with an Internet connection. While this has worked well for many of our customers, we understand that there are certain situations where an on-premise solution might be preferred.

That’s why we have developed on-premise hosting packages for our server software, which allows you to have both the ODIN server and gateway installed and run directly on your own hardware, with the added support and expertise of our team. All ODIN on-premise hosting packages offer the same features and functionality as our cloud-based solution, but with the added benefits of increased control and security. You can have complete control over your server infrastructure, and can ensure that your data is kept secure within your own network.

On-Premise Hosting Documentation

Downloads for the on-premise version of the ODIN server software are now available right within our customer control panel . This makes it easy to access the software and get it up and running within your own infrastructure. You can also generate configuration snippets for both the ODIN server and gateway based on your individual access key.

Generate Configuration for On-Premise Servers

We believe that these on-premise hosting packages will be particularly useful for developers who have strict compliance requirements, or who simply prefer to have their data stored on-site. It is also a great option for customers who want to be able to customize their server setup to meet their specific needs, but don’t have the in-house expertise to do so.

We are confident that these on-premise hosting packages will be a valuable addition to our server software offerings, and we hope that they will be a useful tool for our customers. If you have any questions about this new release and specifically our new pricing model, don’t hesitate to reach out to our sales team .

We are always happy to help!

ODIN Version 1.3.0 is Available

Fri, 11 Nov 2022 00:00:00 +0000

We’ve just published version 1.3.0 of the ODIN SDK. We have some exciting updates to share with you.

First and foremost, we have added support for Windows on ARM. This means that users of these devices can now take advantage of all the features and functionality ODIN has to offer. We have also refactored our internal jitter buffer for improved reliability. This helps to smooth out any variations in the arrival time of audio packets, ensuring that audio playback is as smooth as possible. This update should result in even more reliable audio processing for all users.

The new builds are available on GitHub .

Download Version 1.3.0

In terms of API changes, we have updated the OdinAudioStreamStats struct to better reflect the data it contains. We have renamed several fields and added several new ones, so be sure to check out the changelog for all the details. We have also removed the odin_audio_data_len function. In addition to these updates, we have made a number of bugfixes and improvements, which should result in a more reliable high-quality audio processing experience for all our users. We hope you enjoy these updates and as always, don’t hesitate to reach out if you have any questions or feedback.

Updates to both our Unity and Unreal Engine plugins will be available within a few days.

Here’s the full changelog for this update:

New Features

Added support for Windows on ARM
Refactored internal jitter buffer for improved overall reliability

API Changes

Updated OdinAudioStreamStats struct
- Renamed jitter_packets_processed to packets_processed
- Renamed jitter_packets_dropped_too_early to packets_arrived_too_early
- Renamed jitter_packets_dropped_too_late to packets_arrived_too_late
- Renamed jitter_packets_lost to packets_lost
- Added packets_total
- Added packets_invalid
- Added packets_repeated
Removed odin_audio_data_len

Bugfixes / Improvements

Enabled FEC feature for Opus encoder/decoder
Switched Opus encoder application mode from Audio to VoIP when working with single channel streams
Fixed initial values for time and sequence number in audio datagrams
Fixed a bug where malformed audio datagrams could lead to delayed audio playbck

ODIN Version 1.2.0 is Available

Sun, 16 Oct 2022 00:00:00 +0000

We’ve just published version 1.2.0 of the ODIN SDK. With this release, we’re focussing on stability and performance improvements. Once again, thank you for all of the amazing feedback! Due to the close collaboration with you - the developers - we’re able to constantly improve our services and make ODIN even better.

The new builds are available on GitHub .

Download Version 1.2.0

In terms of stability, we’ve refactored our internal reconnect mechanism, which will now re-establish connections in a faster, more effective way. In addition, we’ve fixed a rare but nasty bug where an ODIN room handle could become unresponsive in case of a connection timeout.

Also, we’ve added the user identifier of the local peer to the Joined event. Since tokens should be generated on a server, previous releases forced you to look in the JWT claims to get that information, so this change should make the whole authentication process more convenient and straight forward.

Updates to both our Unity and Unreal Engine plugins will be released later this week.

Here’s the full changelog for this update:

General

Updated test console client

API Changes

Added OdinRoomConnectionState_Disconnecting
Added own_user_id and own_user_id_len to OdinEvent_JoinedData

Bugfixes / Improvements

Improved internal shutdown process to prevent media handles from being removed too soon
Fixed an issue where a room handle could become unresponsive after a timeout

ODIN Version 1.1.1 is Available

Tue, 27 Sep 2022 00:00:00 +0000

Happy release Tuesday! 🎉

The 4Players ODIN development team is please to announce the immediate availability of ODIN version 1.1.1. This release focuses on addressing your feedback as well as bug reports and feature requests.

You can see the full changelog for more details:

General

Updated test console client

New Features

Added gain controller to bring the input audio signal to an appropriate range when it’s either too loud or too quiet

API Changes

Added gain_controller boolean to OdinApmConfig struct
Updated odin_error_format to make error messages more specific
Updated odin_room_update_user_data to return an error when trying to set user data of the room while not being connected

Bugfixes / Improvements

Fixed a bug where peer user data was not set after re-connecting to a room
Fixed a bug where peer position was not set correctly before joining a room
Fixed an issue where iOS clients were unable to access local root certificates

4Players Releases SwiftUI Sample App

Mon, 12 Sep 2022 00:00:00 +0000

After releasing our OdinKit Swift package for iOS and macOS, we now pushed the code for a very basic SwiftUI sample application to GitHub .

The app is built around OdinKit and implements all APIs required to provide real-time voice communication for your users. It also shows how to use an OdinRoom instance to synchronize data between all users in the room.

Learn more about the sample and how to get started in our example description:

Get Started with Swift

4Players Releases ODIN Swift Package

Sun, 04 Sep 2022 00:00:00 +0000

Now that our team is on a release spree, here you have OdinKit - a Swift package providing an object-oriented wrapper for the ODIN native client library, which enables developers to integrate real-time VoIP chat technology and real-time data synchronization into multiplayer games and apps on macOS and iOS.

With OdinKit, we’re not only following Apples naming convention for APIs. We’re also shipping an XCFramework, which is a distributable binary package created by Xcode that contains variants of the ODIN client library so that it can be used on multiple platforms. Currently, we provide support for both Intel and Apple Silicon based Macs as well as iOS devices.

The package is open-source and available on GitHub .

Swift Playground

The project contains a macOS playground to demonstrate how to use OdinKit in your your apps, but the same code will also work on iOS and iPadOS.

Getting Started

After adding the package to your project, import OdinKit into your application:

import OdinKit

In ODIN, every user connected to the same room can exchange voice and data. You can also join multiple rooms at once, for example one lobby but additional private chats or another room only used for text messaging. So, we create a room instance like this:

let room = OdinRoom()

Handling events

ODIN will notify you of important events like a new user joining the room or a user leaving the room. You can handle these events to build your business logic on top of it. In Swift, we use the delegation pattern to handle these events.

So, we create a class implementing the OdinRoomDelegate protocol:

// Define a class handing events
class YourCustomDelegate: OdinRoomDelegate {
// Callback for internal room connectivity state changes
func onRoomConnectionStateChanged(room: OdinRoom, oldState: OdinRoomConnectionState, newState: OdinRoomConnectionState, reason: OdinRoomConnectionStateChangeReason) {
print("Connection status changed from \(oldState.rawValue) to \(newState.rawValue)")
}
// Callback for when a room was joined and the initial state is fully available
func onRoomJoined(room: OdinRoom) {
print("Room joined successfully as peer \(room.ownPeer.id)")
}
// Callback for room user data changes
func onRoomUserDataChanged(room: OdinRoom) {
print("Global room user data changed to: \(room.userData)")
}
// Callback for peers joining the room
func onPeerJoined(room: OdinRoom, peer: OdinPeer) {
print("Peer \(peer.id) joined the room with ID '\(peer.userId)'")
}
// Callback for peer user data changes
func onPeerUserDataChanged(room: OdinRoom, peer: OdinPeer) {
print("Peer \(peer.id) updated its user data to: \(peer.userData)")
}
// Callback for peers leaving the room
func onPeerLeft(room: OdinRoom, peer: OdinPeer) {
print("Peer \(peer.id) left the room")
}
// Callback for medias being added to the room
func onMediaAdded(room: OdinRoom, peer: OdinPeer, media: OdinMedia) {
print("Peer \(peer.id) added media \(media.id) to the room")
}
// Callback for media activity state changes
func onMediaActiveStateChanged(room: OdinRoom, peer: OdinPeer, media: OdinMedia) {
print("Peer \(peer.id) \(media.activityStatus ? "started" : "stopped") talking on media \(media.id)")
}
// Callback for medias being removed from the room
func onMediaRemoved(room: OdinRoom, peer: OdinPeer, media: OdinMedia) {
print("Peer \(peer.id) removed media \(media.id) from the room")
}
// Callback for incoming arbitrary data messages
func onMessageReceived(room: OdinRoom, senderId: UInt64, data: [UInt8]) {
print("Peer \(senderId) sent a message with arbitrary data: \(data)")
}
}

Next, we assign that delegate to our room instance:

// Create an instance of your delegate
let delegate = YourCustomDelegate()
// Add the delegate to the room
room.delegate = delegate

We also provide a set of published properties for typical use cases so you don’t have to handle these events yourself. This is ideal if you’re using SwiftUI, as your views will notice any changes automatically.

struct RootView: View {
@EnvironmentObject var room: OdinRoom
var body: some View {
switch room.connectionStatus.state {
case OdinRoomConnectionState_Connected:
RoomView()
default:
LoginView()
}
}
}

Joining a Room

That’s it for event handling. We are now ready to join a room. For this, we need to an authentication token. ODIN generates signed JSON Web Tokens (JWT ) for secure authentication, which contain the room you want to join as well as a freely definable identifier for the user (e.g. a player ID or a user ID from your database).

// Create a new local access key
let accessKey = try OdinAccessKey("__YOUR_ACCESS_KEY__")
// Generate a token to authenticate with
let authToken = try accessKey.generateToken(roomId: "Meeting Room", userId: "Swift is great!")

The roomId is just a string and uniquely identifies the room within your access key domain. Every user connected to the same room will be able to communicate with each other. The userId is a string that can be used to refer to an existing record in your particular service.

Info

Privacy and security is very important to us. All the data transferred over our servers is fully encrypted. Also, ODIN is completely user agnostic and we don’t harvest any data or tell our customers how things should work or look.

For your own security, we strongly recommend that you NEVER put an access key in your client-side code. We’ve created a very basic Node.js server , to showcase how to issue ODIN tokens to your client apps without exposing your access key.

We provide both PHP and NPM packages to make the process of generating tokens as easy as possible for you.

Generate an Access Key for FREE

Now that we have created our access token (which you should do on server side if possible) we can join the room and add a media stream using your default audio input device:

// Now that we have a token, join the room
try room.join(token: authToken)
// Append a local audio stream to capture our microphone
let newMediaId = try room.addMedia(audioConfig: OdinAudioStreamConfig(
sample_rate: 48000,
channel_count: 1
))

Warning

As OdinKit will request access to your microphone you need to set a special key in your Info.plist file. Add a key called NSMicrophoneUsageDescription (Privacy - Microphone usage description) and set a text that describes why your app wants to have microphone access. Otherwise your app won’t be able to capture audio samples from your input device.

That’s it! Congratulations! You have added real-time voice communication to your app!

What’s Next

There are many things you can do with ODIN. You could add sending text chat so that users can share links and additional data:

// Encode a string so we can send it as a message
let yourMessage = OdinCustomData.encode("So Long, and Thanks for All the Fish")
// Send the message everyone else in the room
try room.sendMessage(data: yourMessage)

Sample App

Download our sample to get started quickly and learn how to use the APIs:

Show SwiftUI Sample

Documentation

We have extensive documentation and a reference of all available classes and APIs provided by OdinKit.

Open OdinKit Documentation

Announcing ODIN Networking

Sun, 04 Sep 2022 00:00:00 +0000

Today we are releasing what we have been working on for a couple of months now: ODIN Networking. Unity until today lacks a good and easy stack to build multiplayer games and applications. The old Unity Networking has been deprecated years ago and the follow-up solution is still not ready and seems to be quite complicated. So we used Photon or Mirror Networking to build multiplayer examples.

So, we went out to solve that, and we came up with ODIN Networking. This is our first public iteration, and although there is a lot of work to be done, we are quite confident that we can contribute and help developers to more easily build multiplayer applications of any scale.

What is ODIN Networking?

ODIN Networking is built on top of the ODIN Unity SDK and provides easy to use methods to built virtual experiences with ease that allow you to connect users with virtual characters and real-time 3D voice. A 3D virtual conferencing application can be built in no time, as ODIN Networking provides components that automatically synchronize position, animation of all characters over the ODIN servers.

Users can spawn objects in the world and can interact with the provided world in real-time. ODIN Networking also integrates ODIN Audio so your virtual world will automatically integrate audio occlusion (users cannot hear each other if walls are in between) and even direction.

One important aspect: While ODIN Networking is a powerful and easy to use system, it’s mainly targeted for real-world like applications for the metaverse, board games, virtual conferences and conventions. If you want to build a fast competitive first person shooter or real-time physics racing game ODIN Network might not be the best solution. Choose other solutions like Mirror Networking or Photon for that use case. You should still use ODIN for voice support, and we have many guides on how to integrate ODIN into Mirror or Photon.

How does it work?

The ODIN SDK supports sending arbitrary data over the network and this data is automatically synced with all peers connected to the same room. Each user can have its own data (PeerUserData), each room can have its own data (RoomUserData) and each peer can send messages with arbitrary data to all or selected peers.

ODIN Networking packages the current state of a player into the players PeerUserData. It includes the transform (position, location and scale), the animation state and sync vars that allow you to easily mark local variables to be packaged into the state. This updated state is sent multiple times per second (right now every 10th of a second) to other peers that recreate that state in their own world. If a peer is moving, every peer in the network gets an update 10 times a second and updates (tweens) the position locally for that peer.

Every player can also spawn objects into the world. The state of these objects are added to the PeerUserData and are thus updated as well. If a peer spawns an object, all other peers will get an update and spawn the object locally and subsequently update its position as part of the network update cycle.

Of course, players should be part of a living world, so how do you handle objects that are “owned” by the world you might ask? It’s easy. With a deterministic algorithm, all peers in the same room select the same peer to be the host. This is done dynamically, so if the host disconnects a new peer might become host. The host owns the worlds objects and updates the worls state as well as its own state in the RoomUserData. This way, peers entering later will become the same state of the world as every one else, and it’s kept persisted even if the current host disconnects, as every peer in the network has a copy of that world. This way, every peer can instantly become the host.

As it’s decentralized you don’t need to worry about a central server that might go down, and you also don’t need to have all that typical development cycle of sending messages to a server that updates the world and sends the results back as remote procedure calls, which make the whole development process extremely complicated. Now you might understand, why we don’t think ODIN Networking is good for competitive games, as its not easy to build a reliable anti-cheat system into this kind of architecture. We might explore that later, but right now we concentrate on building metaverse applications and all those games that don’t want to be the next eSports hit.

But, ODIN Networking, and the ODIN Unity SDK are open-source. We are happy to merge your contributions!

How do I get started?

All you have to do is to derive your “Player” script (i.e. that script that controls your local player object) from OdinPlayer instead of MonoBehaviour. Distribute at least one OdinNetworkSpawnPosition game object in the scene. Next, join a room, and you are ready to go! Build your application and send it a friend. Once you guys start the application, each user will spawn its own player at one of the spawn positions, and you can see the other players running around, seeing the characters animation, and you can talk to each other in 3D audio - i.e. the voice will come from the direction you see the other player and volume will be adjusted depending on the distance and direction.

How much does it cost?

As ODIN Networking uses the ODIN stack under the hood, the same pricing applies. So no extra costs if you use ODIN Networking!.

Interested?

We released ODIN Networking as a Unity project today. You can download it, fire up Unity and click Play to see it and to examine the source code. In the next couple of weeks we’ll be doing some tests and will then integrate the project into the ODIN Unity SDK.

Download ODIN Networking SDK

ODIN Unity SDK updated to v1.1

Thu, 01 Sep 2022 00:00:00 +0000

ODIN Unity SDK 1.1.0 was released on September 1st 2022. You’ll find the latest version of the SDK in our Github repository .

General

Core SDK has been updated to version 1.0.1 (details )
Added options to adjust microphone input volume
URL to 4Players admin panel has been updated

API Changes

Added MicrophoneReader.GetVolumeScale
Added MicrophoneReader.GetAveragedVolume
Added MicrophoneReader.SetVolume
Renamed MediaStream.IsMuted to MediaStream.IsPaused

Bugfixes / Improvements

Fixed an issue where the activity state of the local media stream was not updated

Get Started with Unity today

Voice-Chat SDK ODIN in Unreal Marketplace

Wed, 31 Aug 2022 00:00:00 +0000

ODIN is now available in the Unreal Marketplace . Head over to download and install the SDK for free.

You can download, install and use the SDK for free for up to 25 concurrent users by either generating a free access key in our developer documentation or directly in the Unreal Editor using a simple blueprint.

We must thank the Unreal Marketplace team that were super fast in responding and did an amazing job of getting our SDK in record time into their Marketplace.

Download in Unreal Engine Marketplace

Using the plugin

The source-code of the plugin is freely available in our Github repository and we have created a guide to get your started quickly.

Unreal Engine Manual

We also have created an extensive Blueprint Reference Documentation that describes every node that ODIN offers in great detail and provides complete Blueprints for you to Copy & Paste into your existing project.

Unreal Engine Blueprint Reference

We can’t wait to see what you are developing with ODIN on the amazing Unreal Engine. Please contact sales if you need additional information on pricing and get in touch with our Customer Success Team if you want to be part of our “Showcase”.

ODIN Core SDK updated to v1.0.1

Wed, 10 Aug 2022 00:00:00 +0000

Today we released version 1.0.1 of the Core SDK .

Bugfixes / Improvements

Fixed an issue with conflicting symbols for Unreal Engine builds

ODIN Unreal Engine SDK Is Available

Wed, 27 Jul 2022 00:00:00 +0000

We are thrilled to announce that we released our ODIN Unreal Engine SDK completing support for all major public game engines used in production today.

You can download the latest release right here:

https://github.com/4Players/odin-sdk-unreal/releases

With ODIN, you can add support for real-time voice chat embedded directly into your game supporting 3D spatial audio. You can even join multiple rooms at once, combining 3D spatial voice chat with radio type voice chat.

That is all you have to do to add ODIN to your game. Hover over the image, click the Copy button and paste it into your Level Blueprint. Set your own Access Key in the Access Key variable and press Play.

The blueprint that we’ll create

Check out our Unreal Engine SDK for more details and work through our getting started guide. You can copy generate an access key for free without signing up. Copy Blueprints directly in your game and you’ll be up and running in a couple of minutes!

Get Started with Unreal today

ODIN Unity SDK Is Available

Fri, 08 Jul 2022 00:00:00 +0000

A few days after launching our Core SDK to production , we also launch version 1.0 of our Unity SDK . Its battle-tested, stable and super easy to integrate into new or existing games.

In contrast to relying on external apps, integrating comms right into the game allows creating unique, ultra-realistic and immersive gaming experiences. Using features like spatial audio and custom filters, there are no limits to creativity. Plus, there is absolutely no interference with existing technology you might use.

We have guides for adding it to Photon based games or games built with Mirror Networking .

Download our Unity SDK today and give it a shot! You’ll not regret it.

https://github.com/4Players/odin-sdk-unity/releases

Here’s a full list of changes and improvements:

General

Core SDK has been updated to version 1.0.0 (details )
Native bindings where updated to reflect the latest SDK changes
Internal media IDs were removed from the API in favor of media stream handles
Overall audio quality and performance has been improved dramatically

API Changes

Added Room.UpdateRoomUserData
Updated functions to use IUserData interface more effectively
Renamed Room.UpdateUserData to Room.UpdatePeerUserData
Renamed ApmConfig option OdinNoiseSuppressionLevel to NoiseSuppressionLevel for sake of consistency
Replaced MediaId with MediaStreamId in OnMediaAdded, OnMediaRemoved and OnMediaActiveStateChanged event arguments
Added OnConnectionStateChanged event

Get Started with Unity today

ODIN Is With Us!

Wed, 06 Jul 2022 00:00:00 +0000

Today is the day. After two years of development and more than five months of open beta, 4Players GmbH is pleased to announce the immediate availability of the ODIN Core SDK version 1.0. Major updates to our engine integration plugins for Unity and both Unreal Engine 4 and 5 will be released to production within the next couple of days.

The latest version can be found here:

https://github.com/4Players/odin-sdk/releases

ODIN is the result from years of expertise and experience and built from the ground up using the popular Rust programming language. 4Players combines business and industry insight with a very modern technology stack to drive growth for your businesses. We took a lot of effort to make sure developers can focus their time and resources on building the game they envisioned.

Real-time communication is essential for a fun, immersive gaming experience. This is why our dedicated development team is creating a powerful set of tools that make games more immersive, social and interactive. With ODIN, 4Players provides a complete, out-of-the-box solution that has been designed and built from the ground up for gamers, developers and publishers so they don’t need to spend valuable resources designing a comms solution on their own.

Privacy and security is very important to us. ODIN is completely user agnostic and we don’t harvest any data or tell you how things should work or look.

Don’t hesitate and be among the first studios to integrate ODIN today! You can find a set of both both static and dynamic libraries as well as a single C header file in our public repository on Github .

Many thanks to all our partners, beta testers and supporters!

ODIN 1.0 comes with numerous improvements and new features such as:

General

Improved overall reliability by adding an internal mechanism to re-establish a connection to the ODIN server on timeouts
Updated test console client to properly handle reconnects
Removed the internal media ID from the API in favor of media handles (internal IDs can still be retrieved using odin_media_stream_media_id for reference while the media stream is added to a connected room)

New Features

Added a generic resampler for situations where your audio pipeline doesn’t support 48 kHz (one resampler instance should be used exclusively per audio stream)

API Changes

Added odin_resampler_create
Added odin_resampler_process
Added odin_resampler_destroy
Added odin_room_close to ensure a clean disconnect before calling odin_room_destroy
Changed type of OdinReturnCode from unsigned to signed integers
Replaced media_id and stream properties with media_handle in Media* event data
Removed unused None event tag

Bugfixes / Improvements

Fixed a bug where odin_audio_mix_streams was only outputting the last media stream
Fixed a possible deadlock when calling API functions within event handlers
Added missing null terminator to room ID and customer strings

In-game Voice. Redefined. 4Players releases communication software ODIN

Fri, 17 Sep 2021 00:00:00 +0000

Hamburg, Germany, October 13, 2021 – German middleware and service provider 4Players announces the Early Access release of its communication software 4Players ODIN. Developed by veterans responsible for the renowned globally successful TeamSpeak software, ODIN represents the next generation of in-game voice tools.

The main features of 4Players ODIN:

comprehensive software solution
ultra-low latency, crystal-clear voice transmission
native support for Unity Engine (support for Unreal will follow at the end of October)
integrated ‘Spatial Audio’ support and 3D sound
deep engine integration instead of superficial voice layers
no restrictions on creativity: ODIN offers maximum flexibility for developers
fully customizable user interface
cross-platform compatibility
easy integration into existing projects
uniform code base for all engines, platforms and systems
encrypted and fully GDPR-compliant service
performance guarantee, optionally on your own or 4Players servers
fully scalable: ODIN knows no limit, no matter if 10 or more than 10,000 users

4Players ODIN is a comprehensive software solution with ultra-low latency and crystal-clear voice transmission. It is easy to deploy or modify thanks to native engine integration, so game designers can focus on the essentials rather than complicated tools: The creative realization of their game ideas, no matter what system they are developing for.

An example how ODIN’s special capabilities can be used to lift immersion to a new level. ODIN goes further than other SDKs, redefining in-game voice: With spatial audio, 3D sound as well as a chat integration of the gamers‘ characters into the game environment, which has not been seen before in this form, new paths are broken in the area of in-game communication. In contrast to many of its competitors, ODIN does not superimpose a superficial voice channel on the game. Instead, you are directly connected to your fellow players, opponents as well as other parts of the game world via native engine integration. Voice communication becomes an integral part of the gaming experience. The SDK is fully GDPR-compliant with its encrypted communication transmission, whether you run it on your own servers or on 4Players servers.

For the Early Access launch, ODIN is fully compatible with Unity. Further engine integrations such as Unreal as well as console support are an integral part of the development roadmap and will be rolled out with coming updates.

Phillip Schuster, CEO 4Players GmbH: “ODIN was developed from scratch by passionate gamers specifically for the different needs of gamers, developers and publishers. We are very proud of the result, which not only connects our passion for games with our almost 20 years of experience with voice software and servers. ODIN is also one of the few communication solutions that transcends system or engine boundaries and enables a more immersive gaming experience with new features. Nevertheless, it is very easy to integrate into projects and, thanks to its open structure, can be easily adapted or modified to meet specific requirements. We are convinced that ODIN is the best solution for communication in gaming.”

“Once you hear the difference, you don’t want to go back to standard communication,” adds Sven Paulsen, Project Lead of 4Players ODIN and former TeamSpeak-CTO. “Our SDK, with its focus on the essentials, is not only one of the most powerful but also one of the most scalable solutions for in-game speech. For us it was enormously important that our tool does not distract from the development process, but helps the developer to realize his creative ideas. And we have achieved this goal with ODIN.”