How to Set Up FMOD in Unity: A Complete Integration Guide

The first time FMOD is integrated into a Unity project, something usually goes wrong. The package installs but the FMOD menu does not appear. The menu appears but the events do not. The events appear but no sound plays. The problem is almost always the same root cause, and the fix is almost always the same, but the symptom looks different each time.

The good news is that FMOD is genuinely one of the easier middleware tools to integrate, and once the version matching is handled correctly, the rest of the setup is fast. The comparison with Wwise and MetaSounds covers why FMOD is usually the recommended starting point for indie developers; this article is specifically about the integration itself, from a blank Unity project to a first event playing in a scene.

The Version Matching That Causes Most Failures

FMOD has two pieces that must match in a specific way: the FMOD Studio version used to author the sound events, and the FMOD Unity integration package installed in the project. The integration package is versioned against specific Unity versions, and a mismatch between any of the three — Studio, integration, or Unity — produces errors that are not always descriptive.

The rule that prevents problems is: choose the FMOD Studio version first, then install the corresponding integration for your Unity version, and only then build the FMOD Studio project. Changing any of those three after the project is set up requires re-doing work.

FMOD Studio is available in two release tracks. The "latest" track gets new features and bug fixes, and the "LTS" (long-term support) track is a stable snapshot that is periodically updated. For a project that will be in development for months, LTS is the safer choice because the integration package is guaranteed to remain compatible. The "latest" track can introduce changes that break an existing integration.

FMOD Studio's current version can be checked on the download page. The Unity integration download is on the same page, and it lists the supported Unity versions for each integration. If the project is on Unity 2022 LTS and the FMOD integration supports Unity 2021 through 2023, the integration is fine. If the integration only supports Unity 6 and above, the project needs a different approach.

Installing the Unity Integration

The FMOD Unity integration is distributed as a .unitypackage file rather than through the Unity Asset Store or the Package Manager. The download comes from FMOD's website as part of the FMOD Studio download, in the "Unity Integration" section.

To install it:

1. Download the FMOD Studio installer and the Unity integration package. Do not download only the integration; the Studio application is required to build the events.
2. Install FMOD Studio first, then open the Unity project.
3. In Unity, go to Assets then Import Package then Custom Package. Select the .unitypackage file.
4. Unity imports the package. A new top-level menu called FMOD appears in the Unity menu bar.
5. Go to FMOD then Settings. A window opens asking for the location of the FMOD Studio project. Leave this blank for now.

If the FMOD menu does not appear after import, the most common causes are: the package did not finish importing (check the Console for errors), the Unity version is not supported by the integration, or another audio package is conflicting. The Console window shows the specific error.

One thing that catches people off guard: the integration does not replace Unity's built-in audio system. Unity's AudioSource and AudioListener components continue to work. The FMOD integration adds its own components — FMOD Studio Event Emitter, FMOD Studio Listener, and others — that run alongside the built-in system. A project can use both, though mixing them in the same scene can produce surprising results if the listener is not set up correctly.

Setting Up the FMOD Studio Project

Before any sound can play in Unity, FMOD Studio needs a project with at least one event. The project is created in FMOD Studio, not Unity.

1. Open FMOD Studio. In the start screen, click New Project.
2. Choose a location for the project. This is important — the Unity project will reference this path directly, and moving the FMOD Studio project afterward breaks the reference.
3. Once the project is open, in the Events tab, right-click the Events folder and select New Event then 2D Timeline.
4. Name the event something meaningful, like sfx_test.
5. Drag a WAV file into the timeline area of the event. The file becomes an audio track.
6. Save the project with Ctrl+S or Cmd+S.
7. Build the project with F7 or by clicking the Build button. The build produces a .bank file in the project's Build folder.

The Build step is what makes the event available to Unity. Without it, the event exists in FMOD Studio but is not visible to the integration. Building generates two things: the .bank file containing the audio data, and a .strings file containing metadata. Both are needed.

For a project with only one event, the bank is tiny and the build is instant. For a project with hundreds of events, the build takes longer and generates a larger bank. The FMOD build process is what the sound file reduction guide applies to: the WAV files that go into FMOD are the ones that should be reduced before import, not the bank files that come out.

Connecting FMOD Studio to Unity

With the FMOD Studio project built, the Unity integration can be pointed at it. This is the step that most first-time users skip, and it is why the events do not show up in Unity afterward.

1. In Unity, go to FMOD then Settings. The FMOD Settings window opens.
2. In the Studio Project Path field, click the ... button and navigate to the FMOD Studio project folder created earlier. Select the .fspro file.
3. The FMOD Settings window now shows the project path and detects the build output. If the "Build" button is available in the Settings window, use it to confirm the connection is working.
4. Close the Settings window. Unity imports the bank files from the FMOD Studio project's Build folder into the project's Assets/StreamingAssets folder.

The streaming assets folder is where the bank files need to live for the game to load them at runtime. The integration handles copying them automatically when the project is built in Unity, but the initial connection has to be set up manually.

At this point, Unity should show the FMOD events under the FMOD Studio Event Emitter component. If the events do not appear, the most common causes are: the FMOD Studio project was not built, the Studio Project Path in Settings is wrong, or Unity has not refreshed after the path change. A re-import of the streaming assets (right-click the StreamingAssets folder, then Reimport) forces the refresh.

Playing the First Event in a Scene

With the connection working, playing a sound in a scene is a matter of adding one component to one GameObject.

1. In the Unity scene, create an empty GameObject. Name it something like SFX_Test.
2. Add a FMOD Studio Event Emitter component to the GameObject.
3. In the component's Event field, click the dropdown. The FMOD events from the connected project appear in the list. Select the test event.
4. Set Play Event to Object Start. This makes the event fire when the scene starts.
5. Press Play in Unity. The sound plays.

The FMOD Studio Listener is the equivalent of Unity's AudioListener. If the project has no listener in the scene, no sound plays, because FMOD has no reference point for 3D spatialization. If the scene already has a main camera with a Unity AudioListener, FMOD detects this and uses the camera's transform for spatialization. If the scene has no listener at all, adding a FMOD Studio Listener component to the camera fixes it.

The first event playing is the moment the integration becomes useful. Everything else — Switch parameters, RTPCs, snapshot transitions, 3D attenuation — is a variation on the same basic pattern: an event fires from a component or a script, and the FMOD runtime plays it.

Calling Events from Scripts

The component-based approach works for sounds that fire on scene start or on a trigger, but most game audio is triggered from code. FMOD exposes a small API for this, and the pattern is the same for every event.

using FMODUnity;
using UnityEngine;

public class FootstepPlayer : MonoBehaviour
{
    void PlayFootstep()
    {
        RuntimeManager.PlayOneShot("event:/sfx/footstep");
    }
}

The RuntimeManager.PlayOneShot method plays the event as a fire-and-forget sound. This is the equivalent of Unity's AudioSource.PlayOneShot. The string is the event path, which is visible in FMOD Studio when an event is selected. The path starts with event:/ and follows the folder structure inside the Events tab.

For sounds that need to start and stop independently, or for sounds that need to have parameters set at runtime, the EventInstance API is used instead:

private EventInstance footstepInstance;

void Start()
{
    footstepInstance = RuntimeManager.CreateInstance("event:/sfx/footstep");
}

void Update()
{
    float speed = GetPlayerSpeed();
    footstepInstance.setParameterByName("Speed", speed);
}

The EventInstance is the persistent handle for a specific playback of an event. It can be started, stopped, have parameters set on it, and be positioned in 3D space. For most game audio, PlayOneShot is enough, and the EventInstance API is reserved for cases where the sound needs to respond to runtime state.

What to Watch for on the First Real Project

The integration steps above are the ones that make the first sound play. The problems that appear later are usually about the build process rather than the integration itself.

The most common issue is that the FMOD bank files are not being rebuilt when the FMOD Studio project changes. The Unity integration does not automatically detect that FMOD Studio has produced a new bank; the bank has to be rebuilt and the Unity project has to refresh the streaming assets. In a team with separate audio and programming workstreams, this is a common source of "the event is broken" complaints when the event is actually fine and the bank is stale.

The second most common issue is the platform-specific build. FMOD banks are platform-specific by default, which means a bank built for Windows does not work on macOS, Android, or iOS. When targeting multiple platforms, the FMOD Studio project needs to be rebuilt for each platform, and the Unity project needs to include the correct bank per build target. FMOD's Build settings in Studio handle this, but the Unity side needs to be configured to match.

The third issue is the streaming assets size. For a project with hundreds of events, the bank files can be several hundred MB in the streaming assets folder. This affects the build size of the game, and on platforms with tight size limits (mobile, particularly), the bank size matters. The FMOD compression settings in Studio are what control this; the settings are per-platform and can be configured separately for desktop and mobile builds.

FMOD's mobile performance is one of the reasons it is often recommended over Wwise for mobile projects. The compression settings and the DSP buffer size are both configurable, and the defaults are well-tuned for most cases. The mobile audio optimization guide covers the broader constraints; the FMOD-specific parts are the bank compression and the DSP buffer size, both of which live in FMOD Studio's platform settings.

Where to Go After the First Event Works

Getting the first event to play in Unity is the moment FMOD stops being an abstract tool. The remaining learning curve is about the features that make FMOD useful: parameter-based variation, switch-based state changes, snapshot transitions, and 3D attenuation.

The parameter system is where FMOD's expressive range comes from. An event with a parameter can respond to a game value — player speed, enemy distance, health level — without any code beyond setting the parameter. The adaptive sound system guide covers the design patterns that make use of this capability.

The snapshot system is the other feature worth learning early. A snapshot is a set of mixer changes that can be applied when a game state changes, and it is how FMOD handles situations like "everything sounds muffled when the player is underwater." Snapshots are simpler than Wwise's State system and cover most of the same use cases for a project at indie scale.

For a developer who is new to audio middleware, the sequence that works is: get the first event playing, then build a small sound set using events and parameters, then add the snapshot transitions. By the time the project has fifty events, the FMOD workflow is familiar enough that the remaining features are easy to pick up as needed.