Recipe Files

Every .yml/.yaml file under plugins/AstralRecipes/recipes/ (walked recursively) is one recipe. The required type key picks the reader — see Recipe types for the id table and the loading lifecycle. This page covers the YAML shape of each type; how a loaded recipe then behaves at each station is on Crafting behavior.

Common fields

Field	Type	Required	Description
`type`	String	Yes	One of the seven recipe types. Case-sensitive.
`key`	Key	Yes	The recipe's identity, as a namespaced key (`astralrecipes:ruby_sword`). A bare value is read as `minecraft:<value>`. An unparsable value throws `Invalid recipe key: <value>`.
`result`	item-stack	Yes	The produced item. Every type uses `result` — the old `output`/`input` field names from the AstralEssentials-era blueprints are gone.

result is a full AstralCore ItemStackWrapper, so material/copy-from, name, lore, amount, enchantments, item-flags, and components are all available — see Menu Items § item-stack.

Ingredients

Every ingredient slot — the values of ingredients on a shaped recipe, the entries of the ingredients list on a shapeless one, and the ingredient key on a cooking or stonecutter recipe — is parsed by the same Ingredient serializer, and accepts three forms:

# 1. a single item id
R: diamond

# 2. a list of accepted item ids (any one of them satisfies the slot)
R: [ gold_ingot, copper_ingot ]

# 3. a section, when you need count or consume
R:
  count: 2
  consume: false
  items:
    - ce:mypack:ruby

Field	Type	Default	Description
`items`	String or list of String	—	Required in the section form. The accepted item ids; at least one.
`count`	Integer	`1`	How many of the item the slot requires. Must be ≥ 1. Only a stack-size gate — see Consumption for what is actually removed at each station.
`consume`	Boolean	`true`	`false` leaves the matched item in the grid (a catalyst or tool). Honoured at the crafting table only; a recipe with a kept ingredient is never run by a crafter.

Item ids

Each id is resolved once at load time through AstralPaperAPI.provideItemStack(namespace, key), splitting on the first ::

Form	Resolves to	Example
bare name	A vanilla material (`Registry.MATERIAL`, lowercased)	`diamond`, `oak_log`
`vanilla:<id>`	The same vanilla material, via the `vanilla` supplier	`vanilla:diamond`
`ce:<pack>:<id>`	A CraftEngine item (namespace `ce`, key `<pack>:<id>`)	`ce:mypack:ruby`
`hdb:<id>`	A HeadDatabase head	`hdb:1234`
`<supplier>:<id>`	Any other registered `ItemStackSupplier`. Plugins register their own — `astralitems`, `heads`, `crates`, `scrolls`, `pets`, `jobs`, `spawners`, …	`astralitems:excalibur`

An id that resolves to nothing (or to air) fails the whole file with Unknown recipe item: <id>.

Shaped — `shaped`

Field	Type	Required	Description
`pattern`	List of String	Yes	1–3 rows, each at most 3 characters, all the same width. A space is an empty cell.
`ingredients`	Map of Char → ingredient	Yes	Maps a pattern symbol to an ingredient. Each key must be exactly one non-space character.
`result`	item-stack	Yes	The crafted output.

The pattern is trimmed of empty leading/trailing rows and columns before matching, and so is the player's grid — position within the crafting window never matters, only the shape. A 2×2 shape therefore works in the inventory grid as well as at a table.

type: shaped
key: astralrecipes:ruby_sword

pattern:
  - " R "
  - " R "
  - " S "

ingredients:
  R: ce:mypack:ruby
  S: stick

result:
  material: DIAMOND_SWORD
  amount: 1
  name: "<red>Ruby Sword"
  lore:
    - "<gray>Forged from pure ruby."
  enchantments:
    sharpness: 5

Shapeless — `shapeless`

Field	Type	Required	Description
`ingredients`	List of ingredient	Yes	1–9 entries, each an ingredient.
`result`	item-stack	Yes	The crafted output.

The grid matches when its non-empty slots correspond exactly to the listed ingredients — one distinct slot per ingredient, in any arrangement. To require two of an item, list it twice (or use count: 2 on a single entry to require a stack of two in one slot).

type: shapeless
key: astralrecipes:ruby_block

ingredients:
  - diamond
  - diamond
  - { count: 1, items: [ gold_ingot, copper_ingot ] }

result:
  material: DIAMOND_BLOCK
  amount: 1
  name: "<aqua>Compressed Gems"

Stonecutter — `stonecutter`

Field	Type	Required	Description
`ingredient`	ingredient	Yes	The item to cut.
`result`	item-stack	Yes	The item produced.

type: stonecutter
key: astralrecipes:oak_stairs_from_log

ingredient: oak_log

result:
  material: OAK_STAIRS
  amount: 4

Stonecutting is driven entirely by vanilla through the backing StonecuttingRecipe — AstralRecipes has no stonecutter listener. The backing recipe uses a component-exact RecipeChoice.ExactChoice, so count and consume have no effect there and provider-backed custom items generally will not match. See Stonecutter.

Cooking — `furnace`, `blasting`, `smoking`, `campfire`

All four cooking types share one shape and differ only in which station they belong to.

Field	Type	Required	Description
`ingredient`	ingredient	Yes	The item to cook.
`result`	item-stack	Yes	The item produced.
`experience`	Float	No	XP granted per cook. Default `0`.
`cooking-time`	Integer	No	Ticks to finish, before station speed modifiers. Must be ≥ 1. Defaults to the station's vanilla time: 200 furnace, 100 blasting, 100 smoking, 600 campfire.

type: furnace
key: astralrecipes:smelt_ruby

ingredient: raw_iron

experience: 0.7
cooking-time: 200

result:
  material: EMERALD
  amount: 1
  name: "<green>Refined Ruby"

The station is started by the backing vanilla cooking recipe, and AstralRecipes then forces its own result when the cook completes — which is what lets a custom item whose base material already has a vanilla smelt produce your output instead. Vanilla consumes exactly one input item regardless of count; see Cooking stations.

Validation

The loader rejects individual files without blocking the rest of recipes/. Every failure below is logged as Failed to load configuration file: <path> with the cause, and only that file is skipped:

Message	Cause
`Missing recipe 'type'`/`Unknown recipe type: <v>`	No `type` key, or a value not in the type table.
`Missing recipe 'key'`/`Invalid recipe key: <v>`	No `key`, or one that isn't a valid namespaced key.
`Unknown recipe item: <id>`	An ingredient id resolved to nothing — a typo, a `minecraft:` prefix, or a provider that had not loaded its items yet.
`Ingredient section requires an 'items' entry`	Section form with no `items`.
`Ingredient 'count' must be at least 1`	`count: 0` or negative.
`Invalid ingredient symbol: '<s>'`	A shaped `ingredients` key that isn't a single non-space character.
`Shaped recipe requires a non-empty 'pattern'`/`All shaped pattern rows must be the same width`/`Shaped pattern can have at most 3 rows`/`Shaped pattern rows can be at most 3 wide`	Malformed shaped pattern.
`Shapeless recipe requires an 'ingredients' list`/`… at least one ingredient`/`… at most 9 ingredients`	Malformed shapeless ingredient list.
`<type> recipe requires an 'ingredient'`/`… requires a 'result'`	A missing required node.
`'cooking-time' must be at least 1 tick`	`cooking-time: 0` or negative.

A recipe that loads fine but whose backing Bukkit recipe cannot be built is a softer failure — it is logged as Skipping backing recipe for <key>: <error> and the recipe still works at the crafting table, just without a recipe-book entry or crafter support.

Reloading

/core reload AstralRecipes (see Reload) re-runs the full unload/read/register sequence, so file changes apply without a restart.

Last modified: 03 September 2026