Docs
Getting Started
Updates
GitHub
search
homechevron_rightData drivenchevron_rightWorldgenchevron_rightDimensions

Dimensions

Dimensions are complete, separate worlds within Minecraft. Each dimension combines a dimension type (world rules like height, lighting, and behavior) with a generator (how terrain is created). Vanilla Minecraft has three dimensions: Overworld, Nether, and End.

With datapacks, you can create unlimited custom dimensions with unique terrain, rules, and atmosphere. Players can travel between dimensions using portals or commands.

References: Dimension, Dimension definition, Custom dimension

Dimension Type

Dimension types define the fundamental rules of a world: vertical bounds, lighting behavior, time flow, and special mechanics. These settings affect gameplay significantly-for example, ultrawarm dimensions evaporate water and make lava flow faster (like the Nether).

Reference: Dimension type

val myDimType = dp.dimensionType("my_dim_type") {
	ambientLight = 0f
	bedWorks = true
	hasCeiling = false
	hasRaids = true
	hasSkylight = true
	height = 384
	logicalHeight = 384
	minY = -64
	natural = true
	piglinSafe = false
	respawnAnchorWorks = false
	ultrawarm = false
}
Kotlin

Dimension Type Properties

Property Description
ambientLight Base light level (0.0 to 1.0)
bedWorks Beds can set spawn point
effects Visual effects (overworld/nether/end)
hasCeiling Whether dimension has bedrock ceiling
hasRaids Raids can occur
hasSkylight Whether sky provides light
height Total height (multiple of 16, max 4064)
infiniburn Block tag for infinite burning
logicalHeight Max height for teleportation/portals
minY Minimum Y coordinate (multiple of 16)
natural Compasses/clocks work normally
piglinSafe Piglins don't zombify
respawnAnchorWorks Respawn anchors can be used
ultrawarm Water evaporates, lava flows faster

Dimension

A dimension combines a dimension type with a generator that produces terrain. The generator determines the terrain algorithm and biome distribution.

val dim = dp.dimension("my_dimension", type = myDimType) {
	// Choose a generator (see below)
}
Kotlin

Noise Generator

The noise generator is the standard terrain generator used by vanilla dimensions. It combines noise settings (terrain shape algorithm) with a biome source (which biomes appear where).

Reference: Noise generator

dimension("my_dimension", type = myDimType) {
	noiseGenerator(
		settings = myNoiseSettings,
		biomeSource = /* BiomeSource */
	)
}
Kotlin

Biome Sources

Biome sources determine how biomes are distributed across the dimension. Different sources suit different use cases:

Reference: Biome source

// Single biome everywhere (simplest option)
noiseGenerator(
	settings = terrain,
	biomeSource = fixed(myBiome)
)

// Checkerboard pattern
noiseGenerator(
	settings = terrain,
	biomeSource = checkerboard(scale = 3, biome1, biome2, biome3)
)

// Multi-noise (vanilla-like biome distribution)
noiseGenerator(
	settings = terrain,
	biomeSource = multiNoise {
		// biome entries with climate parameters
	}
)

// The End biome source
noiseGenerator(
	settings = terrain,
	biomeSource = theEnd()
)
Kotlin

Flat Generator

The flat generator creates superflat worlds with user-defined block layers. Useful for testing, creative building, or specialized gameplay.

Reference: Superflat

dimension("flat_world", type = myDimType) {
	flatGenerator(biome = Biomes.PLAINS) {
		layers {
			layer(Blocks.BEDROCK, height = 1)
			layer(Blocks.DIRT, height = 2)
			layer(Blocks.GRASS_BLOCK, height = 1)
		}
		// structureOverrides = ...
	}
}
Kotlin

Debug Generator

The debug generator creates a world showing every block state in a grid pattern. Primarily used for development and testing.

Reference: Debug mode

dimension("debug_world", type = myDimType) {
	debugGenerator()
}
Kotlin

Complete Example

fun DataPack.createSkyDimension() {
	// 1) Dimension type with high ambient light
	val skyType = dimensionType("sky_type") {
		ambientLight = 0.5f
		bedWorks = true
		hasCeiling = false
		hasRaids = false
		hasSkylight = true
		height = 256
		logicalHeight = 256
		minY = 0
		natural = true
		piglinSafe = false
		respawnAnchorWorks = false
		ultrawarm = false
	}

	// 2) Simple noise settings
	val skyTerrain = noiseSettings("sky_terrain") {
		noiseOptions(minY = 0, height = 256, sizeHorizontal = 1, sizeVertical = 2)
		defaultBlock(Blocks.STONE) {}
		defaultFluid(Blocks.WATER) { this["level"] = "0" }
	}

	// 3) Create a biome
	val skyBiome = biome("sky_biome") {
		temperature = 0.5f
		downfall = 0.0f
		hasPrecipitation = false
		effects {
			skyColor = 0xFFFFFF
			fogColor = 0xFFFFFF
			waterColor = 0x3F76E4
			waterFogColor = 0x050533
		}
	}

	// 4) Create the dimension
	dimension("sky", type = skyType) {
		noiseGenerator(
			settings = skyTerrain,
			biomeSource = fixed(skyBiome)
		)
	}
}
Kotlin
Published03/02/2026Last updated03/02/2026
Edit this page on GitHub
← PreviousBiomesNext →Features