Effects in Animations: Sound and Particle Keyframes

Before writing effect keyframes in an animation file, you must understand how Bedrock resolves effect names. Animations do not use full sound event names (like mob.zombie.say) or full particle identifiers (like minecraft:heart_particle) directly in the keyframe timeline. Instead, they reference a short name—an alias defined in the entity's client definition file (.entity.json).

This indirection allows you to reuse a single animation across multiple entities while swapping out the actual sounds or particles each entity plays. For example, a generic walk animation can trigger a short name called step, and each entity using that animation can map step to a different sound event in its own client entity file.

If an animation triggers a short name that is not listed in the entity's description, the game will silently fail to play the effect or throw a content log warning, even if the short name happens to match a real sound or particle identifier.

{
  "format_version": "1.10.0",
  "minecraft:client_entity": {
    "description": {
      "identifier": "custom:golem_guard",
      "materials": {
        "default": "entity_alphatest"
      },
      "textures": {
        "default": "textures/entity/golem_guard"
      },
      "geometry": {
        "default": "geometry.golem_guard"
      },
      "animations": {
        "smash": "animation.golem_guard.smash"
      },
      "sound_effects": {
        "woosh": "mob.irongolem.throw",
        "impact": "mob.irongolem.hit"
      },
      "particle_effects": {
        "dust": "minecraft:cauldron_explosion_emitter",
        "sparks": "custom:anvil_sparks"
      },
      "scripts": {
        "animate": [
          "smash"
        ]
      },
      "render_controllers": [
        "controller.render.default"
      ]
    }
  }
}

Once your short names are mapped in the client entity file, you can schedule them inside your animation file under the sound_effects object. This object sits at the same level as loop, animation_length, and bones inside a specific animation definition.

The keys inside sound_effects are timestamps in seconds, written as strings (such as "0.0" or "0.45"). At each timestamp, you can provide either a single effect object or an array of effect objects if you need multiple sounds to fire at the exact same frame.

Each sound effect object requires the effect property, whose value is the short name from your client entity file. The sound will automatically play at the entity's current world position in 3D space.

{
  "format_version": "1.8.0",
  "animations": {
    "animation.golem_guard.smash": {
      "animation_length": 1.5,
      "loop": false,
      "sound_effects": {
        "0.2": {
          "effect": "woosh"
        },
        "0.75": [
          {
            "effect": "impact"
          }
        ]
      },
      "bones": {
        "right_arm": {
          "rotation": {
            "0.0": [0, 0, 0],
            "0.2": [-120, 0, 0],
            "0.75": [30, 0, 0],
            "1.5": [0, 0, 0]
          }
        }
      }
    }
  }
}

Particle keyframes are defined in the particle_effects block of an animation, using the same timestamp structure as sounds. However, particles have spatial requirements that sounds do not: you usually want a particle to spawn at a specific bone (like a hand, mouth, or sword tip) rather than at the entity's feet.

To position a particle accurately, you first add a locator to a bone inside your geometry file (.geo.json). Locators are invisible reference points attached to a bone that inherit its transformations. In the animation's particle keyframe, you specify the locator property matching the name in your geometry.

You can also control whether the particle moves with the bone after spawning by setting bind_to_actor. When bind_to_actor is true, the particle emitter stays attached to the locator as the bone moves. When false (or omitted), the particle spawns at the locator's current world position and remains behind in the world as the entity walks away.

If your particle needs dynamic values from the entity, you can use pre_effect_script. This field takes a Molang string that executes on the entity right before the particle spawns, allowing you to set Molang variables (such as variable.charge_level) that the particle's own JSON can read.

{
  "format_version": "1.8.0",
  "animations": {
    "animation.golem_guard.smash": {
      "animation_length": 1.5,
      "particle_effects": {
        "0.75": [
          {
            "effect": "dust",
            "locator": "right_hand_locator",
            "bind_to_actor": false
          },
          {
            "effect": "sparks",
            "locator": "right_hand_locator",
            "bind_to_actor": true,
            "pre_effect_script": "variable.spark_scale = 2.0;"
          }
        ]
      }
    }
  }
}

For the locator property in a particle keyframe to work, the locator must exist in the entity's geometry file. Locators are defined inside a bone object using the locators key. Each locator is given a unique name across the model and an offset array in model space [x, y, z].

Because the locator is a child of the bone, it will rotate and pivot whenever that bone is animated. If you use Blockbench to create your models, you can add a locator using the Locator tool in the toolbar, place it inside the target bone group, and position it visually.

{
  "format_version": "1.12.0",
  "minecraft:geometry": [
    {
      "description": {
        "identifier": "geometry.golem_guard",
        "texture_width": 64,
        "texture_height": 64
      },
      "bones": [
        {
          "name": "right_arm",
          "pivot": [-6, 22, 0],
          "cubes": [
            {
              "origin": [-10, 10, -2],
              "size": [4, 12, 4],
              "uv": [0, 0]
            }
          ],
          "locators": {
            "right_hand_locator": [-8, 10, 0]
          }
        }
      ]
    }
  ]
}

While timeline animations are ideal for timed keyframes (like footsteps at 0.25s and 0.75s), sometimes you just want a sound or particle to fire immediately when an entity enters a specific state (such as beginning a jump or taking damage).

Resource pack animation controllers also support particle_effects and sound_effects arrays inside each state definition. These work identically to animation keyframes—referencing the short names from the client entity file and supporting locator, bind_to_actor, and pre_effect_script—except they trigger once upon entering the state rather than at a specific timestamp.

Applies to Bedrock Edition 1.8.0 and above for animations, and 1.10.0 and above for client entity definitions. All features are stable and do not require any experimental toggles.

Read out of the game itself, so the ids match the version you are building for.