How to make an ItemsAdder model

Sep 7, 20263 min read

Making a model for ItemsAdder is not one file. It is four pieces wired together: the model geometry, the texture, the plugin's config file, and the resource pack that reaches the player. Here is what each one is, where it goes, and where people get stuck.

First, Minecraft does not really support new items

That custom chair on a server is not a chair. The server hands the player an ordinary item — usually paper — with a marker on it. The resource pack on the player's machine reads that marker and says "don't draw this as paper, draw it with this model instead." ItemsAdder, Oraxen, Nexo and CraftEngine are all built on that same trick.

Two things follow from this. A player without the resource pack sees paper, not your model. And the model file runs on the player's client, not on the server — the only thing living server-side is the item's behaviour: where it can be placed, its hitbox, what it drops when broken.

The four pieces

Piece	What it is	Where it goes
Model JSON	Box coordinates and where each face sits on the texture	resourcepack/assets/<namespace>/models/
Texture (PNG)	The atlas stretched across the model's faces	resourcepack/assets/<namespace>/textures/
Config (yml)	The item's name, material, behaviour and hitbox	configs/
Resource pack	Everything above, bundled for the player	ItemsAdder builds it

What the model JSON looks like

A Minecraft model is a list of axis-aligned boxes, nothing more. Each box has a start corner (from) and an end corner (to), measured inside a 16-unit cube: 16 units is exactly one block.

json

{
  "textures": { "0": "minemodelai:table", "particle": "minemodelai:table" },
  "elements": [
    {
      "name": "top",
      "from": [1, 12, 1],
      "to": [15, 14, 15],
      "faces": {
        "up":   { "uv": [0, 0, 8, 8], "texture": "#0" },
        "down": { "uv": [8, 0, 16, 8], "texture": "#0" }
      }
    }
  ]
}

The uv field says which part of the texture atlas paints that face. Doing this by hand is the slow part of modelling: finding room on the atlas for all six faces of every box and getting the coordinates right. Blockbench does it for you.

The config file

This is where ItemsAdder learns about the item: the namespace, an id, a display name, which vanilla item it rides on, and which model to use.

yaml

info:
  namespace: my_pack
items:
  oak_table:
    display_name: "Oak table"
    resource:
      generate: false
      material: PAPER
      model_path: oak_table
    behaviours:
      furniture:
        solid: true
        placeable_on:
          floor: true
          walls: false
          ceiling: false
        hitbox:
          width: 1
          length: 1
          height: 1

generate: false matters: it tells ItemsAdder not to build a texture itself but to use the model file you prepared. The furniture behaviour turns the item into something you place on the ground; without it you get an ordinary held item.

Folder layout

All of it goes under plugins/ItemsAdder/contents/ as one tree:

text

contents/
  my_pack/
    configs/
      oak_table.yml
    resourcepack/
      assets/
        my_pack/
          models/oak_table.json
          textures/oak_table.png

Then /iazip on the server builds and stages the resource pack, and /iareload re-reads the config.

Where people get stuck

Purple-and-black checks: the texture path is wrong. The textures entry in the model JSON must read <namespace>:<file> and match the folder exactly, casing included.
Item in hand but no model: the resource pack never reached the player. If your server does not require the pack, they may have declined it.
Model floating or sunk into the ground: the furniture scale and drop are off. ItemsAdder renders furniture in the head slot of a small armor stand, so the scale has to compensate.
Hitbox bigger than the model: hitbox is measured in blocks, not model units. A table two blocks wide is width: 2.

How long this takes by hand

For a simple table: half an hour in Blockbench, about as long again for the texture, plus config and trial and error. Several times that for your first one, because you are learning Blockbench, UV layout and the plugin's expected folder structure all at once.

MineModel AI produces exactly those four pieces: you write a description and get back the model JSON, the texture atlas and a filled-in yml as a folder tree ready to drop into contents/. The same run also gives you Nexo, Oraxen, CraftEngine, Blockbench and plain resource pack versions.