BIOMES DOCUMENTATION
Version: 1.13.0.15

This is documentation for a beta release of Minecraft. New features, components, and capabilities in this release are not final and might change without notice before the final release.
Be sure to check the documentation once the release is out of beta if your add-on isn't working properly. Resource and Behavior Packs created for the beta are not guaranteed to work on the final release.

Index

Back to top

Adding biomes

Biomes are read from JSON files in the biomes subfolders of behavior packs. Loading enforces one biome per file; the file name and the actual biome name must match. Adding a file with a new name to the biome data location will make it available for the game to use, while existing biomes can be overriden via files that match their existing name. Note that if you add a new biome you'll need to write component data that allows it to participate in world generation (see full schema below), or else it won't show up in your worlds!
Back to top

JSON format

All biomes should specify the version that they target via the "format_version" field. The remainder of the biome data is divided up into independent JSON sub-objects, or components. In general you can think of the presence of a component as defining what game behaviors a biome participates in with the component fields defining how it participates. Broadly there are two categories of components:
1) Namespaced components (i.e. those with a 'name:' prefix) map to specific behaviors in-game; they may have member fields that parameterize that behavior; only names that have a valid mapping are supported.
2) Components with no namespace are treated as 'tags': any name consisting of alphanumeric characters, '.' and '_' is permitted; the tag is attached to the biome so that either code or data may check for its existence; tag components may not have member fields.

See the full biome schema below for additional details and the full list of namespaced components.

Here is a sample biome
{
  "plains": {
    "format_version": "1.12.0",

    "minecraft:climate": {
      "downfall": 0.4,
      "snow_accumulation": [ 0.0, 0.125 ],
      "temperature": 0.8
    },
    "minecraft:overworld_height": {
      "noise_type": "lowlands"
    },
    "minecraft:overworld_surface": {
      "floor_depth": 7,
      "floor_material": "minecraft:gravel",
      "foundation_material": "minecraft:stone",
      "mid_material": "minecraft:dirt",
      "top_material": "minecraft:grass"
    },
    "minecraft:world_generation_rules": {
      "hills_transformation": [
        [ "forest_hills", 1 ],
        [ "forest", 2 ]
      ],
      "mutate_transformation": "sunflower_plains",
      "generate_for_climates": [
        [ "medium", 3 ],
        [ "warm", 1 ],
        [ "cold", 1 ]
      ]
    },

    "animal": {},
    "monster": {},
    "overworld": {},
    "plains": {}
  }
}

Back to top

Overview

Biomes describe how a local patch of the world should look and behave. By writing custom biome data you could:
1) Change the general shape of terrain for a biome.
2) Change the ratio of frequency of biome types.
3) Change the blocks that make up the biome, both at the surface and below.
4) Change the distribution of decorative features (e.g. trees, grass, etc.) for a biome.
5) Change the mobs that spawn for a biome.
6) Change the climate for a biome.
7) ...and more!
Back to top

Schema


  {
      object "minecraft:climate"[0,3] : opt // Describes temperature, humidity, precipitation, etc.  Biomes without this component will have default values.
      {
          float "temperature"
          float "downfall"
          array "snow_accumulation"[2]
          {
              float "0"
              float "1"
          }
      }
      object "minecraft:overworld_height"[0,2] : opt // Noise parameters used to drive terrain height in the Overworld.
      {
          array "noise_params"[2] : opt
          {
              float "0"
              float "1"
          }
          string "noise_type" : opt
      }
      object "minecraft:forced_features"[0,11] : opt // Force specific decorative features (trees, plants, etc.) to appear in this Biome, regardless of normal decoration rules.
      {
          array "first_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  object "scatter_chance" : opt // Probability numerator / denominator that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  {
                      int "numerator"
                      int "denominator"
                  }
                  molang "scatter_chance" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  enumerated_value "coordinate_eval_order" : opt
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "before_underground_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  object "scatter_chance" : opt // Probability numerator / denominator that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  {
                      int "numerator"
                      int "denominator"
                  }
                  molang "scatter_chance" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  enumerated_value "coordinate_eval_order" : opt
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "underground_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  object "scatter_chance" : opt // Probability numerator / denominator that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  {
                      int "numerator"
                      int "denominator"
                  }
                  molang "scatter_chance" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  enumerated_value "coordinate_eval_order" : opt
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "after_underground_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  object "scatter_chance" : opt // Probability numerator / denominator that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  {
                      int "numerator"
                      int "denominator"
                  }
                  molang "scatter_chance" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  enumerated_value "coordinate_eval_order" : opt
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "before_surface_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  object "scatter_chance" : opt // Probability numerator / denominator that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  {
                      int "numerator"
                      int "denominator"
                  }
                  molang "scatter_chance" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  enumerated_value "coordinate_eval_order" : opt
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "surface_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  object "scatter_chance" : opt // Probability numerator / denominator that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  {
                      int "numerator"
                      int "denominator"
                  }
                  molang "scatter_chance" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  enumerated_value "coordinate_eval_order" : opt
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "after_surface_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  object "scatter_chance" : opt // Probability numerator / denominator that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  {
                      int "numerator"
                      int "denominator"
                  }
                  molang "scatter_chance" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  enumerated_value "coordinate_eval_order" : opt
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "before_sky_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  object "scatter_chance" : opt // Probability numerator / denominator that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  {
                      int "numerator"
                      int "denominator"
                  }
                  molang "scatter_chance" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  enumerated_value "coordinate_eval_order" : opt
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "sky_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  object "scatter_chance" : opt // Probability numerator / denominator that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  {
                      int "numerator"
                      int "denominator"
                  }
                  molang "scatter_chance" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  enumerated_value "coordinate_eval_order" : opt
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "after_sky_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  object "scatter_chance" : opt // Probability numerator / denominator that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  {
                      int "numerator"
                      int "denominator"
                  }
                  molang "scatter_chance" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  enumerated_value "coordinate_eval_order" : opt
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
          array "final_pass" : opt
          {
              object "<any array element>" : opt
              {
                  molang "iterations" // Number of scattered positions to generate
                  object "scatter_chance" : opt // Probability numerator / denominator that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  {
                      int "numerator"
                      int "denominator"
                  }
                  molang "scatter_chance" : opt // Probability (0-100] that this scatter will occur.  Not evaluated each iteration; either no iterations will run, or all will.
                  enumerated_value "coordinate_eval_order" : opt
                  molang "x" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "x" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "z" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "z" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  molang "y" : opt // Expression for the coordinate (evaluated each iteration).  Mutually exclusive with random distribution object below.
                  object "y" : opt // Distribution for the coordinate (evaluated each iteration).  Mutually exclusive with Molang expression above.
                  {
                      enumerated_value "distribution" // Type of distribution - uniform random, gaussian (centered in the range), or grid
                      int "step_count" : opt // When the distribution type is grid, defines the number of subdivisions along this axis
                      array "extent"[2]
                      {
                          molang "0" : opt // Lower bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                          molang "1" : opt // Upper bound (inclusive) of the scatter range, as an offset from the input point to scatter around
                      }
                  }
                  feature_reference "places_feature"
              }
          }
      }
      object "minecraft:ignore_automatic_features"[0] : opt // No features will be automatically attached to this Biome, only features specified in the minecraft:forced_features component will appear.
      object "minecraft:overworld_surface"[0,5] : opt // Control the blocks used for the default Minecraft Overworld terrain generation.
      {
          block_reference "top_material" // Controls the block type used for the surface of this biome.
          block_reference "mid_material" // Controls the block type used in a layer below the surface of this biome.
          block_reference "floor_material" // Controls the block type used as a floor for bodies of water in this biome.
          block_reference "foundation_material" // Controls the block type used deep underground in this biome.
          int "floor_depth" // Controls how deep below the world water level the floor should occur.
      }
      object "minecraft:surface_material_adjustments"[0,1] : opt // Specify fine-detail changes to blocks used in terrain generation (based on a noise function)
      {
          array "adjustments" : opt // All adjustments that match the column's noise values will be applied in the order listed.
          {
              object "<any array element>"
              {
                  object "materials"
                  {
                      block_reference "top_material" : opt // Controls the block type used for the surface of this biome when this adjustment is active.
                      block_reference "mid_material" : opt // Controls the block type used in a layer below the surface of this biome when this adjustment is active.
                      block_reference "floor_material" : opt // Controls the block type used as a floor for bodies of water in this biome when this adjustment is active.
                      block_reference "foundation_material" : opt // Controls the block type used deep underground in this biome when this adjustment is active.
                  }
                  array "noise_range"[2] // Defines a range of noise values [min, max) for which this adjustment should be applied.
                  {
                      string "0" : opt
                      float "0" : opt
                      string "1" : opt
                      float "1" : opt
                  }
              }
          }
      }
      object "minecraft:swamp_surface"[0,5] : opt // Similar to overworld_surface.  Adds swamp surface details.
      {
          block_reference "top_material" // Controls the block type used for the surface of this biome.
          block_reference "mid_material" // Controls the block type used in a layer below the surface of this biome.
          block_reference "floor_material" // Controls the block type used as a floor for bodies of water in this biome.
          block_reference "foundation_material" // Controls the block type used deep underground in this biome.
          int "floor_depth" // Controls how deep below the world water level the floor should occur.
      }
      object "minecraft:frozen_ocean_surface"[0,5] : opt // Similar to overworld_surface.  Adds icebergs.
      {
          block_reference "top_material" // Controls the block type used for the surface of this biome.
          block_reference "mid_material" // Controls the block type used in a layer below the surface of this biome.
          block_reference "floor_material" // Controls the block type used as a floor for bodies of water in this biome.
          block_reference "foundation_material" // Controls the block type used deep underground in this biome.
          int "floor_depth" // Controls how deep below the world water level the floor should occur.
      }
      object "minecraft:mesa_surface"[0,9] : opt // Similar to overworld_surface.  Adds colored strata and optional pillars.
      {
          block_reference "top_material" // Controls the block type used for the surface of this biome.
          block_reference "mid_material" // Controls the block type used in a layer below the surface of this biome.
          block_reference "floor_material" // Controls the block type used as a floor for bodies of water in this biome.
          block_reference "foundation_material" // Controls the block type used deep underground in this biome.
          int "floor_depth" // Controls how deep below the world water level the floor should occur.
          block_reference "clay_material"
          block_reference "hard_clay_material"
          bool "bryce_pillars"
          bool "has_forest"
      }
      object "minecraft:nether_surface"[0] : opt // Use default Minecraft Nether terrain generation.
      object "minecraft:the_end_surface"[0] : opt // Use default Minecraft End terrain generation.
      object "minecraft:world_generation_rules"[0,5] : opt // Control how this biome is instantiated (and then potentially modified) during world generation.
      {
          biome_reference "hills_transformation" : opt
          array "hills_transformation" : opt
          {
              biome_reference "<any array element>" : opt
              array "<any array element>"[2] : opt
              {
                  biome_reference "0"
                  int "1"
              }
          }
          biome_reference "mutate_transformation" : opt
          array "mutate_transformation" : opt
          {
              biome_reference "<any array element>" : opt
              array "<any array element>"[2] : opt
              {
                  biome_reference "0"
                  int "1"
              }
          }
          array "generate_for_climates" : opt // Controls the world generation climate categories that this biome can spawn for.  A single biome can be associated with multiple categories with different weightings.
          {
              array "<any array element>"[2]
              {
                  enumerated_value "0" // Name of a climate category
                  int "1" // Weight with which this biome should be selected, relative to other biomes in the same category
              }
          }
          biome_reference "river_transformation" : opt
          array "river_transformation" : opt
          {
              biome_reference "<any array element>" : opt
              array "<any array element>"[2] : opt
              {
                  biome_reference "0"
                  int "1"
              }
          }
          biome_reference "shore_transformation" : opt
          array "shore_transformation" : opt
          {
              biome_reference "<any array element>" : opt
              array "<any array element>"[2] : opt
              {
                  biome_reference "0"
                  int "1"
              }
          }
      }
      object "minecraft:legacy_world_generation_rules"[0] : opt // Additional world generation control applicable only to legacy limited worlds.
      object "[a-z0-9_.:]+"[0] : opt // Attach arbitrary string tags to this biome
  }


Back to top