Blockbench: Modeling, Texturing & Animating

When starting a new asset in Blockbench, choosing the correct project format on the start screen is critical because each format enforces the specific technical limits of its target game engine. For Bedrock add-ons, you will almost always select either Bedrock Entity or Bedrock Block. If you accidentally build your model in the Generic Model or Java Block/Item format, the exported files will not work in a Bedrock resource pack without conversion, and you may use features like per-cube rotations that the format cannot support.

In the File > Project settings menu, you must configure two essential fields before exporting: the File Name and the Model Identifier. The Model Identifier is the exact string the game uses to look up your geometry inside the resource pack. For entities and attachables, it must begin with the geometry. prefix (such as geometry.my_pack.crab). For custom blocks, it is best practice to use a namespaced identifier like geometry.my_pack.statue to prevent collisions with other add-ons loaded in the same world.

Always save a working copy of your project in Blockbench's native .bbmodel format alongside your exported game files. The .bbmodel file keeps your geometry, textures, and animations bundled in a single workspace file, preserving layer data and hidden helper cubes that get stripped out when you export to the final Bedrock JSON formats.

A Bedrock model is built from two core elements in the Outliner panel: bones (represented as folders) and cubes. Cubes are the visible 3D boxes that hold your texture, while bones act as invisible groups that define how the model moves and inherits transformations. Even on a static block model that never animates, you should organize your cubes inside at least one root bone so the engine transforms the geometry predictably.

Every bone has a pivot point, displayed in the viewport as a three-axis gizmo when the Pivot Tool is active. The pivot point is the exact coordinate around which a bone rotates and scales during an animation. If you are modeling a quadruped leg, the leg bone's pivot point must be placed at the hip joint where it meets the body, not at the center of the leg cube or at the floor. Setting pivots accurately during the modeling phase saves hours of frustration when you move to the Animate tab.

To avoid texture flickering—known as Z-fighting—where two cubes overlap at the exact same coordinates, use the Inflate field in the transform toolbar. Adding a tiny inflation value like 0.05 or 0.1 pushes the faces of a cube outward evenly on all axes without altering its UV texture mapping. This is the standard way to model tight-fitting armor layers, eyes, or clothing overlays on top of a base limb.

{
  "format_version": "1.12.0",
  "minecraft:geometry": [
    {
      "description": {
        "identifier": "geometry.my_pack.crab",
        "texture_width": 32,
        "texture_height": 32,
        "visible_bounds_width": 2.0,
        "visible_bounds_height": 1.5,
        "visible_bounds_offset": [0.0, 0.25, 0.0]
      },
      "bones": [
        {
          "name": "root",
          "pivot": [0, 0, 0]
        },
        {
          "name": "body",
          "parent": "root",
          "pivot": [0, 2, 0],
          "cubes": [
            {
              "origin": [-4, 1, -3],
              "size": [8, 4, 6],
              "uv": [0, 0]
            }
          ]
        }
      ]
    }
  ]
}

Once your geometry is blocked out and your pivots are placed, switch to the Paint tab to create a texture. Clicking Create Texture generates a blank canvas and automatically maps your cubes onto it. You can choose between two UV mapping modes: Box UV and Per-Face UV. Box UV unfolds all six sides of a cube into a fixed T-shaped cross pattern, which is compact and required by older model formats. Per-Face UV lets you position, resize, and rotate each of the six faces independently on the canvas, making it much easier to share textures across identical parts and pack islands tightly.

Pixel density is determined by the relationship between a cube's size in model units and the resolution of your texture canvas. Vanilla Minecraft uses a 16x16 pixel density per block unit. To keep your asset visually consistent with the base game, keep your cube sizes as whole integers and let Blockbench auto-calculate the template resolution at 16x. Avoid mixing fractional cube sizes with standard UV grids unless you intentionally want stretched or higher-resolution pixels on a detail piece.

Before you start painting details, double-check your geometry sizes. Under Box UV, resizing a cube later will change the footprint of its UV island, forcing you to rearrange the layout and potentially ruining pixels you have already painted. When exporting, save the texture as a .png file directly into your resource pack's RP/textures/entity/ or RP/textures/blocks/ directory.

Switching to the Animate tab reveals the timeline and animation list. Create a new animation and give it a standard Bedrock identifier, which always starts with animation. followed by your pack namespace, the entity name, and the action—for example, animation.my_pack.crab.walk. In the animation properties menu, choose whether the animation should loop continuously, hold on the last frame when finished, or play once and reset.

In Bedrock Edition, you can only animate bones, never individual cubes. Select a bone in the Outliner, move the timeline playhead to a timestamp, and rotate, move, or scale the bone in the viewport to automatically drop a keyframe. For mechanical or snappy motion, alternate between Linear and Step interpolation modes on your keyframes. For organic creatures, either use Smooth (Catmull-Rom) keyframes or bypass keyframe dots entirely by typing Molang math expressions directly into the X, Y, or Z channels of a single frame at 0.0.

Using Molang expressions like math.sin(q.anim_time * 360) * 15 inside a rotation channel produces continuous, framerate-independent oscillation for walking legs, breathing chests, or wagging tails while keeping the exported .animation.json file tiny. You can preview most common time and life queries directly in the Blockbench viewport using the variable sliders in the left sidebar.

{
  "format_version": "1.8.0",
  "animations": {
    "animation.my_pack.crab.idle": {
      "loop": true,
      "bones": {
        "body": {
          "position": [0, "math.sin(q.anim_time * 180) * 0.25", 0],
          "rotation": [0, 0, "math.cos(q.anim_time * 90) * 2"]
        }
      }
    }
  }
}

Exporting your model, texture, and animations into the right folders does not automatically make them appear in-game. You must link their identifiers together inside a client entity definition file (for mobs and projectiles) or inside terrain_texture.json and blocks.json (for custom blocks). The client entity file lives in RP/entity/ and maps short internal names—like default—to the full identifiers you created in Blockbench.

Pay close attention to the difference between file paths and identifiers in this file. Textures are referenced by their folder path relative to the resource pack root (without the .png extension), whereas geometries and animations are referenced by the string identifier written inside their JSON files, regardless of what you named the .geo.json or .animation.json files on disk.

{
  "format_version": "1.10.0",
  "minecraft:client_entity": {
    "description": {
      "identifier": "my_pack:crab",
      "materials": {
        "default": "entity_alphatest"
      },
      "textures": {
        "default": "textures/entity/crab"
      },
      "geometry": {
        "default": "geometry.my_pack.crab"
      },
      "animations": {
        "idle": "animation.my_pack.crab.idle"
      },
      "scripts": {
        "animate": [
          "idle"
        ]
      },
      "render_controllers": [
        "controller.render.default"
      ]
    }
  }
}

Applies to Minecraft Bedrock 1.12.0 and later for geometry (format_version 1.12.0) and 1.8.0+ for animations. Custom 3D block models using minecraft:geometry require behaviour pack format_version 1.19.40 or higher. No experimental toggles are required for standard entity, attachable, or block models.

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