Player Geometry

Minecraft Bedrock uses several built-in geometry definitions for the player, depending on the equipped skin type and the active camera perspective. Classic skins use standard 4-pixel-wide arms, whereas slim skins use 3-pixel-wide arms. When the player switches to a first-person view, the game swaps to a stripped-down geometry that only renders the arms to save performance and prevent the head from blocking the camera.

In addition to the base body meshes, the player relies on a separate cape geometry and two humanoid armor geometries that inflate slightly to sit over the skin without z-fighting. When you open the vanilla client entity file for the player, you will see these identifiers mapped to short names.

If you are building a custom player model from scratch or modifying the vanilla rig in Blockbench, you must preserve the exact bone names and hierarchy if you want vanilla animations, held items, and armor to continue working. The game's internal rendering engine and animation controllers look for specific bone names to apply movements like sneaking, swimming, and bowing.

The hierarchy starts at a master bone named root. Inside root, the waist bone acts as the central pivot for the upper body. The body bone is parented to waist, and from body branch out the head, leftArm, rightArm, and cape. The leftLeg and rightLeg bones are parented directly to root rather than the waist, allowing the upper torso to twist independently of the lower body during attacks. Inside the arm bones, leftItem and rightItem act as zero-size pivot bones (or locators) where held weapons, tools, and blocks are rendered.

Second-layer skin details—such as the hat, jacket, sleeves, and pants—are separate cubes parented to their respective limb bones. They use the same UV layout as a standard 64x64 player skin and are slightly inflated using the cube inflate property so they hover just above the base skin.

{
  "format_version": "1.12.0",
  "minecraft:geometry": [
    {
      "description": {
        "identifier": "geometry.custom.player_rig",
        "texture_width": 64,
        "texture_height": 64,
        "visible_bounds_width": 2,
        "visible_bounds_height": 3,
        "visible_bounds_offset": [0, 1.5, 0]
      },
      "bones": [
        {
          "name": "root",
          "pivot": [0, 0, 0]
        },
        {
          "name": "waist",
          "parent": "root",
          "pivot": [0, 12, 0]
        },
        {
          "name": "body",
          "parent": "waist",
          "pivot": [0, 24, 0],
          "cubes": [
            {"origin": [-4, 12, -2], "size": [8, 12, 4], "uv": [16, 16]}
          ]
        },
        {
          "name": "head",
          "parent": "body",
          "pivot": [0, 24, 0],
          "cubes": [
            {"origin": [-4, 24, -4], "size": [8, 8, 8], "uv": [0, 0]},
            {"origin": [-4, 24, -4], "size": [8, 8, 8], "inflate": 0.5, "uv": [32, 0]}
          ],
          "locators": {
            "lead": [0, 24, 0]
          }
        },
        {
          "name": "rightArm",
          "parent": "body",
          "pivot": [-5, 22, 0],
          "cubes": [
            {"origin": [-8, 12, -2], "size": [4, 12, 4], "uv": [40, 16]}
          ]
        },
        {
          "name": "rightItem",
          "parent": "rightArm",
          "pivot": [-6, 15, 1]
        }
      ]
    }
  ]
}

To make the player use your custom geometry, you must edit the client entity definition located at RP/entity/player.entity.json. In the description object, add a new key-value pair under geometries that points to your custom model identifier. You can either replace the default and slim references entirely or add your geometry under a new short name.

Once registered in the geometries block, the model will not appear until a render controller tells the game to draw it. For a full model replacement, the simplest route is to map your custom geometry to both the default and slim short names so the vanilla render controllers automatically pick it up regardless of what skin the player has selected in the dressing room.

{
  "format_version": "1.10.0",
  "minecraft:client_entity": {
    "description": {
      "identifier": "minecraft:player",
      "materials": {
        "default": "entity_alphatest",
        "cape": "entity_alphatest",
        "animated": "player_animated"
      },
      "textures": {
        "default": "textures/entity/steve",
        "cape": "textures/entity/cape_invisible"
      },
      "geometry": {
        "default": "geometry.custom.player_rig",
        "slim": "geometry.custom.player_rig",
        "cape": "geometry.cape"
      },
      "render_controllers": [
        { "controller.render.player.first_person": "variable.is_first_person" },
        { "controller.render.player.third_person": "!variable.is_first_person && !variable.map_face_icon" }
      ],
      "enable_attachables": true
    }
  }
}

The player entity handles textures differently than any other mob. Even though textures/entity/steve is listed as the default texture in the client entity file, the vanilla player render controllers use the Texture.default array slot, which the game dynamically overrides with the player's chosen dressing room skin at runtime. If your custom geometry uses a layout larger than 64x64 or expects a specific monster or vehicle texture, the player's personal skin will wrap onto your custom cubes and look scrambled.

To force a custom texture onto your custom player geometry, you must define a new texture short name in RP/entity/player.entity.json (for example, custom_skin) and create or modify a render controller so it references Texture.custom_skin instead of Texture.default. Keep in mind that doing this hides the player's personal skin while that render controller is active.

Notice the enable_attachables field in the client entity description. Setting this to true allows the player model to render 3D armor, elytra, shields, and custom attachable items. Attachables bind their own bones to matching bone names on the player geometry. If you rename or delete rightArm, head, or body in your custom geometry, armor pieces and held attachables will fail to follow the player's movements and will either float at the world origin or disappear.

Whenvariable.is_first_person is true, the vanilla player switches to controller.render.player.first_person. This render controller uses visibility rules to hide every bone except rightArm and leftArm (along with their sleeve overlays). It does not actually swap to a different geometry file in modern versions; instead, it reuses the main geometry and relies on bone visibility inside the render controller and specific first-person animations to position the arms in front of the camera.

If you add extra bones to the upper body of your custom player geometry—such as wings, a backpack, or extra heads—you must ensure they are either parented to body (which the first-person render controller hides) or explicitly hidden in your first-person render controller's part_visibility array. Otherwise, those custom cubes will clip directly through the player's screen during gameplay.

Applies to Bedrock Edition 1.12.0 and newer for the modern geometry format, and 1.10.0 for client entity definitions. No experimental toggles are required to modify player geometry in a resource pack.

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