Overwriting Vanilla Assets and Definitions

Minecraft Bedrock resolves assets and data by assembling a virtual file system from all active packs on a world or in the global settings. At the very bottom of this stack sits the base vanilla pack (along with internal engine packs for newer game updates). Above the vanilla pack sit user-applied packs, ordered from lowest priority at the bottom to highest priority at the top.

When the game requests a resource—whether by its file path or by its internal JSON identifier—it searches from the top of the pack stack downward. For non-merging files like textures and audio, the very first file found at the expected path wins, and anything below it in the stack is ignored. For JSON registry files that support merging, the game loads the bottom-most vanilla file first and sequentially applies keys from higher packs on top of it.

Because the top pack always wins conflicts, the order in which a player arranges their packs in the world settings directly dictates which add-on's changes survive when two packs touch the same vanilla asset.

Binary files such as PNG textures, OGG audio files, and font images cannot be merged. To overwrite them, you simply mirror the exact folder structure and filename used by the vanilla Resource Pack. You do not need to edit any JSON definition if your only goal is to swap the visual or audio asset.

For image textures, Bedrock allows format substitution across the same base path. If the vanilla game provides a texture as a `.png`, your pack can supply a `.tga` file with the exact same name and directory path, and the engine will recognize it as a valid override. However, keep the base filename and folder casing identical to the vanilla path, as some platforms treat file paths as case-sensitive.

For JSON data files, Bedrock uses two different resolution rules depending on the system: identifier-based replacement and path-based key merging. Most modern actor, item, and recipe definitions rely on the `identifier` field inside the JSON rather than the filename itself. If you place a file at `BP/entities/my_custom_zombie_tweak.json` and set its identifier to `minecraft:zombie`, it will completely replace the vanilla `BP/entities/zombie.json` file.

When an identifier-based file is overwritten, it does not merge with the vanilla file. If you define `minecraft:zombie` with only a `minecraft:health` component, your zombie will lose all movement, attack behaviors, collision boxes, and loot drops because you omitted the rest of the vanilla components. To safely modify a vanilla entity, copy the entire vanilla JSON file from the official vanilla template pack first, then edit only the parts you want to change.

In contrast, client entity definitions (`RP/entity/*.json`) and registry files (`RP/textures/terrain_texture.json`, `RP/sounds/sound_definitions.json`) merge or override specific keys. In a client entity file, redefining `minecraft:zombie` allows you to overwrite just the `textures.default` entry or a single animation while leaving the rest of the vanilla client definition intact, provided you match the vanilla `format_version` structure.

{
  "format_version": "1.10.0",
  "minecraft:client_entity": {
    "description": {
      "identifier": "minecraft:zombie",
      "textures": {
        "default": "textures/entity/zombie/custom_zombie"
      }
    }
  }
}

Certain files act as master registries for the entire Resource Pack, such as `RP/textures/terrain_texture.json`, `RP/textures/item_texture.json`, `RP/blocks.json`, and `RP/sounds/sound_definitions.json`. If these files completely replaced each other, two resource packs could never be used together. Instead, Bedrock merges the top-level JSON objects inside them across all active packs.

When you want to overwrite a single vanilla terrain texture shortname or add a new one, you should only include the specific keys you are changing or adding inside your `terrain_texture.json`. Do not copy the entire multi-thousand-line vanilla file into your pack. Including every vanilla entry bloats your pack and forces your pack to overwrite changes made by any lower-priority pack in the stack.

{
  "resource_pack_name": "vanilla",
  "texture_name": "atlas.terrain",
  "padding": 8,
  "num_mip_levels": 4,
  "texture_data": {
    "stone": {
      "textures": "textures/blocks/my_custom_stone"
    }
  }
}

Loot tables (`BP/loot_tables/`) and trade tables (`BP/trading/`) do not have an `identifier` field inside their JSON structure. Instead, they are referenced directly by their relative file path from within entity behaviors or block definitions. To overwrite the drops of a vanilla creeper, your file must be placed at the exact path `BP/loot_tables/entities/creeper.json`. Like behavior entities, loot tables do not merge pools; your file completely replaces the vanilla table at that path.

Spawn rules (`BP/spawn_rules/`) and recipes (`BP/recipes/`) use internal identifiers under their `description` block. To overwrite a vanilla recipe or spawn rule, your JSON must use the exact `minecraft:` identifier of the target rule or recipe. For recipes specifically, if you want to alter how a vanilla item is crafted, copy the vanilla recipe file, keep its original `description.identifier`, and change the ingredients or result.

{
  "pools": [
    {
      "rolls": 1,
      "entries": [
        {
          "type": "item",
          "name": "minecraft:gunpowder",
          "functions": [
            {
              "function": "set_count",
              "count": {
                "min": 2,
                "max": 4
              }
            }
          ]
        }
      ]
    }
  ]
}

Whenever Mojang updates an existing mob or block in a recent version of the game, those changes are frequently shipped inside internal built-in packs (such as `vanilla_1.20.0` or `vanilla_1.21.0`) rather than the base `vanilla` folder. If you extract a template from the base `vanilla` folder to start your overwrite, you might accidentally grab an outdated version of that entity that lacks newer components or animations.

Always inspect the highest versioned internal vanilla folder when copying a vanilla JSON file to modify. Furthermore, make sure the `format_version` in your overwritten file is at least as high as the version used by the latest internal vanilla pack; in several subsystems, the engine ignores an override or parses it with legacy rules if its `format_version` is older than the base game's definition.

Applies to all modern Minecraft Bedrock versions (1.16.0 through 1.21+). No experimental toggles are required to overwrite vanilla assets, loot tables, entities, or recipes.

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