Using and Customizing Vanilla Particles

Every modern particle effect in Bedrock is driven by a JSON definition inside the base resource pack's particles folder. Inside each file, the effect is assigned an identifier under the description object, such as minecraft:heart_particle or minecraft:villager_happy. When the game, a command, or an entity requests a particle, it looks up this exact string identifier rather than the file name.

A small number of older effects in the game are legacy engine particles that predate the data-driven JSON system. While most common effects have been converted to JSON definitions that you can inspect in the official vanilla sample packs, a few hard-coded emitters still rely on internal C++ logic or accept engine-passed Molang variables—like block tinting or potion colors—that do not work if you spawn them manually in the world without context.

The fastest way to test a vanilla particle in-game is with the /particle command. It requires the full namespace identifier and a three-dimensional coordinate. Because the command simply spawns an emitter at a point in space, particles that do not require entity-specific Molang variables will appear immediately.

When building gameplay logic with the @minecraft/server Script API, you can spawn vanilla particles directly from a Dimension object using the spawnParticle method. If a vanilla particle expects dynamic colors or speeds, you can pass a MolangVariableMap as the third argument, though for standard effects like smoke or flames you only need the identifier and a location vector.

import { world } from "@minecraft/server";

world.afterEvents.itemUse.subscribe((event) => {
  const player = event.source;
  if (event.itemStack.typeId === "minecraft:blaze_rod") {
    const headLoc = player.getHeadLocation();
    player.dimension.spawnParticle("minecraft:totem_particle", headLoc);
  }
});

Rather than calling commands or scripts every tick, the standard way to attach a vanilla particle to a custom entity is through its client entity definition and a resource pack animation or animation controller. First, you map a short reference name to the full vanilla identifier inside the particle_effects object of the client entity file.

Once the short name is registered on the entity, any animation or animation controller running on that entity can trigger the effect using the short name. You can optionally bind the emitter to a specific bone in the entity's geometry by specifying the locator or bone name in the animation timeline.

{
  "format_version": "1.10.0",
  "minecraft:client_entity": {
    "description": {
      "identifier": "custom:flame_golem",
      "materials": {
        "default": "entity_alphatest"
      },
      "textures": {
        "default": "textures/entity/flame_golem"
      },
      "geometry": {
        "default": "geometry.flame_golem"
      },
      "particle_effects": {
        "ambient_fire": "minecraft:mobflame_single",
        "death_poof": "minecraft:huge_explosion_emitter"
      },
      "animations": {
        "idle_particles": "animation.flame_golem.idle_particles"
      },
      "scripts": {
        "animate": [
          "idle_particles"
        ]
      },
      "render_controllers": [
        "controller.render.default"
      ]
    }
  }
}

In your resource pack animations file, the particle_effects timeline triggers the short name you defined in the client entity. Each timestamp key holds an object or an array of objects declaring which effect to play. This separation lets you swap out the vanilla particle in the client entity file later without rewriting your animation timings.

{
  "format_version": "1.8.0",
  "animations": {
    "animation.flame_golem.idle_particles": {
      "loop": true,
      "animation_length": 2.0,
      "particle_effects": {
        "0.0": {
          "effect": "ambient_fire",
          "locator": "head_locator"
        },
        "1.0": {
          "effect": "ambient_fire",
          "locator": "head_locator"
        }
      }
    }
  }
}

Hundreds of particle definitions exist in the base game, but many rely on internal context variables to set their UV coordinates or tinting. The identifiers listed below are self-contained and work reliably out of the box with /particle, Script API calls, and entity animations.

If you want to change how a vanilla particle behaves globally—for example, making torch flames blue everywhere in the world—you can create a particle JSON file in your resource pack under RP/particles/ and give its description the exact same identifier as the vanilla particle (such as minecraft:basic_flame_particle). When your resource pack is applied at the top of the stack, the game will replace the built-in definition with yours.

For custom add-ons, it is usually safer to copy a vanilla particle file from the official sample resource pack, rename the file, and change the identifier to your own namespace (for instance, mypack:blue_flame). Most vanilla particles pull their sprites from the shared atlas at textures/particle/particles, meaning your cloned particle can keep using the vanilla texture path and UV coordinates while you freely edit its motion, emitter rate, or color tinting components.

{
  "format_version": "1.10.0",
  "particle_effect": {
    "description": {
      "identifier": "custom:blue_heart",
      "basic_render_parameters": {
        "material": "particles_alpha",
        "texture": "textures/particle/particles"
      }
    },
    "components": {
      "minecraft:emitter_rate_instant": {
        "num_particles": 1
      },
      "minecraft:emitter_lifetime_once": {
        "active_time": 0.1
      },
      "minecraft:emitter_shape_point": {},
      "minecraft:particle_lifetime_expression": {
        "max_lifetime": 1.0
      },
      "minecraft:particle_initial_speed": 1.0,
      "minecraft:particle_motion_dynamic": {
        "linear_acceleration": [0, 2.0, 0],
        "linear_drag_coefficient": 2.0
      },
      "minecraft:particle_appearance_billboard": {
        "size": [0.2, 0.2],
        "facing_camera_mode": "lookat_xyz",
        "uv": {
          "texture_width": 128,
          "texture_height": 128,
          "uv": [0, 40],
          "uv_size": [8, 8]
        }
      },
      "minecraft:particle_appearance_tinting": {
        "color": [0.2, 0.5, 1.0, 1.0]
      }
    }
  }
}

Applies to Bedrock Edition 1.10.0 and later for JSON particle definitions and client entities. No experimental toggles are required for overriding, referencing, or spawning vanilla particles.

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