AudioStreamMicrophone in Godot – Complete Guide

In the realm of game development, audio is the soul that breathes life into our virtual experiences. It creates ambiance, conveys emotion, and, most importantly, connects players to the game world in a tangible way. Today, we’re diving into the world of real-time audio input with the AudioStreamMicrophone class in Godot 4, a powerful tool that offers us the means to capture live sound and interact within our game environment dynamically.

What is AudioStreamMicrophone?
AudioStreamMicrophone is a Godot 4 class that inherits from AudioStream, allowing developers to play back audio data from a microphone in real time. This functionality opens the door to a plethora of interactive applications within a game, such as voice chat systems, voice commands, or even dynamic sound effect generation.

What is it for?
The concept of integrating live audio input into games or applications isn’t entirely new, but the ease with which Godot 4 allows you to implement this feature is noteworthy. With AudioStreamMicrophone, you can enhance the level of interactivity in your games. For instance, players can communicate with each other in multiplayer settings or you can create mechanics that react to volume or pitch variations captured by the microphone.

Why Should I Learn It?
Learning how to work with AudioStreamMicrophone can significantly boost the interactive potential of your projects, setting your games apart with innovative features. It’s not just about bridging the gap between the player and the game world; it’s about tearing it down entirely. Whether you’re an enthusiastic beginner in the world of game development or a seasoned coder looking to spice up your game mechanics, mastering this class will empower you to create more immersive and responsive experiences.

CTA Small Image

Setting Up the AudioStreamMicrophone

Before we can harness the power of live audio input, we need to set up the AudioStreamMicrophone in our Godot project. The following snippet creates an AudioStreamPlayer node with an attached AudioStreamMicrophone:

var mic_stream =

func _ready():
    var audio_player = = mic_stream

In the above code, we create a new AudioStreamMicrophone instance and an AudioStreamPlayer node. We assign the microphone stream as the audio stream of the player and then play it.

Accessing Microphone Properties

The AudioStreamMicrophone class offers several properties to customize the microphone input. For example, you can adjust the mix rate and enable or disable the microphone:

mic_stream.mix_rate = 44100  # Set the mix rate to 44100Hz = true      # Enable the microphone

To ensure our microphone input is being used correctly, we can check if it’s active:

func _process(delta):
        print("Microphone is active")
        print("Microphone is not active")

Capturing and Using Audio Input

Next, let’s capture audio input from the microphone and apply it to a game mechanic. Imagine we are creating a game where the player can influence the game world by blowing on the microphone.

func _process(delta):
    var raw_audio_data = mic_stream.get_buffer(1024)
    var volume = raw_audio_data.get_rms()

    if volume > 0.5:
        # The player blew on the microphone!

In this example, `get_buffer()` fetches a segment of the audio buffer, and `get_rms()` calculates the root mean square of the audio buffer, which can be related to the volume level. If this volume exceeds a certain threshold, it triggers a function that affects the game world.

Implementing a Simple Voice Command System

Let’s consider a voice command system where players can give commands by speaking into the microphone. For simplicity, this example will detect if a loud noise, like a clap or a shout, was performed to trigger an action:

var threshold = 0.7

func _process(delta):
    var raw_audio_data = mic_stream.get_buffer(1024)
    var volume = raw_audio_data.get_rms()

    if volume > threshold:

Here, if the detected volume exceeds the `threshold`, we simulate a function `execute_command()` with a parameter that represents the command name. For a full voice command system, you would integrate a speech recognition engine that processes the raw_audio_data more thoroughly.

Remember, adding real-time audio input to your project not only broadens the scope of how players can interact with your game but also allows for creative game mechanics and features that make your game stand out.

To expand upon our use of real-time audio input with the AudioStreamMicrophone in Godot 4, let’s delve into more complex examples and utilizations. As you advance your understanding of this feature, the potential for intricate and interactive elements in your game broadens.

Monitoring Audio Levels

Visualizing audio levels can add a layer of feedback for players, especially in rhythm games or games that rely on audio intensity. Below is how you can create a simple volume meter.

var sprite = preload("res://volume_meter.png")
var max_meter_width = sprite.get_width()

func _process(delta):
    var raw_audio_data = mic_stream.get_buffer(1024)
    var volume = raw_audio_data.get_rms()

    # Update the sprite width based on volume
    sprite.scale.x = max_meter_width * volume

Adjusting Game Effects with Sound

You can also adjust game parameters such as visual effects or game speed based on audio input. This could lead to a game that changes dynamically based on environmental noise or player input.

var effect_intensity = 0.0

func _process(delta):
    var raw_audio_data = mic_stream.get_buffer(1024)
    var volume = raw_audio_data.get_rms()

    # Adjust the intensity of an effect
    effect_intensity = volume * 100

This could be used to create a pulsing glow that reacts to player’s vocal inputs, or perhaps to vary the intensity of a game’s background music.

Interacting with Game Objects

Beyond visual and audio effects, microphone input can also interact directly with objects in your game. Here we influence a physics object’s behavior based on the audio input.

func _process(delta):
    var raw_audio_data = mic_stream.get_buffer(1024)
    var volume = raw_audio_data.get_rms()

    # Let's assume there's a RigidBody in the scene named "balloon"
    var balloon = get_node("balloon")

    # The balloon rises faster if there's a louder sound detected
    if volume > 0.5:
        balloon.apply_central_impulse(Vector3.UP * volume * 10)

This snippet applies an upward impulse to a RigidBody node, simulating the effect of wind or breath, adding an interactive layer to gameplay that is tied directly to the player’s real-world actions.

Creating Dynamic Dialogue or Sounds

Finally, AudioStreamMicrophone can be utilized to alter or dynamically generate in-game sounds or dialogue. Below, we adjust the pitch of a character’s voice as a function of the microphone input volume.

func _process(delta):
    var raw_audio_data = mic_stream.get_buffer(1024)
    var volume = raw_audio_data.get_rms()

    # Adjust the dialogue pitch based on volume
    var character_voice = get_node("CharacterVoice")
    character_voice.pitch_scale = 1.0 + volume

In this example, as the volume picked up by the microphone increases, the pitch of the pre-recorded character voice increases, adding a level of dynamism and responsiveness to the game environment.

With these additional examples, you should have a better grasp of how AudioStreamMicrophone can be creatively used to incorporate real-time audio input within your Godot projects. As with any powerful tool, imagination is your only limit. We at Zenva encourage you to explore the myriad possibilities this feature presents and look forward to seeing how you’ll use it to elevate your game development aspirations to new heights!

Real-time audio input in Godot 4 not only provides a gateway to novel game mechanics but also allows for interactive storytelling and learning applications. Let’s explore further code examples that showcase the versatility of the AudioStreamMicrophone class and invigorate our creative palettes.

Detecting Specific Frequency Ranges:

func _process(delta):
    var buffer_size = 1024
    var raw_audio_data = mic_stream.get_buffer(buffer_size)
    var volume = raw_audio_data.get_rms()
    # Apply a Fast Fourier Transform (FFT) algorithm to convert time-domain signals to frequency-domain
    var frequency_domain = raw_audio_data.fft()

    # Identify if a specific frequency range has significant volume
    if frequency_domain.has_significant_volume(frequency_min, frequency_max):

This snippet demonstrates how one could process the raw audio data to discern specific frequency ranges, which could trigger game events, such as a puzzle that only solves if the player hits the right notes.

Implementing a Sound Toggle:

var is_mic_enabled = false

func toggle_mic():
    is_mic_enabled = !is_mic_enabled = is_mic_enabled

# Now you can call toggle_mic() to enable/disable microphone input

Here we provide functionality to enable or disable microphone input with a simple function. This can be connected to a UI button or a keyboard shortcut, providing accessibility features or just to give control to the player over their privacy.

Creating a Proximity Chat:

var network_peer = get_tree().network_peer
var player_id = network_peer.get_unique_id()

func _process(delta):
    if and network_peer:
        var raw_audio_data = mic_stream.get_buffer(1024)
        # Send this raw audio data to other players in proximity
        for peer_id in get_proximity_player_ids():
            rpc_unreliable_id(peer_id, "play_voice_audio", player_id, raw_audio_data)

remote func play_voice_audio(from_id, audio_data):
    if from_id in get_proximity_player_ids() or from_id == player_id:
        # Process the raw audio data for the player(s)

This code can enable players to communicate with their nearby teammates or enemies, making for an engaging strategic element in multiplayer environments.

Controlling Non-Player Character (NPC) Responses:

var player_present = false

func _on_PlayerDetectionArea_body_entered(body):
    if == "Player":
        player_present = true

func _on_PlayerDetectionArea_body_exited(body):
    if == "Player":
        player_present = false

func _process(delta):
    var raw_audio_data = mic_stream.get_buffer(1024)

    if player_present and raw_audio_data.get_rms() > 0.5:

NPCs can be programmed to respond to player’s in-game actions, triggered by audio input. In this case, an NPC reacts differently when the player is present and speaks or makes noise, creating an interactive and immersive narrative experience.

Experimenting with Voice Modulation:

func modulate_voice(effect_preset):
    var raw_audio_data = mic_stream.get_buffer(1024)

    # Apply different effects to modulate the player's voice
    var modulated_voice = apply_effect_to_voice(raw_audio_data, effect_preset)
    # Play the modulated voice
    var audio_player = get_node("AudioPlayer") = modulated_voice

This example shows how you might apply different effects to the voice captured by the microphone, perhaps to disguise a character’s voice or to fit with specific story elements.

Our journey with AudioStreamMicrophone illuminates the vast landscape of interactive opportunities within Godot 4. As we push the boundaries of conventional gameplay with live audio input, we invite you to explore these concepts and craft extraordinary experiences for your audiences. At Zenva, we are committed to empowering you with the knowledge and tools to turn imaginative ideas into reality. Delve into the unlimited potential that awaits in the virtual realms you create!

Continue Your Game Development Journey

Having explored the dynamic world of real-time audio input with AudioStreamMicrophone in Godot 4, you are likely buzzing with ideas and ready to tackle new challenges. This is just the beginning of what’s possible, and we’re excited for you to explore the expanse of your game development potential.

For those keen to delve deeper into the world of game creation, we invite you to check out our Godot Game Development Mini-Degree. This comprehensive program will equip you with the skills required across a variety of game development topics. From mastering 2D and 3D game mechanics to learning about player and enemy behaviors, every lesson brings you a step closer to realizing your game development dreams. While this program doesn’t cover the exact topic of this tutorial, the foundational knowledge you gain will help you to integrate complex features like real-time audio with confidence.

If you’re eager for more and want to browse through a broader set of offerings, our Godot courses can be found here. With Zenva, your learning journey is flexible, project-based, and always at the cusp of the latest industry trends. Whether you’re a beginner or looking to sharpen your existing skills, our courses are designed to help you build a robust professional portfolio and make your mark in the world of game development.


By embracing the capabilities of AudioStreamMicrophone in Godot 4, you’ve unlocked an entirely new dimension of game interactivity and creativity. The potential to enhance immersion, engagement and provide players with novel experiences is vast and exciting. We encourage you to continue experimenting, learning, and deploying these dynamic audio input features in your games to truly captivate and astonish your players.

At Zenva, we understand the ever-evolving landscape of game development and strive to keep you at the forefront of these changes. So, whatever your next project may be, remember that resources like our Godot Game Development Mini-Degree are here to guide you through each step of the creative process. Keep building, keep innovating, and most importantly, keep having fun with the process. Happy coding!

Python Blog Image

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