Custom world generation

Custom world generation allows data packs to change how the world generates. This is particularly useful in conjunction with custom worlds.

Noise settings

Noise settings are for generating the shape of the terrain, stored as JSON files within a data pack in the path data/<namespace>/worldgen/noise_settings, and are used with the minecraft:noise generator in the dimension folder. Default settings include minecraft:overworld for normal Overworld generation, minecraft:amplified for Amplified Overworld generation, minecraft:nether for regular Nether generation, minecraft:caves for Cave (Nether-like generation but with Overworld terrain features) generation, minecraft:end for regular End generation, and minecraft:floating_islands for Floating Islands (similar to The End outer islands) generation.

JSON format

• The root tag
  •  bedrock_roof_position: The distance from the world height for the top coordinate of the bedrock roof, if out of world bounds (0-255) the roof does not appear, example: "-1". e.g. setting this to 32 puts the top of the roof at y=224. If the bedrock roof is low enough, natural terrain still generates above it. ^{[needs testing]}
  •  bedrock_floor_position: The y coordinate of the bedrock floor, similar to bedrock_roof_position – setting both floor and roof to 255 generates a single layer of flat bedrock for each of them. ^{[needs testing]}
  •  sea_level: The sea level in this dimension between 0 and 255
  •  disable_mob_generation: Can be true or false. ^{[needs testing]}
  •  structures: Structure settings
    •  stronghold: Settings for how strongholds should be spawned. The stronghold values under the structures tag appear to be placeholders so that every namespaced structure has a value; these values are the ones that actually control stronghold spawning.
      •  distance: Controls how far apart the strongholds are. ^{[needs testing]}
      •  count: How many strongholds to generate. ^{[needs testing]}
      •  spread:^{[needs testing]}
    •  structures: List of structures to use in this dimension
      •  <namespaced id>: The key for this field should be the namespaced ID of a structure, a list is available at Java Edition data value § Structures.
        •  spacing (number): Average distance between two structure placement attempts of this type in chunks.
        •  separation (number): Minimum distance between two structures of this type in chunks; must be less than spacing.
        •  salt (integer):^{[needs testing]} A number that assists in randomization; see salt (cryptography).
  •  noise: Parameters for world generation.
    •  top_slide: Settings for the curve at the top of the world.
      •  target (integer): The value of the curve. Negative values round off the top of the hills in the affected area, positive values create a roof. Higher values produce larger effects.
      •  size (integer): Defines the size of the affected area from the top of the world. size is calculated using the formula size = <height in blocks> * 0.25 / size_vertical.
      •  offset (integer): Moves the affected area from the top of the world. offset uses the same formula as size so offset = <height in blocks> * 0.25 / size_vertical. For top_slide, positive values move the area down and negative values bring it up.
    •  bottom_slide: Settings for the curve at the bottom of the world.
      •  target (integer): The value of the curve. Negative values remove the floor and round off the bottom of the islands, positive values make a floor. Higher values produce larger effects.
      •  size (integer): Defines the size of the affected area from the bottom of the world. Uses the same formula as in top_slide.
      •  offset (integer): Moves the affected area from the bottom of the world. Uses the same formula as in top_slide. For bottom_slide, positive values move the area up and negative values bring it down.
    •  sampling: ^{[needs testing]}
      •  xz_scale (double): Scales the X and Z axis of the noise. Higher values results in more intricate horizontal shapes. Works similarly to coordinate scale from old customized worlds.
      •  xz_factor (double): Smoothes the noise on the horizontal axis. Works similarly to main noise scale X/Z from old customized worlds.
      •  y_scale (double): Scales the Y axis of the noise. Higher values result in more intricate vertical shapes. Works similarly to height scale from old customized worlds.
      •  y_factor (double): Smoothes the noise on the vertical axis. Works similarly to main noise scale Y from old customized worlds.
    •  size_vertical (integer): Changes the Y scale of the landmass. Values between 1 and 15 gradually increase the hill height, above 20 are all above the normal sea level of 63, and higher than 32 give normal land levels of 100+.^{[needs testing]}
    •  size_horizontal (integer): Changes the X/Z scale of the landmass, but not the biomes.^{[needs testing]}
    •  height (integer): Changes the max height of generated terrain by squashing the world. For example, with height=128, the ground is set to Y=32. this does not affect sea level.^{[needs testing]}
    •  density_factor (double): Changes the gradient of terrain density from the bottom to the top of the world. Positive values result in terrain that is solid underneath with shapes that shrink at higher altitudes, negative values result in terrain that is solid on top with empty space underneath. Greater positive or negative values result in a sharper transition.
    •  density_offset (double; values between -1 and 1): Moves the center height for terrain density relative to Y=128, by an amount inversely proportional to density_factor.^{[needs testing]}
    •  random_density_offset (boolean; optional):^{[needs testing]}
    •  simplex_surface_noise (boolean):^{[needs testing]}
    •  island_noise_override (boolean; optional): Causes the world to generate like The End with a big island in the center and smaller ones around.
    •  amplified (boolean; optional): Toggles between amplified and normal terrain generation. Can be used alongside large biomes in `vanilla_layered` types, and in any dimension (Nether, End, and custom).
  •  default_block: The block that appears below the top blocks of the world; see Java Edition data values § Blocks
    •  Name: ID of the block
    •  Properties: Block states
      •  state (string): A block state key and its value.
  •  default_fluid: The block used for seas and lakes; see Java Edition data values § Fluids.
    •  Name (string): ID of the block
    •  Properties: Block states
      •  state (string): A block state key and its value.

Default settings

These are the settings used by the 6 presets available for the minecraft:noise generator.

Property			minecraft:overworld	minecraft:amplified	minecraft:nether	minecraft:caves	minecraft:end	minecraft:floating_islands
bedrock_roof_position			-10		0		-10
bedrock_floor_position			0		0		-10
sea_level			63		32		0
disable_mob_generation			false		false		true	false
default_block			minecraft:stone		minecraft:netherrack	minecraft:stone	minecraft:end_stone	minecraft:stone
default_fluid			minecraft:water		minecraft:lava	minecraft:water	minecraft:air	minecraft:water
structures	stronghold	distance	32		Tag not included		Tag not included
		count	1
		spread	3
	structures		See below
noise	top_slide	target	-10		120		-3000
		size	3		3		64
		offset	0		0		-46
	bottom_slide	target	-30		320		-30
		size	0		4		7
		offset	0		-1		1
	sampling	xz_scale	0.9999999814507745		1		2
		xz_factor	80		80		80
		y_scale	0.9999999814507745		3		1
		y_factor	160		60		160
	size_vertical		2		2		1
	size_horizontal		1		1		2
	height		256		128		128
	density_factor		1		0		0
	density_offset		-0.46875		0.019921875		0
	random_density_offset		true		false		false
	simplex_surface_noise		true		false		true
	island_noise_override		false		false		true	false
	amplified		false	true	false		false

Structure defaults

These are the default values for all namespaced structures. Every preset uses the same values for all of these structures, with the exception of minecraft:ruined_portal.

Structure		Spacing	Separation	Salt
village		32	8	10387312
desert_pyramid		32	8	14357617
igloo		32	8	14357618
jungle_pyramid		32	8	14357619
swamp_hut		32	8	14357620
pillager_outpost		32	8	165745296
stronghold*		1	0	0
monument		32	5	10387313
endcity		20	11	10387313
mansion		80	20	10387319
buried_treasure**		1	0	0
mineshaft**		1	0	0
ruined_portal	nether and caves	25	10	34222645
	All other presets	40	15	34222645
shipwreck		24	4	165745295
ocean_ruin		20	8	14357621
bastion_remnant		27	4	30084232
fortress		27	4	30084232
nether_fossil		2	1	14357921

*Placeholder values, have no effect

**Salt values aren't used for theses structures; changing them produces no effect

Biome

Biomes stored as JSON files within a data pack in the path data/<namespace>/worldgen/biome.

JSON format

• The root tag
  •  precipitation: The type of precipitation found in this biome. Can be "none", "rain", or "snow".
  •  category:^{[needs testing]} Can be "none", "taiga", "extreme_hills", "jungle", "mesa", "plains", "savanna", "icy", "the_end", "beach", "forest", "ocean", "desert", "river", "swamp", "mushroom", or "nether".
  •  depth:^{[needs testing]} Used for terrain noise generation. Biomes with positive depth are considered land, biomes with negative depth are oceans.
  •  scale:^{[needs testing]} Used for terrain noise generation. Vertically stretches the terrain. Lower values produce flatter terrain.
  •  temperature:^{[needs testing]} Controls gameplay features like grass and foliage color and whether snow golems take damage.
  •  temperature_modifier:^{[needs testing]} Can be none or frozen.
  •  downfall:^{[needs testing]} Controls grass and foliage color, a value above 0.85 also makes fire burn out faster.
  •  effects: Ambient effects in this biome.
    •  fog_color: Decimal value converted from Hex color to use for fog.
    •  foliage_color: Decimal value converted from Hex color to use for tree leaves and vines. If not present, the value depends on humidity and temperature.
    •  grass_color: Decimal value converted from Hex color to use for grass blocks, grass, tall grass, ferns, tall ferns, and sugar cane. If not present, the value depends on humidity and temperature.
    •  sky_color: Decimal value converted from Hex color to use for the sky.
    •  water_color: Decimal value converted from Hex color to use for water blocks and cauldrons.
    •  water_fog_color: Decimal value converted from Hex color to use for fog.
    •  grass_color_modifier:^{[needs testing]} Can be none, dark_forest or swamp.
    •  particle (optional): The particle to use throughout this biome.
      •  probability:^{[needs testing]} Controls how often the particle spawns.
      •  options: Controls what particle to use.
        •  type: The namespaced id of the particle type.
        • If type is block or falling_dust:
          •  Name: The namespaced id of the block to use.
          •  Properties: Block states
            •  state: A block state key and its value.
        • If type is dust:
          •  r: The red component of the dust color, from 0 to 1.
          •  g: The green component of the dust color, from 0 to 1.
          •  b: The blue component of the dust color, from 0 to 1.
          •  scale: Controls the size of the dust particles.
        • If type is item:
          •  id: Namespaced id of the item to use.
          •  Count: The amount of the item.
          •  tag: NBT data present on the item.
    •  ambient_sound (optional):^{[needs testing]} Sound event to use for ambient sound.
    •  mood_sound (optional):^{[needs testing]} Settings for mood sound.
      •  sound: Sound event to use
      •  tick_delay:^{[needs testing]}
      •  block_search_extent:^{[needs testing]} Determines the cubic range of possible positions to play the mood sound. The player is at the center of the cubic range, and the edge length is 2 * block_search_extent + 1.
      •  offset:^{[needs testing]}
    •  additions_sound (optional):^{[needs testing]} Settings for additions sound.
      •  sound: Sound event to use
      •  tick_chance:^{[needs testing]}
    •  music (optional):^{[needs testing]} Specific music that should be played in the biome.
      •  sound: Sound event to use
      •  min_delay:^{[needs testing]}
      •  max_delay:^{[needs testing]}
      •  replace_current_music:^{[needs testing]} Whether or not to replace music which is already playing.
  •  surface_builder: The namespaced id of the configured surface builder to use.
  •  carvers: The carvers to use.
    •  air: List of carvers used to fill areas with air.
      • : The namespaced id of a configured carver.
    •  liquid: List of carvers used to fill areas with the liquid.
      • : The namespaced id of a configured carver.
  •  features:^{[needs testing]} A list of 10 lists of features. In vanilla, each of the 10 lists corresponds to a different type of feature: the feature lists are applied to each chunk in order from top to bottom. The index of the list which the feature is placed in is also used to generate part of the feature seed, so moving features to a different list definitely has some effect on generation. Each element of each list is a namespaced id of a configured feature. Can be a empty list.
    • : Internal feature type RAW_GENERATION. Used by miniature end island features by default.
    • : Internal feature type LAKES. Used by water and lava lakes by default.
    • : Internal feature type LOCAL_MODIFICATIONS. Used for rocks in taigas and icebergs by default.
    • : Internal feature type UNDERGROUND_STRUCTURES. Used for dungeons and overworld fossils by default.
    • : Internal feature type SURFACE_STRUCTURES. Used for desert wells and blue ice patches by default.
    • : Internal feature type STRONGHOLDS. Not used for any features by default.
    • : Internal feature type UNDERGROUND_ORES. Used for overworld ore veins, overworld dirt/gravel/stone variant patches, and sand/gravel/clay disks by default.
    • : Internal feature type UNDERGROUND_DECORATION. Used for infested block veins, nether gravel and blackstone veins, and all nether ore veins by default.
    • : Internal feature type VEGETAL_DECORATION. Used for trees, bamboo, cacti, kelp, and other ground and ocean vegetation, as well as lava and water springs by default.
    • : Internal feature type TOP_LAYER_MODIFICATION. Used for surface freezing by default.
  •  starts:^{[needs testing]} The structures to generate in this biome.
    • The namespaced id of a configured structure feature.
  •  spawners: Entity spawning settings.
    •  <mob category>: Valid mob categories are monster, creature, ambient, water_creature, water_ambient, and misc.
      • A list of spawner data objects, one for each mob which should spawn in this biome.
        • The spawner data for a single mob.
          •  type: The namespaced entity id of the mob.
          •  weight:^{[needs testing]} How often this mob should spawn, higher values produce more spawns.
          •  minCount:^{[needs testing]}
          •  maxCount:^{[needs testing]}
  •  player_spawn_friendly:^{[needs testing]} Can be true or false.
  •  creature_spawn_probability: Spawns passive mobs as long as random value is less than this. Must be between 0 and 1.
  •  parent (optional):^{[needs testing]} The namespaced id of this biome's parent biome.
  •  spawn_costs:^{[needs testing]} List of entity ids.
    •  <entity id>:^{[needs testing]}
      •  energy_budget:^{[needs testing]}
      •  charge:^{[needs testing]}

Biome categories

Biome categories are used by several game mechanics:^{[needs testing]}

• Any biomes in the category ocean are considered part of the ocean temperature category; other temperature categories are controlled by the biome's temperature value. This means that biomes in the ocean category should typically be placed near each other.
• Biomes in the categories ocean and river play the underwater music instead of their normal music when the player is underwater.
• Zombie sieges and patrols do not spawn in biomes in the category mushroom.
• Rabbits spawning in biomes in the category desert always have the desert skin, unless they are in a biome with precipitation set to snow.
• Mobs in the water_ambient category spawn much less often in biomes in the category river.
• Ocean monuments do not spawn in any biome which isn't in the category ocean or river.

Default biomes

Main article: Biome

Carvers

Carvers are used to add carved out regions of biomes, either replaced with air or liquid. They stored as JSON files within a data pack in the path data/<namespace>/worldgen/configured_carver.

Whether it is possible to configure the "ocean" layer of carvers (for example the lava that appears below y=10 in Overworld caves) is unknown.

JSON format

The root tag

• •  type: The type of carver to use, must be one of either "cave", "nether_cave", "canyon", "underwater_canyon", or "underwater_cave".
  •  config: Configuration values for the carver.
    •  probability:^{[needs testing]} The probability that each chunk attempts to generate this carver, must be between 0 and 1.

Surface builders

Surface builders control how the surface of the terrain is shaped and what blocks it is generated with. They are stored as JSON files within a data pack in the path data/<namespace>/worldgen/configured_surface_builder.

JSON format

The root tag

• •  type:^{[needs testing]} The type of surface builder to use, must be one of "default", "mountain", "shattered_savanna", "gravelly_mountain", "giant_tree_taiga", "swamp", "badlands", "wooded_badlands", "eroded_badlands", "frozen_ocean", "nether", "nether_forest", "soul_sand_valley", "basalt_deltas", or "nope". These choices change the generation of patterns of surface materials, and in the case of "frozen_ocean" and "eroded_badlands", add generated icebergs and buttes, respectively. For example, the mixed patterns of stone in mountains and the striped terracotta of mesas are coded for through these options.
  •  config: Configuration for the surface builder.
    •  top_material:^{[needs testing]} The block to use for the topmost layer of the terrain.
      •  Name: The namespaced id of the block to use.
      •  Properties: Block states
        •  state: A block state key and its value.
    •  under_material:^{[needs testing]} The block to use directly under the topmost layer of the terrain.
      •  Name: The namespaced id of the block to use.
      •  Properties: Block states
        •  state: A block state key and its value.
    •  underwater_material:^{[needs testing]} The block to use under bodies of water.
      •  Name: The namespaced id of the block to use.
      •  Properties: Block states
        •  state: A block state key and its value.

Features

Features are unique elements of the world like trees, flowers, ore, etc. They stored as JSON files within a data pack in the path data/<namespace>/worldgen/configured_feature.

JSON format

When another configured feature is required inside the settings, it can either be provided with a string tag as the namespaced id of another configured feature, or with a compound tag as a nested definition.

• The root tag
  •  type: The type of configured feature. Must be one of the types listed below.
  •  config: The settings for this configured feature. The settings vary depending on type. Any name not listed under this tag has no settings; however, they must still include an empty config object in their definition.
    • If type is tree:
      •  trunk_provider:^{[needs testing]} The block to use for the trunk. Note that provider block must be blocks with xyz axis tag, like logs, when the trunk placer is "fancy_trunk_placer"
        • Blockstate Provider
      •  leaves_provider:^{[needs testing]} The block to use for the leaves.
        • Blockstate Provider
      •  foliage_placer:^{[needs testing]} Controls how leaves are generated.
        •  radius:^{[needs testing]}
          • Uniform Int with minBase 0, maxBase 8, and maxSpread 8
        •  offset:^{[needs testing]}
          • Uniform Int with minBase 0, maxBase 8, and maxSpread 8
        •  type:^{[needs testing]} The type of foliage placer to use. Must be one of "blob_foliage_placer", "spruce_foliage_placer", "pine_foliage_placer", "acacia_foliage_placer", "bush_foliage_placer", "fancy_foliage_placer", "jungle_foliage_placer", "mega_pine_foliage_placer", or "dark_oak_foliage_placer".
        • If type is blob_foliage_placer, bush_foliage_placer, fancy_foliage_placer, or jungle_foliage_placer:
          •  height:^{[needs testing]} Affect the foliage height and size in block height. Must be between 0 and 16, inclusive.
        • If type is spruce_foliage_placer:
          •  trunk_height:^{[needs testing]}
            • Uniform Int with minBase 0, maxBase 16, and maxSpread 8
        • If type is pine_foliage_placer:
          •  height:^{[needs testing]}
            • Uniform Int with minBase 0, maxBase 16, and maxSpread 8
        • If type is mega_pine_foliage_placer:
          •  crown_height:^{[needs testing]}
            • Uniform Int with minBase 0, maxBase 16, and maxSpread 8
      •  trunk_placer:^{[needs testing]} Controls how the trunk is generated.
        •  type:^{[needs testing]} The type of trunk placer to use. Must be one of "straight_trunk_placer", "forking_trunk_placer", "giant_trunk_placer", "mega_jungle_trunk_placer", "dark_oak_trunk_placer", or "fancy_trunk_placer".
        •  base_height:^{[needs testing]} Must be between 0 and 32, inclusive.
        •  height_rand_a:^{[needs testing]} Must be between 0 and 24, inclusive.
        •  height_rand_b:^{[needs testing]} Must be between 0 and 24, inclusive.
      •  minimum_size:^{[needs testing]}
        •  min_clipped_height (optional):^{[needs testing]} Must be between 0 and 80, inclusive.
        •  type:^{[needs testing]} Must be either "two_layers_feature_size" or "three_layers_feature_size".
        • If type is two_layers_feature_size:
          •  limit (optional):^{[needs testing]} Must be between 0 and 81, inclusive. Defaults to 1 if not provided.
          •  lower_size (optional):^{[needs testing]} Must be between 0 and 16, inclusive. Defaults to 0 if not provided.
          •  upper_size (optional):^{[needs testing]} Must be between 0 and 16, inclusive. Defaults to 1 if not provided.
        • If type is three_layers_feature_size:
          •  limit (optional):^{[needs testing]} Must be between 0 and 80, inclusive. Defaults to 1 if not provided.
          •  upper_limit (optional):^{[needs testing]} Must be between 0 and 80, inclusive. Defaults to 1 if not provided.
          •  lower_size (optional):^{[needs testing]} Must be between 0 and 16, inclusive. Defaults to 0 if not provided.
          •  middle_size (optional):^{[needs testing]} Must be between 0 and 16, inclusive. Defaults to 1 if not provided.
          •  upper_size (optional):^{[needs testing]} Must be between 0 and 16, inclusive. Defaults to 1 if not provided.
      •  decorators:^{[needs testing]} Decorations to add to the tree apart from the trunk and leaves.
        • A decorator.
          •  type: The type of decoration to add. Must be one of "trunk_vine", "leave_vine", "cocoa", "beehive", or "alter_ground".
          • If type is cocoa or beehive:
            •  probability:^{[needs testing]} Must be between 0 and 1, inclusive.
          • If type is alter_ground:
            •  provider:^{[needs testing]} The block to replace the ground with.
              • Blockstate Provider
      •  max_water_depth (optional):^{[needs testing]} The maximum depth of water this tree can generate in. Defaults to 0 if not provided.
      •  ignore_vines (optional):^{[needs testing]} Defaults to false if not provided.
      •  heightmap:^{[needs testing]} Must be one of "WORLD_SURFACE_WG", "WORLD_SURFACE", "OCEAN_FLOOR_WG", "OCEAN_FLOOR", "MOTION_BLOCKING", or "MOTION_BLOCKING_NO_LEAVES".
    • If type is flower or random_patch:
      •  state_provider:^{[needs testing]} The block to use.
        • Blockstate Provider
      •  block_placer:^{[needs testing]}
        •  type:^{[needs testing]} The type of block placer to use. Must be one of "simple_block_placer", "double_plant_placer", or "column_placer".
        • If type is column_placer:
          •  min_size:^{[needs testing]} The minimum height of the column of blocks.
          •  extra_size:^{[needs testing]} The extra height (added to the minimum height) that the column can reach.
      •  whitelist:^{[needs testing]} A list of block states that can be replaced. Includes all block states if left blank
        • A block state
          •  Name: The namespaced id of the block to use.
          •  Properties: Block states
            •  state: A block state key and its value.
      •  blacklist:^{[needs testing]} A list of block states that cannot be replaced.
        • A block state
          •  Name: The namespaced id of the block to use.
          •  Properties: Block states
            •  state: A block state key and its value.
      •  tries (optional):^{[needs testing]} Defaults to 128 if not provided.
      •  xspread (optional):^{[needs testing]} Defaults to 7 if not provided.
      •  yspread (optional):^{[needs testing]} Defaults to 3 if not provided.
      •  zspread (optional):^{[needs testing]} Defaults to 7 if not provided.
      •  can_replace (optional):^{[needs testing]} Defaults to false if not provided.
      •  project (optional):^{[needs testing]} Defaults to true if not provided.
      •  need_water (optional):^{[needs testing]} Defaults to false if not provided.
    • If type is block_pile or nether_forest_vegetation:
      •  state_provider:^{[needs testing]} The block to use.
        • Blockstate Provider
    • If type is spring_feature:
      •  state:^{[needs testing]} The fluid to use for the spring.
        •  Name: The namespaced id of the fluid to use.
        •  Properties: Fluid states
          •  state: A fluid state key and its value.
      •  requires_block_below (optional):^{[needs testing]} Defaults to true if not provided.
      •  rock_count (optional):^{[needs testing]} Defaults to 4 if not provided.
      •  hole_count (optional):^{[needs testing]} Defaults to 1 if not provided.
      •  valid_blocks:^{[needs testing]} A list of blocks.
        • : The namespaced id of the block to use.
    • If type is emerald_ore:
      •  target:^{[needs testing]}
        • A block state
          •  Name: The namespaced id of the block to use.
          •  Properties: Block states
            •  state: A block state key and its value.
      •  state:^{[needs testing]}
        • A block state
          •  Name: The namespaced id of the block to use.
          •  Properties: Block states
            •  state: A block state key and its value.
    • If type is huge_red_mushroom or huge_brown_mushroom:
      •  cap_provider:^{[needs testing]} The block to use for the cap.
        • Blockstate Provider
      •  stem_provider:^{[needs testing]} The block to use for the stem.
        • Blockstate Provider
      •  foliage_radius (optional):^{[needs testing]} The size of the cap. Defaults to 2 if not provided.
    • If type is iceberg, forest_rock, or lake:
      •  state:^{[needs testing]}
        • A block state
          •  Name: The namespaced id of the block to use.
    • If type is disk or ice_patch:
      •  state:^{[needs testing]}
        • A block state
          •  Name: The namespaced id of the block to use.
      •  radius:^{[needs testing]}
        • Uniform Int with minBase 0, maxBase 4, and maxSpread 4
      •  half_height:^{[needs testing]} Must be between 0 and 4, inclusive.
      •  targets:^{[needs testing]}
        • A block state
          •  Name: The namespaced id of the block to use.
          •  Properties: Block states
            •  state: A block state key and its value.
    • If type is ore or no_surface_ore:
      •  target:^{[needs testing]} Test for if a block can be replaced
        •  predicate_type:^{[needs testing]} The test to perform. Must be one of "always_true", "block_match", "blockstate_match", "tag_match", "random_block_match", or "random_blockstate_match"
        • If predicate_type is block_match:
          •  block: The namespaced id of the block to match.
        • If predicate_type is blockstate_match:
          •  block_state The block state to match.
            •  Name: The namespaced id of the block to use.
            •  Properties: Block states
              •  state: A block state key and its value.
        • If predicate_type is tag_match:
          •  tag: The namespaced id of the block tag to match.
        • If predicate_type is random_block_match:
          •  block: The namespaced id of the block to match.
          •  probability: A number on the interval [0, 1] giving the probability of the vein 'growing' after seeding. Lower values correspond to smaller veins on average.
        • If predicate_type is random_blockstate_match:
          •  block_state The block state to match.
            •  Name: The namespaced id of the block to use.
            •  Properties: Block states
              •  state: A block state key and its value.
          •  probability:^{[needs testing]}
      •  state:^{[needs testing]} The block state to use for the ore.
        •  Name: The namespaced id of the block to use.
        •  Properties: Block states
          •  state: A block state key and its value.
      •  size:^{[needs testing]} The size of the vein. Must be between 0 and 64, inclusive.
    • If type is end_spike:
      •  crystal_invulnerable (optional):^{[needs testing]} Defaults to false if not provided.
      •  spikes: Settings for each individual spike.
        • A spike
          •  centerX (optional):^{[needs testing]} Defaults to 0 if not provided.
          •  centerZ (optional):^{[needs testing]} Defaults to 0 if not provided.
          •  radius (optional):^{[needs testing]} The radius of the spike. Defaults to 0 if not provided.
          •  height (optional):^{[needs testing]} The height of the spike. Defaults to 0 if not provided.
          •  guarded (optional):^{[needs testing]} Whether or not to generate a cage around the crystal. Defaults to false if not provided.
      •  crystal_beam_target (optional):^{[needs testing]} The position of a block.
        • The position's x coordinate.
        • The position's y coordinate.
        • The position's z coordinate.
    • If type is end_gateway:
      •  exit (optional):^{[needs testing]} The position where the gateway portal should exit.
        • The position's x coordinate.
        • The position's y coordinate.
        • The position's z coordinate.
      •  exact:^{[needs testing]}
    • If type is seagrass or bamboo:
      •  probability:^{[needs testing]} Decimal probability between 0 and 1.
    • If type is sea_pickle:
      •  count:^{[needs testing]}
        • Uniform Int with minBase -10, maxBase 128, and maxSpread 128
    • If type is simple_block:
      •  to_place:^{[needs testing]} The block to place.
        •  Name: The namespaced id of the block to use.
        •  Properties: Block state properties
          •  state: A block state key and its value.
      •  place_on:^{[needs testing]} A list of block states that can be below the main block. Must not be left blank
        • The block state to match.
          •  Name: The namespaced id of the block to use.
          •  Properties: Block states
            •  state: A block state key and its value.
      •  place_in:^{[needs testing]} A list of block states that can be replaced at the block location. Must not be left blank
        • The block state to match.
          •  Name: The namespaced id of the block to use.
          •  Properties: Block states
            •  state: A block state key and its value.
      •  place_under:^{[needs testing]} A list of block states that can be above the main block. Must not be left blank
        • The block state to match.
          •  Name: The namespaced id of the block to use.
          •  Properties: Block states
            •  state: A block state key and its value.
    • If type is huge_fungus:
      •  valid_base_block:^{[needs testing]} The block to place on top of.
        •  Name: The namespaced id of the block to use.
        •  Properties: Block states
          •  state: A block state key and its value.
      •  stem_state:^{[needs testing]} The block to use for the stem.
        •  Name: The namespaced id of the block to use.
        •  Properties: Block states
          •  state: A block state key and its value.
      •  hat_state:^{[needs testing]} The block to use for the hat.
        •  Name: The namespaced id of the block to use.
        •  Properties: Block states
          •  state: A block state key and its value.
      •  decor_state:^{[needs testing]} The block to use for the decor.
        •  Name: The namespaced id of the block to use.
        •  Properties: Block states
          •  state: A block state key and its value.
      •  planted (optional):^{[needs testing]} Defaults to false if not provided.
    • If type is basalt_columns:
      •  reach:^{[needs testing]}
        • Uniform Int with minBase 0, maxBase 2, and maxSpread 1
      •  height:^{[needs testing]}
        • Uniform Int with minBase 1, maxBase 5, and maxSpread 5
    • If type is delta_feature:
      •  contents:^{[needs testing]} The block to use for the delta.
        •  Name: The namespaced id of the block to use.
        •  Properties: Block states
          •  state: A block state key and its value.
      •  rim:^{[needs testing]} The block to use for the rim of the delta.
        •  Name: The namespaced id of the block to use.
        •  Properties: Block states
          •  state: A block state key and its value.
      •  size:^{[needs testing]} The size of the delta.
        • Uniform Int with minBase 0, maxBase 8, and maxSpread 8
      •  rim_size:^{[needs testing]} The size of the rim of the delta.
        • Uniform Int with minBase 0, maxBase 8, and maxSpread 8
    • If type is netherrack_replace_blobs:
      •  target:^{[needs testing]}
        • A block state
          •  Name: The namespaced id of the block to use.
          •  Properties: Block states
            •  state: A block state key and its value.
      •  state:^{[needs testing]}
        • A block state
          •  Name: The namespaced id of the block to use.
          •  Properties: Block states
            •  state: A block state key and its value.
      •  radius:^{[needs testing]}
        • Uniform Int
    • If type is fill_layer:
      •  height:^{[needs testing]} The layer to fill.
      •  state:^{[needs testing]} The block to fill with.
        • A block state
          •  Name: The namespaced id of the block to use.
          •  Properties: Block states
            •  state: A block state key and its value.
    • If type is random_selector:
      •  features:^{[needs testing]} A list of other features to be randomly chosen from.
        • A feature and its corresponding chance
          •  feature: Another configured feature.
          •  chance: The chance of this feature being chosen.
      •  default: The configured feature to use if none of the above features are chosen.
    • If type is simple_random_selector:
      •  features:^{[needs testing]} A list of other features to be randomly chosen from, each with equal chance.
        •  feature: Another configured feature.
    • If type is random_boolean_selector:
      •  feature_true:^{[needs testing]} The configured feature to select if the randomly generated boolean is true.
      •  feature_false:^{[needs testing]} The configured feature to select if the randomly generated boolean is true.
    • If type is decorated_feature_configuration:
      •  feature: The configured feature to use.
      •  decorator:^{[needs testing]} The configured decorator to modify the feature with.

Data types

The JSON format makes use of these relatively complex data types many times, so to avoid filling the main JSON format tree with too much redundant information, they are provided here:

•  Blockstate Provider:^{[needs testing]} This structure is used to define more advanced settings for generating a block state.
  •  type: The type of provider to use. Must be one of "simple_state_provider", "weighted_state_provider", "plain_flower_provider", "forest_flower_provider", or "rotated_block_provider".
  • If type is simple_state_provider or rotated_block_provider:
    •  state: A blockstate
      •  Name: The namespaced id of the block to use.
      •  Properties: Block states
        •  state: A block state key and its value.
  • If type is weighted_state_provider:
    •  entries: A list of blockstates to choose from.
      • A blockstate and its corresponding weight.
        •  weight: The weight of this blockstate to be randomly chosen; a higher weight increases the chance.
        •  data: A blockstate
          •  Name: The namespaced id of the block to use.
          •  Properties: Block states
            •  state: A block state key and its value.

•  Uniform Int:^{[needs testing]} This structure represents a randomly generated integer between base and base + spread, inclusive, where each number in the range has equal probability. spread must always be greater than or equal to 0. Additionally, different configuration settings often place extra restrictions on the range of these values; these restrictions are expressed as minBase, maxBase, and maxSpread. All of these restrictions are inclusive ranges. If these restrictions are not stated, then any value of base and any non-negative value of spread is allowed. Alternatively, the compound tag can be substituted for an int tag, in which case the provided value is used as base and spread is set to 0, effectively making this the same as a constant integer. In this case, minBase and maxBase still apply to this value if they are provided.
  •  base: The lowest number which can be generated.
  •  spread: The size of the inclusive range to generate numbers within.

Feature types

These are all of the valid types which can be used for configured features:

• no_op
• chorus_plant
• void_start_platform
• desert_well
• fossil
• ice_spike
• glowstone_blob
• freeze_top_layer
• vines
• monster_room
• blue_ice
• end_island
• kelp
• coral_tree
• coral_mushroom
• coral_claw
• weeping_vines
• twisting_vines
• bonus_chest
• basalt_pillar
• tree
• flower
• random_patch
• block_pile
• nether_forest_vegetation
• spring_feature
• emerald_ore
• huge_red_mushroom
• huge_brown_mushroom
• iceberg
• forest_rock
• lake
• disk
• ice_patch
• ore
• no_surface_ore
• end_spike
• end_gateway
• seagrass
• bamboo
• sea_pickle
• simple_block
• huge_fungus
• basalt_columns
• delta_feature
• netherrack_replace_blobs
• fill_layer
• random_selector
• simple_random_selector
• random_boolean_selector
• decorated
• decorated_flower

Decorators

Decorators are used to modify the generation of features in various ways. They are applied from the outermost decorator to the innermost.

JSON format

• The root tag
  •  type: The type of configured decorator. Must be one of the types listed below.
  •  config: The settings for this configured decorator. The settings vary depending on type. Any name not listed under this tag has no settings; however, they must still include an empty config object in their definition.
    • If type is chance, lava_lake, or water_lake:
      •  chance:^{[needs testing]} The chance for this feature to generate. Calculated by 1 / chance.
    • If type is count, fire, glowstone, or count_multilayer:
      •  count:^{[needs testing]}
        • Uniform Int with minBase -10, maxBase 128, and maxSpread 128
    • If type is count_noise:
      •  noise_level: Determines the threshold within the Perlin noise of when to use below_noise or above_noise.
      •  below_noise: Determines the count placed when the noise is below noise_level .
      •  above_noise: Determines the count placed when the noise is above noise_level .
    • If type is count_noise_biased:
      •  noise_to_count_ratio: Determines the count features generated at the peak noise.
      •  noise_factor: Determines the size of the affected region, scales Perlin noise.
      •  noise_offset (optional): Determines the threshold of the "positive" area, where features are generated. Ranges from -1 to 1, defaults to 0 if not provided.
    • If type is count_extra:
      •  count:^{[needs testing]}
      •  extra_chance:^{[needs testing]}
      •  extra_count:^{[needs testing]}
    • If type is range, range_biased, or range_very_biased:
      •  bottom_offset (optional):^{[needs testing]} Defaults to 0 if not provided.
      •  top_offset (optional):^{[needs testing]} Defaults to 0 if not provided.
      •  maximum (optional):^{[needs testing]} Defaults to 0 if not provided.
    • If type is depth_average:
      •  baseline:^{[needs testing]}
      •  spread:^{[needs testing]}
    • If type is carving_mask:
      •  step:^{[needs testing]} The carving generation step; either "air" or "liquid"
      •  probability:^{[needs testing]}
    • If type is decorated:
      •  outer: The outer configured decorator.
      •  inner: The inner configured decorator.

Decorator types

These are all of the valid types which can be used for configured decorators:

• nope
• square
• heightmap
• heightmap_spread_double
• top_solid_heightmap
• heightmap_world_surface
• spread_32_above
• magma
• emerald_ore
• end_gateway
• dark_oak_tree
• iceberg
• end_island
• chance
• lava_lake
• water_lake
• count
• fire
• glowstone
• count_multilayer
• count_noise
• count_noise_biased
• count_extra
• range
• range_biased
• range_very_biased
• depth_average
• carving_mask
• decorated

Structure features

Structure features are a special type of feature that generates a structure, stored as JSON files within a data pack in the path data/<namespace>/worldgen/configured_structure_feature. The logic behind what qualifies as a structure feature versus a regular feature is unclear. Dungeons and Desert wells are typically considered structures, but are not structure features. Also, Nether Fossils are structure features while Fossils are not even though they are essentially the same feature.

JSON format

• The root tag
  •  type: The type of structure feature. Must be one of the types listed below.
  •  config: The settings for this structure feature. The settings vary depending on type. Any name not listed under this tag has no settings; however, they must still include an empty config object in their definition.
    • If type is pillager_outpost, village, or bastion_remnant:
      •  start_pool: The namespaced id of the structure pool to start from.
      •  size:^{[needs testing]} Must be between 0 and 7, inclusive.
    • If type is mineshaft:
      •  type:^{[needs testing]} Must be either "normal" or "mesa".
      •  probability:^{[needs testing]} Decimal probability between 0 and 1.
    • If type is ruined_portal:
      •  portal_type:^{[needs testing]} Must be one of "standard", "desert", "jungle", "swamp", "mountain", "ocean", or "nether".
    • If type is shipwreck:
      •  is_beached (optional):^{[needs testing]} Whether or not the shipwreck is beached. Defaults to false if not provided.
    • If type is ocean_ruin:
      •  biome_temp:^{[needs testing]} Must be either "warm" or "cold".
      •  large_probability:^{[needs testing]} Decimal probability between 0 and 1.
      •  cluster_probability:^{[needs testing]} Decimal probability between 0 and 1.
    • If type is buried_treasure:
      •  probability:^{[needs testing]} Decimal probability between 0 and 1.

Structure feature types

These are all of the valid types which can be used for structure features:

• mansion
• jungle_pyramid
• desert_pyramid
• igloo
• swamp_hut
• stronghold
• monument
• fortress
• endcity
• nether_fossil
• pillager_outpost
• village
• bastion_remnant
• mineshaft
• ruined_portal
• shipwreck
• ocean_ruin
• buried_treasure

Jigsaw pools

Jigsaw pools or template pools are used to generate structures using jigsaw blocks, stored as JSON files within a data pack in the path data/<namespace>/worldgen/template_pool.

JSON format

• The root tag
  •  name: The namespaced id of the pool ^{[needs testing]}
  •  fallback: Can set to another template pool, which generates when the original pool cannot generate at the end of all layers. Used in the vanilla datapack to generate the end of village streets, aka terminators in structure files. ^{[needs testing]}
  •  elements: A list of structures to choose from
    •  An element:
      •  weight: How likely this element is to be chosen when using this pool
      •  element: The properties of this element
        •  element_type: Can be minecraft:empty_pool_element to generate no structure, minecraft:feature_pool_element when feature is used, minecraft:list_pool_element when elements are used, and minecraft:legacy_single_pool_element or minecraft:single_pool_element when location is used ^{[needs testing]}
        •  feature: The namespaced id of the feature.
        •  location: The namespaced id of the structure to place
        •  projection: Can be rigid to place a fixed structure (like a house), or terrain_matching to match the terrain height like a village road ^{[needs testing]}
        •  processors: The namespaced ID of a processor if this is a string
          •  processors: A list of processors to use
            •  An element:
              •  processor_type: The namespaced id of the processor to use
              •  other properties ^{[needs testing]}
        •  elements: A list of structures to choose from
          •  An element:
            •  weight: How likely this element is to be chosen when using this pool
            •  location: The namespaced id of the structure to place
            •  projection: Can be rigid or terrain_matching ^{[needs testing]}
            •  element_type: Can be minecraft:empty_pool_element to generate no structure, minecraft:list_pool_element when elements is used, and minecraft:legacy_single_pool_element or minecraft:single_pool_element when location is used ^{[needs testing]}
            •  processors: The namespaced ID of a processor if this is a string
              •  processors: A list of processors to use
                •  An element:
                  •  processor_type: The namespaced id of the processor to use
                  •  other properties ^{[needs testing]}

Processor lists

Processor lists are lists of processors used to affect blocks in structures, stored as JSON files within a data pack in the path data/<namespace>/worldgen/processor_list.

JSON format

• The root tag
  •  processors: A list of processors
    •  A processor
      •  processor_type: Can be minecraft:rule, minecraft:block_rot, minecraft:block_age, minecraft:block_ignore, minecraft:blackstone_replace, minecraft:jigsaw_replacement, minecraft:lava_submerged_block, minecraft:gravity or minecraft:nop.
      • If processor_type is minecraft:block_rot:
        •  integrity: A number between 0 and 1 ^{[needs testing]}
      • If processor_type is minecraft:rule:
        •  rules: A list of rules to apply from top to bottom ^{[needs testing]}
          •  A rule
            •  position_predicate: The predicates to apply to the block's position ^{[needs testing]}, see below for a list of valid predicates
            •  input_predicate: The predicates to apply to the block that is placed
            •  location_predicate: The predicates to apply to the block before the structure is generated ^{[needs testing]}
            •  output_state: The block that is placed if all conditions are met
              •  Name: ID of the block
              •  Properties: Block states
                •  state: A block state key and its value
      • If processor_type is minecraft:block_age:
        •  mossiness: Values below 0 is treated as 0; values above 1 is treated as 1.^{[needs testing]}
      • If processor_type is minecraft:block_ignore:
        •  blocks: ^{[needs testing]}
          •  A block
            •  Name: The namespaced id of the block to use.
            •  Properties: Block states
              •  state: A block state key and its value.
      • If processor_type is minecraft:gravity:
        •  heightmap: Must be one of "WORLD_SURFACE_WG", "WORLD_SURFACE", "OCEAN_FLOOR_WG", "OCEAN_FLOOR", "MOTION_BLOCKING", or "MOTION_BLOCKING_NO_LEAVES".
        •  offset: ^{[needs testing]}

Predicates

• The root tag
  •  predicate_type: Can be always_true, axis_aligned_linear_pos for a random chance that depends on a block's distance to the structure's origin ^{[needs testing]}, block_match to test for a block, blockstate_match to test for specific block states, random_block_match to test for a block with a random chance or tag_match to test for a block in a block tag.
  • If predicate_type is axis_aligned_linear_pos:
    •  axis: Can be x, y or z
    •  min_chance: The chance for the predicate to pass when the distance of a block to the structure's origin is equal to min_dist ^{[needs testing]}.
    •  max_chance: The chance for the predicate to pass when the distance of a block to the structure's origin is equal to max_dist ^{[needs testing]}. If a block's distance is between min_dist and max_dist, chance is obtained by linear interpolation between the values of min_chance and max_chance.
    •  min_dist
    •  max_dist
  • If predicate_type is block_match:
    •  block: A block ID.
  • If predicate_type is blockstate_match:
    •  block_state
      •  Name: ID of the block
      •  Properties: Block states
        •  state: A block state key and its value.
  • If predicate_type is random_block_match:
    •  block: A block ID.
    •  probability: The probability (between 0 and 1) of the predicate to pass if the block is found.
  • If predicate_type is tag_match:
    •  tag: The namespaced ID of a block tag

History

Java Edition
1.16.2		20w28a			Added support for custom world generation.
		20w29a			Noise settings moved from dimensions to worldgen.

External links

Settings for vanilla world generation (direct download)