Raw Text Format and Localization

Every raw text payload in commands and JSON files starts with a root object containing a `rawtext` array. The game evaluates each object inside that array in order and concatenates the results into a single string with no automatic spaces between elements. If you want spaces or line breaks (`\n`), you must include them explicitly inside your text literals or translation strings.

Each element in the `rawtext` array uses one primary key to determine what kind of content it renders. You cannot mix multiple primary keys (like `text` and `score`) inside the same array item; instead, place them as separate objects inside the `rawtext` array.

Hardcoding English strings inside functions or scripts makes a pack impossible to translate cleanly. By using the `translate` key, the server only sends the translation identifier to the client, and each player's client resolves that identifier against their own selected language in `RP/texts/*.lang`.

When a `.lang` entry contains positional tokens like `%s` or numbered tokens like `%1$s` and `%2$s`, you pair `translate` with the `with` key. While `with` accepts a simple array of plain strings (`["10", "Apples"]`), its real power comes from passing a nested `rawtext` object. Doing so lets you inject live entity selectors, scores, or even secondary translation keys directly into the middle of a translated sentence.

pack.arena.victory=§6%1$s§r won the match with §a%2$s§r points!
item.custom_coin.name=Gold Coin

The `selector` and `score` components pull live world data at the exact moment the message is sent. In a `selector` component, any valid target selector string works, and if multiple entities match, the game formats them into a comma-separated list automatically. Be aware that selector resolution depends on the execution context: using `@s` requires an execution context set by `/execute` or an NPC dialogue trigger.

For `score`, you pass an object containing `name` and `objective`. Setting `name` to `*` displays the score of whichever player is currently reading the message, which is useful when broadcasting a single `/tellraw @a` command where every player should see their own personal balance.

{
  "format_version": "1.17.0",
  "minecraft:npc_dialogue": {
    "scenes": [
      {
        "scene_tag": "match_summary",
        "npc_name": {
          "rawtext": [
            {
              "translate": "entity.npc.name"
            }
          ]
        },
        "text": {
          "rawtext": [
            {
              "translate": "pack.arena.victory",
              "with": {
                "rawtext": [
                  {
                    "selector": "@p[tag=arena_winner]"
                  },
                  {
                    "score": {
                      "name": "@p[tag=arena_winner]",
                      "objective": "arena_points"
                    }
                  }
                ]
              }
            }
          ]
        }
      }
    ]
  }
}

When working with `@minecraft/server`, methods such as `Player.sendMessage()`, `Dimension.sendMessage()`, and `ScreenDisplay.setTitle()` accept either a plain string or a `RawMessage` object. Notice that in the Script API, the top-level wrapper is optional when passing a single component, though you still use `rawtext` arrays when chaining multiple fragments or nesting inside `with`.

Keep in mind that `with` inside a Script API `RawMessage` is strict about types: it only accepts an array of strings (`string[]`) or a nested `RawMessage`. You cannot pass raw numbers or booleans into `with` without converting them to strings first (for example, `score.toString()`), or the script will throw a native type error.

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

export function announceWinner(player) {
  const message = {
     translate: "pack.arena.victory",
     with: {
       rawtext: [
         { text: player.name },
         {
           score: {
             name: player.name,
             objective: "arena_points"
           }
         }
       ]
     }
  };
  world.sendMessage(message);
}

Bedrock raw text does not use JSON keys like `color` or `bold` on text objects. Instead, all visual styling is handled inline using the section sign (`§`) followed by a formatting code, either inside your `.lang` file or inside the `text` string itself. When styling inside a `translate` template, always place `§r` after a `%s` token if you want to prevent a colored player name or item name from bleeding its color into the rest of the sentence.

When writing raw text inside `.mcfunction` files or JSON files, quotes inside a string must be escaped as `\"`, and line breaks are written as `\n`.

Stable in all current Bedrock versions (1.16.0 and above for commands and dialogue; 1.19.50+ for stable @minecraft/server RawMessage support). No experimental toggles required.

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