Using /reload and What It Does Not Reload

Before `/reload` can pick up changes you make in your code editor, the game must be reading your pack directly from the development folders rather than from a cached copy inside the world save. Always place your working packs in `development_behavior_packs` and `development_resource_packs` inside your `com.mojang` directory. When you apply a pack from the standard `behavior_packs` folder, Bedrock copies the files into the world's `db` or pack folder on creation, and edits to the original source folder are ignored until you manually replace the world's copy.

You also need cheats enabled in the world settings to run `/reload` from the chat screen or from a command block. During active development, enable the Content Log GUI and Content Log File in Settings under Creator. Whenever `/reload` runs, the Content Log prints syntax errors from broken functions or unhandled exceptions thrown during script initialization, giving you immediate feedback if a change failed to parse.

If you are using Script API, your behavior pack `manifest.json` must declare a `script` module and the corresponding module dependency. Without a valid script module entry, `/reload` will only scan the `functions/` directory.

{
  "format_version": 2,
  "header": {
    "name": "Reload Test Pack",
    "description": "Development pack configured for script and function reloading.",
    "uuid": "a1b2c3d4-e5f6-4a5b-8c9d-0e1f2a3b4c5d",
    "version": [1, 0, 0],
    "min_engine_version": [1, 20, 80]
  },
  "modules": [
    {
      "type": "data",
      "uuid": "b2c3d4e5-f6a7-4b6c-9d0e-1f2a3b4c5d6e",
      "version": [1, 0, 0]
    },
    {
      "type": "script",
      "language": "javascript",
      "uuid": "c3d4e5f6-a7b8-4c7d-8e1f-2a3b4c5d6e7f",
      "entry": "scripts/main.js",
      "version": [1, 0, 0]
    }
  ],
  "dependencies": [
    {
      "module_name": "@minecraft/server",
      "version": "1.10.0"
    }
  ]
}

Despite its broad name, `/reload` only refreshes two parts of a behavior pack: `.mcfunction` files inside the `functions/` folder (including `tick.json` registrations) and JavaScript files executed by the Script API engine. When you run the command, the game halts all currently running scripts, tears down the JavaScript virtual machine environment, re-reads your `.mcfunction` and `.js` files from disk, and starts a fresh script execution context.

You can add entirely new `.mcfunction` files or import new `.js` modules while the world is open, and `/reload` will discover them as long as the main entry point in `manifest.json` already existed when the world loaded. Any in-memory JavaScript state—such as global variables, `Map` caches, or running `system.runInterval` timers—is completely wiped out and re-created from the top of your entry script.

Because the script environment boots *after* the world has already finished loading during a hot-reload, initialization events behave slightly differently than they do on initial world startup. Still, subscribing to `worldInitialize` or setting up an interval is the fastest way to confirm in chat that your latest save took effect.

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

const RELOAD_STAMP = "v1.0.4";

system.run(() => {
  world.sendMessage(`[Dev] Scripts loaded (${RELOAD_STAMP})`);
});

world.afterEvents.itemUse.subscribe((event) => {
  if (event.itemStack.typeId === "minecraft:stick") {
    event.source.sendMessage(`Stick used under build ${RELOAD_STAMP}`);
  }
});

Most data-driven JSON files in Bedrock are parsed once when the world initializes its registries, or even earlier when the game client boots. Running `/reload` does not re-parse entity definitions, block components, item components, recipes, loot tables, or any resource pack asset. Use the table below to know whether your latest edit requires `/reload`, backing out to the world selection screen (Save & Quit), or closing the Minecraft application completely.

Even when you do the right thing for JSON files—saving and quitting to the main menu, then loading the world again—changes to `BP/entities/*.json` can still look like they failed to load. This happens because Minecraft serializes an entity's active component groups and properties into the world database when the entity spawns. Reloading the world updates the base definition in memory, and Changes to baseline components in the root `components` block usually apply to existing mobs, but component groups added earlier remain stuck on those entities unless an event explicitly removes them.

For example, if you edit a custom mob's `minecraft:scale` or `minecraft:movement` inside a component group that was only added during `minecraft:entity_spawned`, existing mobs in your test area will not re-run `minecraft:entity_spawned` when you reopen the world. Always summon a fresh entity or add a temporary debug event to cycle component groups after reloading the world.

{
  "format_version": "1.20.80",
  "minecraft:entity": {
    "description": {
      "identifier": "wiki:test_dummy",
      "is_spawnable": true,
      "is_summonable": true
    },
    "component_groups": {
      "wiki:fast_mode": {
        "minecraft:movement": {
          "value": 0.45
        }
      }
    },
    "components": {
      "minecraft:type_family": {
        "family": ["dummy"]
      },
      "minecraft:health": {
        "value": 20,
        "max": 20
      },
      "minecraft:physics": {},
      "minecraft:Interact": {
        "interactions": [
          {
            "on_interact": {
              "filters": {
                "test": "is_family",
                "subject": "other",
                "value": "player"
              },
              "event": "wiki:refresh_groups"
            }
          }
        ]
      }
    },
    "events": {
      "minecraft:entity_spawned": {
        "add": {
          "component_groups": ["wiki:fast_mode"]
        }
      },
      "wiki:refresh_groups": {
        "remove": {
          "component_groups": ["wiki:fast_mode"]
        },
        "add": {
          "component_groups": ["wiki:fast_mode"]
        }
      }
    }
  }
}

Custom block and item components registered via the Script API (`blockComponentRegistry` and `itemComponentRegistry` inside the `worldInitialize` before-event) live on the border between JSON definitions and scripts. When you run `/reload`, the script environment restarts and fires the initialization sequence again, allowing you to change the *implementation* inside your JavaScript event handlers (such as `onStepOn`, `onPlayerInteract`, or `onUse`) on the fly.

However, you cannot register a brand-new custom component identifier with `/reload` and expect a block JSON you also just edited to recognize it. Because the block and item JSON registries are only built when the world first opens, the JSON side of the binding is locked until you Save & Quit and reload the world. Use `/reload` only to tweak the logic inside custom component callbacks that were already bound when the world started.

Resource packs have no equivalent to `/reload` in standard retail builds of Bedrock. Every change to a model, render controller, animation, sound, or particle file requires backing out to the main menu and reopening the world. When the world closes, the client flushes world-specific resource allocations and rebuilds them on the next load.

Block and item textures have an extra layer of caching that frequently trips up creators: stitched texture atlases. When you add a new texture file or edit `RP/textures/terrain_texture.json` or `RP/textures/item_texture.json`, simply exiting to the main menu and re-entering the world is sometimes not enough on Windows or mobile if the pack is also active in Global Resources or cached in memory. If your new texture renders as the magenta-and-black missing texture checkerboard or simply shows the old pixels after a Save & Quit, close the Minecraft application completely and relaunch it.

Applies to all modern Minecraft Bedrock Edition versions (1.19.0 through 1.21+). The /reload command and standard @minecraft/server Script API reloading work in stable releases without any experimental toggles enabled.

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