Bedrock Wiki
  • Discord
  • Contribute
  • bedrock.dev
  • MS Learn
Beginner's Guide
  • Guide
    • 1. Introduction
      guide
    • 2. Add-Ons Explained
    • 3. Software & Preparation
    • 4. Project Setup
    • 5. Create a Custom Item
    • 6. Create a Custom Entity
    • 7. Blockbench: Modeling, Texturing & Animating
    • 8. Adding a Loot Table, Spawn Rule & Crafting Recipe
  • Extra
    • a. Understanding JSON
    • b. Download Example Packs
    • c. Troubleshooting
      help
    • d. Advanced Manifest
    • e. Format Versions
    • f. Project Setup Android
Animation Controllers
  • Intro to Animation Controllers
    guide
  • Entity Commands
  • AFK Detector
  • Death Commands
  • Molang into Scoreboard
  • Respawn Commands
Blocks
  • General
    • Intro to Blocks
      guide
    • Block Components
    • Block Tags
    • Block States
    • Block Traits
    • Block Permutations
    • Block Events
      Scripts
    • Block Event Migration
      help
    • Blocks as Items
    • Troubleshooting Blocks
      help
  • Visuals
    • Block Culling
    • Block Models
      guide
    • Block Texture Animation
    • Block Texture Variation
    • Block Tinting
  • Tutorials
    • Applying Constant Effects
      Scripts
    • Avoiding State Limit
    • Fake Blocks
      Scripts
    • Ore Loot Tables
      Scripts
    • Precise Interaction
      Scripts
    • Precise Rotation
      Scripts
    • Rotatable Blocks
  • Vanilla Re-Creations
    • Custom Crops
      Scripts
    • Custom Glass
    • Custom Glazed Terracotta
    • Custom Trapdoors
      Scripts
  • Documentation
    • Block Format History
    • Block Shapes
    • Block Sounds
    • Vanilla Block Models
Commands
  • General
    • Intro to Command Blocks
    • Functions
    • Block States
    • Coordinate System
    • NBT Commands
    • Scoreboard Operations
    • Understanding Selectors
  • Commands
    • Damage
    • Execute
    • Playanimation
    • Playsound
  • On Event Systems
    • On Player First Join
    • On Player Join
    • On Player Leave
    • On Player Death
    • On Player Respawn
    • On First World Load
  • Scoreboard Systems
    • Entity Counter
    • Scoreboard Timers
    • Comparing And Retrieving Scores
  • Techniques
    • Execute Logic Gates
    • MBE - Max's Block Entity
    • FMBE - A New Way to Create Display Entities
    • Look Detection
    • Movement Detections
    • Orbital Camera
  • Useful Creations
    • Custom Crafter
    • Multiplayer Position Rearrangement
      function
Concepts
  • contents.json
  • Emojis & Symbols
  • Molang
  • Namespaces
  • Overwriting Assets
  • Raw Text
  • Shaders
  • Sounds
  • Subpacks
  • Text and Localization
  • Texture Atlases
  • textures_list.json
Documentation
  • Shared Constructs
  • Advanced Molang
  • File Types
  • Fog IDs
  • Material Configuration Description
  • Menu Categories
  • Molang Queries
  • Pack Folder Structure
  • Sound Definitions
  • Vanilla Materials
Entities
  • General
    • Intro to Entities BP
      guide
    • Intro to Entities RP
      guide
    • Troubleshooting Entities
      help
    • Entity Events
    • Entity Properties
    • NPC Dialogues
    • Render Controllers
    • Spawn Rules
  • Tutorials
    • Convert Points Between Any Space (World, Entity, Bones)
    • Creating Boats
    • Detecting Other Entities
    • Disabling Team Damage
    • Dummy Entities
    • Entity Attacks
    • Entity Holds Item
    • Entity Movement
    • Entity Timers
    • Flying Entities
    • Introduction to AOE Clouds
    • Invulnerable Entities
    • Look at Entity
    • Sleeping Entities
    • Solid Entities
    • Spawning Tamed Entities
      Scripts
    • Village Mechanic
  • Documentation
    • Dummy Components
    • Non-Mob Runtime Identifiers
    • Projectiles
    • Runtime Identifiers
    • Vanilla Usage Components
    • Vanilla Usage Spawn Rules
Items
  • General
    • Intro to Items
      guide
    • Item Components
    • Item Tags
    • Item Events
      Scripts
    • Item Event Migration
      help
    • Troubleshooting Items
      help
  • Tutorials
    • Custom Armor
    • Custom Food
      Scripts
    • Custom Pottery Sherds
    • Custom Weapons
    • Equipment-Based Commands
    • High Resolution Items
    • Spawning Items
    • Throwable Items
  • Documentation
    • Enchantments
    • Attachables
    • Item Format History
    • Numerical Item IDs
    • Vanilla Item Identifiers
    • Vanilla Usage Components
JSON UI
  • General
    • Intro to JSON UI
      guide
    • Best Practices
      guide
  • Tutorials
    • Adding HUD Elements
    • Aseprite Animations
    • Buttons and Toggles
    • Modifying Server Forms
    • Preserve Title Texts
    • String to Number
  • Documentation
    • JSON UI Documentation
Loot, Recipes & Trading
  • General
    • Trading Behavior
  • Documentation
    • Loot Tables
    • Trade Tables
    • Recipes
    • Item Functions
  • Tutorials
    • Randomized Structure Loot
Meta
  • Add-On Performance
  • Style Guide
  • Useful Links
  • Using Schemas
  • Version Control
  • Q&A
    • Blocks and Items Q&A 2024/08/30
    • Deferred Technical Preview Q&A 2024/02/23
    • GameTest Q&A 2021/08/06
    • Scripting and Editor Q&A 2023/09/22
    • World Generation Q&A 2024/11/15
NBT
  • General
    • .mcstructure
  • Tutorials
    • Experiments in Minecraft Education
    • Extending Structure Limits
  • NBT in Depth
    • About NBT (Named Binary Tag)
    • NBT Libraries
    • Reading NBT Example
Particles
  • General
    • Intro to Particles
      guide
  • Tutorials
    • Disabling Particles
  • Documentation
    • Vanilla Particles
Scripting
  • General
    • Intro to Scripting
    • What is Script API?
    • API Modules
  • Tutorials
    • Block Placement Prevention
    • GameTests
    • Script Core Features
    • Script Forms
    • Script Requests API
    • Simple Chat Commands
  • Documentation
    • Engine Environment
    • Script Resources
    • Script Watchdog
    • Troubleshooting JavaScript
    • TypeScript
Servers
  • Software
    • Bedrock Server Software
  • Protocols
    • Bedrock Protocol
    • NetherNet Protocol
    • RakNet Protocol
Visuals
  • General
    • Introduction to Entity Visuals
      guide
    • Bedrock Modeling
    • Custom Death Animations
    • Effects in Animations
    • Material Creations
    • Materials
    • Math-Based Animations
    • Skin Packs
  • Tutorials
    • Entity Texture Animation
    • Glowing Entity Texture
    • Hurt Animations
    • Leash Position
    • Player Geometry
    • Remove Entity Shadows
    • Retexturing Spawn Eggs
  • Ideas
    • Structure Presentation
World Generation
  • General
    • Intro to World Generation
      guide
    • Biomes
      guide
    • Feature Types
    • Jigsaw Structures
  • Tutorials
    • Block Conditions for Features
    • Generating Custom Ores
    • Generating Custom Structures
    • Generating Patches
    • Heightmap Noise
  • Documentation
    • Biome Tags

Sounds

intermediate
Sounds
  • Folder Structure
  • sound_definitions.json
    • /playsound volume notes
    • Top Level Keys
    • Sound definitions
    • Example
  • sounds.json
    • Adding Entity Sounds
    • Example
  • Adding sounds to Animations
  • Adding sounds to Animation Controllers

In bedrock, we can add custom sounds without overwriting any vanilla sounds. This is done by adding files to the resource pack.

TIP

The best way to learn about sounds is by downloading and playing around with the default resource pack.

Folder Structure ​

There are two main files that we edit when we want to add sounds. Note how sound_definition is nested inside sounds.

Sound files themselves are added inside of the sounds folder, and can be any of the following formats.

      • 📝example.wav
      • 📝example.ogg
      • 📝example.fsb
      • 📝sound_definitions.json
    • 📝sounds.json

sound_definitions.json ​

sound_definitions.json is where we define new sound short-names. This should be thought of as typing a short-name or id to a physical sound path. Here is an example, sound_definitions.json, that adds a new trumpet sound called example.toot:

RP/sounds/sound_definitions.json
json
{
	"format_version": "1.14.0",
	"sound_definitions": {
		"example.toot": {
			"category": "neutral",
			"sounds": ["sounds/trumpet"]
		}
	}
}
1
2
3
4
5
6
7
8
9

Sounds added in this way can be triggered using /playsound. Please note that playsound does not auto-correct, so you will need to be careful in your typing.

WARNING

New files referenced by file path, such as sounds, DO need a complete client restart to load. This means that if sounds don't work, you should restart your entire MC client rather than just reloading the world.

/playsound volume notes ​

The game will clamp the sound volume to at most 1.0 before multiplying it with the sound definition's volume.

For /playsound, the maximum hearable range of a sound is given by min(max_distance, max(volume * 16, 16)). If "max_distance"is not given in the sound's definition, it is equivalent to playsound_volume * 16.

Approximate sound attenuation by distance. The actual graph might not be linear.

Shown above is the approximate sound attenuation factor by distance for playing sounds with a volume parameter greater than or equal to 1. Notice how the playsound <volume> limits the sound's audible range. The axis distance is the distance of the sound listener (player) to the sound source. The corresponding volume axis' value is the factor for the playsound volume capped to 1, multiplied by the sound definition's volume to get the final volume of the sound you hear. As an expression this could be written as: final_volume = min(playsound_volume, 1) * graph_volume * sound_definition_volume.

Note: Attenuation by distance of the hearable sound's volume is not affected by the volume parameter given in the command.

For example, mob.ghast.affectionate_scream sets "min_distance": 100.0, but can only be heard from at most 16 blocks away when using /playsound with volume 1 to play it. Specifying a greater volume value increases the audible range. When using a large enough volume to hear the sound farther away, the sound will get quieter only after a distance of more than 100.0.

To make a sound which can be heard far away but also drops in volume continuously over distance, one can add e.g. "volume": 0.01and use large <volume> values in the playsound command. The high value for the /playsound volume will produce a large audible range (e.g. a volume of 4 is 64 blocks as calculated above), while the low volume will prevent the played sound from capping at 1.0 too soon.

Top Level Keys ​

In the example above, I showed two top-level fields: category and sounds. Sounds will be discussed in further detail below, but the other top-level keys will be discussed here:

Categories ​

Categories are used internally by the engine to decide how each sound is played. We can utilize different channels to get other effects.

CategoryNote
block
bottle
bucket
hostile
music
neutral
player
record
uiSounds in this category will ignore range limit
weather

min_distance ​

The distance from the sound source after which sound volume is attenuated. Default value: 0.0. It must be a float (eg. 1.0), or the property will be ignored.

max_distance ​

The distance from the sound source after which the sound volume is the quietest (if in range). It must be a float (eg. 1.0), or the property will be ignored.

Sound definitions ​

In the example above, I showed sounds as simply a list with a single path. This is good for simple sounds but does not have much power. For starts, I can add multiple sounds to the list. These sounds will be randomized when played:

RP/sounds/sound_definitions.json
json
{
	"format_version": "1.14.0",
	"sound_definitions": {
		"example.toot": {
			"category": "neutral",
			"sounds": [
				"sounds/trumpet",
				"sounds/trumpet2",
				"sounds/trumpet3"
			]
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

Additionally, we can define each sound as an object instead of a string. This allows us finer control and unlocks some new settings. The string/object style can be mixed and matched.

name ​

The path to the file, such as: "sounds/music/game/creative/creative1"

stream ​

Limits the sound only to be played a limited number of instances at a time. Will cause the game to not load the entire sound data into memory while playing, but rather in smaller parts while playing, thus using less memory. Good for improving performance on sound heavy worlds.

volume ​

How loud the sound should play, from 0.0 to 1.0. Sounds cannot be made more audible than initially encoded. Set to 1.0 by default. Sounds in custom resource packs can have working values greater than 1.0.

load_on_low_memory ​

Forces the loading of the sound even when nearing low memory. "load_on_low_memory" is now deprecated as of 1.16.0

pitch ​

The pitch of the sound (how low/high it sounds). Should be a positive value. For example, 2.3 will let the sound play 2.3 times as quickly and thus at higher pitch. Set to 1.0 by default.

is3D ​

true makes the sound directional. Set to true for all sounds by default. Ignored for music and ui sounds. Only sounds with false will play stereo sound.

interruptible ​

Set to true by default.

weight ​

If there is more than one sound in the list, the sound to be played is chosen randomly. "weight" (integer value like 5) will give the relative chance that this sound is chosen from the list. For example, if there are two sounds in the list, one with "weight": 10 and the other with "weight": 2, the first will be played approximately 5 times more likely than the second (accurately: 10 / (10 + 2) = 83.3% chance vs. 2 / (10 + 2) = 16.7% chance) . Set to 1 by default.

Example ​

Here is a more realistic example containing these options:

RP/sounds/sound_definitions.json#sound_definitions
json
"block.beehive.drip": {
    "category": "block",
    "max_distance": 8,
    "sounds": [
        {
            "name": "sounds/block/beehive/drip1",
            "load_on_low_memory": true
        },
        "sounds/block/beehive/drip2",
        "sounds/block/beehive/drip3",
        "sounds/block/beehive/drip4"
    ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13

sounds.json ​

If we want our sounds to run automatically, we can add them into the sounds.json file. This will tie the sound definitions directly to game events and cause them to play without needing to trigger with /playsound.

Sounds can be added into various categories:

CategoryNote
block_soundsContains hit, step, and break sounds for blocks
entity_soundsContains death, ambient, hurt, etc. sounds for entities (Including custom ones!)
individual_event_soundsContains sounds like beacon activation, chest-close, or explode
interactive_soundsWIP

Adding Entity Sounds ​

I assume that sounds can be added in other categories, but I personally only have experience adding sounds into the entities category. Entity sounds are automatically played at various points in the entities life-cycle.

Common events:

EventsNote
ambientPlayed randomly, such as grunts, clucks, or ghast noises
attackFor melee attacking
attack.strongFor attacking with behavior.delayed_attack
cast.spellFor starting summon
deathPlayed when it dies
fall.bigFor hitting the ground from a high height
fall.smallFor hitting the ground from a low height
hurtPlayed when damaged
prepare.attackFor finishing summon
roarFor roaring
shootFor shooting projectiles
splashFor splashing in the water
stepPlayed when the entity moves along the ground

There are also many sound events, which most likely trigger automatically, but which I don't have details for, such as:

Unknown Categories
ambient.in.water
breathe
death.in.water
eat
hurt.in.water
jump
mad
scream
sleep
sniff
spit
splash
stare
swim
warn

Example ​

RP/sounds.json
json
{
	"entity_sounds": {
		"entities": {
			"wiki:elephant": {
				"volume": 1,
				"pitch": [0.9, 1.0],
				"events": {
					"step": {
						"sound": "elephant.step",
						"volume": 0.18,
						"pitch": 1.1
					},
					"ambient": {
						"sound": "elephant.trumpet",
						"volume": 0.11,
						"pitch": 0.9
					}
				}
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Adding sounds to Animations ​

Sounds played in animations function based on short-name definitions in the RP entity file.

This example shows playing a wing-flap sound, synced with an animation.

RP/entities/dragon.json#minecraft:client_entity/description
json
"sound_effects": {
    "wing_flap": "wiki.dragon.wing_flap" //where wiki.dragon.roar is a sound defined in sound_definitions
}
1
2
3
RP/animations/dragon.json#animations/animation.dragon.flying
json
"sound_effects": {
    "3.16": {
        "effect": "wing_flap"
    }
}
1
2
3
4
5

Adding sounds to Animation Controllers ​

You can play sounds within animation controllers in a similar way that animations can be.

This example shows playing an explosion sound, synced using an animation controller.

RP/entities/custom_tnt.json#minecraft:client_entity/description
json
"sound_effects": {
    "explosion": "wiki.custom_tnt.explosion" //where wiki.custom_tnt.explosion is a sound defined in sound_definitions just like animation sounds.
}
1
2
3
RP/animation_controllers/custom_tnt.animation_controllers.json#controller.animation.custom_tnt
json
"states":{
    "default":{
        "transitions":[
            {
                "explode_state":"q.mark_variant == 1"
            }
        ]
    },
    "explode_state":{
        "sound_effects":[
            {
                "effect":"explosion"
            }
        ],
        "transitions":[
            {
                "default":"q.mark_variant == 0"
            }
        ]
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Contributors

Edit Sounds on GitHub

Bedrock Wiki by Bedrock OSS

"Minecraft" is a trademark of Mojang AB.

Bedrock OSS, Bedrock Wiki and bedrock.dev are not affiliated in any way with Microsoft or Mojang AB.

  • Privacy Policy
  • Join our Discord
  • Learn how to Contribute
  • Visit our Repository