AudioEffectChorus in Godot – Complete Guide

In this tutorial, we will dive deep into the world of audio effects within the Godot Engine, specifically focusing on the AudioEffectChorus class in Godot 4. Whether you’re creating a hypnotic soundscape for a game level or adding dimension to a character’s voice, understanding how to manipulate audio can greatly enhance your project’s overall experience. Let’s embark on a journey to explore the capabilities of the AudioEffectChorus class and discover how it can add that extra layer of polish to your game’s audio.

What is AudioEffectChorus?

The AudioEffectChorus class is an integral part of Godot Engine’s robust audio system. It adds a chorus effect to your audio, which can create a richer, more complex sound by duplicating the original audio signal and varying the time-delay and pitch of the copies. This effect is commonly used to thicken the sound, giving the illusion of multiple voices or instruments playing in harmony.

What is it for?

A chorus effect is a powerful tool for game developers and audio designers. It’s used to enhance the auditory depth and texture in various situations such as:
– Emulating the sound of a choir or string ensemble from a single voice or instrument.
– Adding movement and thickness to static sounds.
– Creating surreal or ethereal audio environments for specific game scenes.
– Simulating the effect of old tape recordings or vintage instruments.

Why Should I Learn It?

Learning how to use the AudioEffectChorus class can open up a world of possibilities for your game development projects. Here are a few reasons why mastering this tool can be beneficial:
– **Enhancing Gameplay Experience**: Compelling audio effects can significantly boost immersion, making gameplay much more engaging.
– **Creative Control**: Knowing how to manipulate audio gives you greater creative freedom to achieve the exact sound you envision for your game.
– **Skill Development**: Understanding audio processing is a valuable skill that can extend beyond game development to other fields like music production or sound design.

Stay tuned as we delve into coding examples and further explore how to implement AudioEffectChorus within your Godot projects. Whether you’re a beginner or an experienced coder, you’ll find valuable insights that can elevate your audio game.

CTA Small Image

Creating a Chorus Effect Instance

To begin using the AudioEffectChorus class in Godot 4, you need to create an instance of the effect and attach it to an audio bus. Below is a basic example of how to create a chorus effect in code:

var chorus =

Once you’ve created the effect, you can customize its properties to fit your needs:

chorus.depth_ms = 20.0
chorus.rate_hz = 1.5 = 0.5
chorus.voice_count = 4

These parameters allow you to modify the depth, rate, feedback, and number of voices for the chorus effect. After setting up the chorus effect, you need to add it to an audio bus:

AudioServer.add_bus_effect(bus_idx, chorus)

Make sure to replace `bus_idx` with the index of the audio bus you want to attach the effect to.

Adjusting Chorus Parameters

Playing with the AudioEffectChorus parameters is essential to achieving the desired sound. You can adjust these parameters in real-time or set them when initializing the effect:

// Adjust chorus parameters in real-time
chorus.depth_ms = 12.0  // Change the depth of the chorus effect
chorus.rate_hz = 2.0    // Adjust the rate or speed of the modulation

The `depth_ms` parameter controls how much time difference there is between the original signal and the chorus “voices,” while `rate_hz` determines the speed of modulation.

You might also want to modify the feedback and the spread to refine the sound: = 0.7     // Increase feedback for more pronounced effect
chorus.spread = 0.6       // Adjust spread to control the stereo width of the effect

A higher feedback value will result in a more intense chorus effect, and the spread value affects how much the duplicate signals are panned to the left and right in the stereo field.

Applying the Chorus to an Audio Stream

For applying the effect to a specific audio stream, you need to set up an AudioStreamPlayer node and an AudioBus with the Chorus effect. Here’s a snippet to set up an AudioStreamPlayer:

var audio_player = = preload("res://your_audio_file.ogg")  // Load your audio file
audio_player.bus = "ChorusBus"  // Assign the player to the bus with the chorus effect

Ensure that a bus named “ChorusBus” exists in the Godot Audio Bus Layout and has the chorus effect you created.

Dynamically Toggling the Chorus Effect

In game scenarios, you may want to enable or disable the chorus effect based on certain events. Here’s how you can toggle the chorus effect on and off:

const BUS_IDX = 0  // The index of the bus where the chorus effect is applied

func _toggle_chorus(is_enabled: bool):
    AudioServer.set_bus_effect_enabled(BUS_IDX, effect_idx, is_enabled)

In this example, `effect_idx` is the index of the chorus effect on the specified audio bus. Call `_toggle_chorus(true)` or `_toggle_chorus(false)` to enable or disable the effect, respectively.

Remember, experimentation is key to mastering audio effects. Play around with these snippets and listen to how they alter your game’s sound environment. Over time, you’ll develop a keen ear for fine-tuning audio to perfection.Now, let’s progress with our exploration into the AudioEffectChorus class within Godot 4 by looking at practical examples and diving deeper into the various parameters and their uses.

Manipulating Wet Mix Levels

The wet mix levels determine the balance between the original audio signal and the effected signal. Here’s how you manage the wet levels in a chorus:

chorus.wet = 0.8  // Increase the wet mix level for more effect presence

If the wet level is set too high, the effect might overshadow the original sound. Adjust this carefully to maintain a pleasant blend.

Creating a Script to Control Chorus Parameters

You may want to control the chorus parameters through player actions or game events. Here is an example script that changes chorus parameters dynamically:

extends Node

var chorus =

func _ready():
    AudioServer.add_bus_effect(1, chorus)

func set_chorus_depth(depth: float) -> void:
    chorus.depth_ms = depth

func set_chorus_rate(rate: float) -> void:
    chorus.rate_hz = rate

# Call these functions when you want to adjust the chorus dynamically

You can call the `set_chorus_depth` or `set_chorus_rate` functions to adjust the chorus effect in response to in-game triggers.

Using Chorus with AnimationPlayer

For more complex interactions, such as those that evolve over time or have a specific sequence, Godot’s AnimationPlayer can be utilized to animate chorus parameters. The following example shows how to create a simple animation that modifies the chorus depth:

var animation_player =
var animation =

animation.track_insert_key(0, 0.0, 12.0)  // Insert keyframe at 0 seconds with value 12.0
animation.track_insert_key(0, 2.0, 24.0)  // Insert keyframe at 2 seconds with value 24.0

animation_player.add_animation('chorus_depth_animation', animation)
# Now you can play this animation to change chorus depth over time

This animated approach can enrich scenes with changes in atmosphere, corresponding to on-screen developments.

Randomizing Chorus Parameters

Sometimes, you want a less predictable result for your audio effects. Here’s how you could randomize the chorus parameters for a unique outcome every time it’s triggered:

func randomize_chorus():
    chorus.depth_ms = rand_range(10.0, 30.0)
    chorus.rate_hz = rand_range(0.5, 2.0) = rand_range(0.0, 0.9)

# Call randomize_chorus to change the effect randomly

Make sure to call `randomize()` or set `randomize` to true somewhere in the initialization code to ensure the random number generator is properly seeded.

Chaining Multiple AudioEffects

Chorus can be part of a chain of effects. Adding reverb to the mix can produce a richer sound:

var reverb =
var chorus =

AudioServer.add_bus_effect(2, reverb)
AudioServer.add_bus_effect(2, chorus)

# The above code adds both reverb and chorus to the same audio bus, creating a chain.

When adjusting your chain of effects, consider the order as it can significantly impact the final output. Experiment with different combinations and orders to discover unique soundscapes.

These examples only scratch the surface of what is possible with the AudioEffectChorus in Godot 4. Keep experimenting with different settings and combinations to truly make your game’s audio stand out. With practice, these techniques will become second nature, and you’ll be able to integrate them seamlessly into your game development workflow.We’ve already scripted basic controls, randomized parameters, and combined effects. Now, let’s push further by incorporating chorus effects within the context of environmental sound design and adaptive audio, which can truly make your games feel alive.

Imagine you have an underwater scene wherein you’d like the ambient music to have a wavy, liquid quality. Here’s how you might modify the chorus parameters to create that effect:

func apply_underwater_effect():
    chorus.depth_ms = 30.0
    chorus.rate_hz = 1.2 = 0.4
    chorus.wet = 0.6
    chorus.dry = 0.4

In the above script, increased depth and moderate rate give a slowly modulating feel, akin to being underwater.

Next, suppose players find themselves in a mystical forest. You might want the audio to reflect a more magical and surreal atmosphere. You could achieve this by applying a higher rate and depth:

func apply_mystical_forest_effect():
    chorus.depth_ms = 25.0
    chorus.rate_hz = 2.5 = 0.3
    chorus.voice_count = 6

This configuration delivers a faster, more prominent modulation, which can contribute to a feeling of enchantment or otherworldliness.

Progressing to more complex examples, let’s say we want to automate adjustments in chorus parameters based on the player’s movement speed. The following script outlines a potential approach:

func update_chorus_with_speed(player_speed: float) -> void:
    var speed_factor = clamp(player_speed / max_speed, 0.0, 1.0)
    chorus.depth_ms = lerp(10.0, 30.0, speed_factor)
    chorus.rate_hz = lerp(0.5, 2.0, speed_factor)

Here, `lerp` is used to interpolate between minimum and maximum values based on the player’s speed, providing a dynamic audio response to in-game action.

Additionally, creating a sense of space in your game’s levels can be achieved by automating the spread of the chorus effect based on the player’s location within the environment:

func update_chorus_with_position(player_position: Vector3) -> void:
    var position_factor = player_position.x / level_width
    chorusspread = lerp(0.5, 1.0, position_factor)

This snippet presumes a level where the x-coordinate can represent the player’s traversal from one end to the other, adjusting the stereo spread accordingly.

For transitions between different audio effect settings, such as moving from an outdoor to an indoor environment, smoothly interpolating between chorus settings can enhance realism:

var target_settings = {"depth_ms": 15.0, "rate_hz": 1.0, "feedback": 0.2}
var transition_time = 5.0
var transition_timer = 0.0

func _process(delta):
    if transition_timer < transition_time:
        transition_timer += delta
        var progress = transition_timer / transition_time
        chorus.depth_ms = lerp(chorus.depth_ms, target_settings["depth_ms"], progress)
        chorus.rate_hz = lerp(chorus.rate_hz, target_settings["rate_hz"], progress) = lerp(, target_settings["feedback"], progress)

This script gradually interpolates the values from their current state to the desired target settings over five seconds.

The flexibility of the AudioEffectChorus class, as shown in these examples, can significantly contribute to the overall mood and immersion of your game. By understanding and utilizing these features, you can create dynamic and responsive audio experiences that elevate the quality of your projects. Being proficient with audio effects like chorus not only broadens your toolkit as a game developer but also helps in crafting compelling narratives through sound.

Continuing Your Godot Audio Mastery Journey

If you’ve enjoyed diving into the depths of the AudioEffectChorus class and want to further enrich your game development skills, we at Zenva encourage you to continue exploring the vast world of Godot. Our Godot Game Development Mini-Degree is an excellent stepping stone to take your expertise to the next level.

This comprehensive collection of courses covers everything from 2D and 3D game development to intricacies like control flows and UI systems in Godot 4. Whether you’re a complete beginner or a developer looking to expand your horizons, we have a broad array of content to suit your learning pace and interests. And the best part? You can learn at your own convenience, with access to our courses available 24/7.

For those who want to explore an even broader selection of topics, feel free to explore our full range of Godot courses. We’re confident that with dedication and our high-quality content, you’ll be able to go from beginner to professional, applying your skills across various industries. Start building your dream games today with Zenva!


By embracing the power of the AudioEffectChorus class in Godot 4 and learning how to finely tune your audio effects, you’ve taken a significant step towards creating immersive and memorable gaming experiences. Remember, great audio can breathe life into your games, turning them from simple interactive experiences into captivating worlds that resonate with players long after they’ve put down the controller.

Don’t stop here, though! Venture forth and enhance your skills further with our Godot Game Development Mini-Degree. Let us guide you through the fascinating process of game creation, where the only limit is your imagination. Together, we can craft stunning audio landscapes and engaging gameplay that tell stories and evoke emotions in ways only interactive media can. We at Zenva are excited to be part of your journey and can’t wait to see what you’ll develop next!

Python Blog Image

FINAL DAYS: Unlock coding courses in Unity, Godot, Unreal, Python and more.