This section describes the "top level" keys/options inside a dimension config object (which are not nested inside other objects). Some of these are objects themselves, some (read: jed) with numerous possible contained keys/options themselves, and those will be described separately further down.

Note that all of the boolean type options here default to false, and you don't need to specify them if you don't wan to use them. And it's basically the same with all other options - you don't need to specify any options you don't want to use.

One particular note is that if either of the worldinfo or worldinfo_onetime values exists, even as an empty object, then that enables the "WorldInfo override" feature for that dimension (see further down for more info about that).

Most common options

• dim (int) - the (Forge) dimension ID this entry is for. This is an integer value, and is unique for each dimension. This value should always exist for every dimension config entry, otherwise the entry won't do anything as it doesn't target any dimension. The vanilla dimension IDs are 0 for the Overworld, -1 for The Nether, and `1´ for The End.
• dimensiontype (object) - This defines what type of dimension to register.
  • If you want to register a new dimension, or replace/override an existing dimension, then the dimension entry should have this value
  • If you are just overriding some settings for an already existing (vanilla or other mod) dimension without overriding the entire dimension, then this value is not needed
  • This DimensionType object (as it's called in the MCP mappings) defines only a small number of basic settings for the dimension:
    • id (int) - The "Dimension Type ID" (in vanilla it's the only dimension ID, but under Forge this is separate from the "actual dimension ID", and this "DimensionType ID" doesn't need to be unique)
    • name (string) - The dimension's name. This isn't that important for many things, it's mostly just visible for teleportation related items and things.
    • keeploaded (boolean) - Whether the dimension's spawn chunks are allowed to unload.
      • Note that this is not a chunk loading option. This controls the vanilla spawn chunks behavior (think overworld spawn chunks).
      • Basically if this is true, then the spawn chunks are not allowed to unload after something has laoded them.
      • This option will not automatically load them. Nor does this keep the chunks ticking with no players in the same dimension (for block entities) or nearby (for entities).
    • worldprovider (string) - This is the most important option here. It's the class name of the WorldProvide to use. In many cases you want to use one of the three JED WorldProvider variants, and those are needed for most (but not all) of the config options inside the jed object to work.
    • require_exact_match (boolean) - This is a JED option, which controls whether an exact match of all the values is required, or whether JED can use pre-registered common DimensionType instances that have a different name and id.
      • The name and id aren't usually that important, so re-using those pre-registered instances can avoid some issues with DimensionType entries registered later after game start not actually working properly.
      • Apparently one cause for such issues is having Optifine installed. This is because the DimensionType in the vanilla code is a Java enum, and isn't supposed to be modified at run-time. So adding new entries to it might not work if the JIT has already optimized away the values() method to return the earlier fixed list of values. And apparently Optifine calls the values() method a lot, which causes the JIT to optimize it away pretty quickly. Which means that trying to register new dimensions some time after game start does not work anymore. For this reason JED pre-registers a small number of DimensionType values early on, and uses those when possible (the important thing is that the worldprovider value and keeploaded both match, as those change behavior significantly.)
• override (boolean) - If true, and a dimension already exists by this ID, then that dimension will be overridden by this dimension. Use the dimensiontype option to define what type of dimension to register.
• worldinfo (object) - This can set any of the values that vanilla keeps in the WorldInfo class (MCP name).
  • If this value (or worldinfo_onetime) exists, that also enabled the "WorldInfo override" feature for this dimension. Without the override these would have no effect on most dimensions except for the overworld.
  • These values are stored in the level.dat file in vanilla, or by JED in the jed_level.dat file.
  • These values include: the dimension's spawn point, the world seed (RandomSeed), the WorldType (generatorName) and the world generator settings (generatorOptions), the difficulty, game rules, game type (game mode), time settings, weather counters, world border settings and a few others. A full list of the options is provided further down.
• worldinfo_onetime (object) - Same as worldinfo, but the values are only applied once, when the dimension is loaded for the very first time.
  • In most cases you should use this instead of worldinfo
  • The only cases where you need to use worldinfo instead of worldinfo_onetime are:
    • If you actually want to reset these settings every time the dimension is loaded
    • If the server is running Sponge, then the generatorName and generatorOptions values will (for some reason) get reset on subsequent dimension loads, so you need to use worldinfo to set them every time
• jed (object) - This object can hold a lot of different JED-specific options to configure the behavior and properties of the dimension. See further down for a full list of the possible options.
  • Most (but not all) of the options inside this object will require the dimension to be using one of JED's WorldProvider variants. This is because many of the configs are implemented by overriding the vanilla methods in the WorldProvider class with variants that check if the value was defined in the JED dimension config, and if not, then continue with the vanilla behavior.

The rest of the options (which might be used less often)

• biome (string) - If this option exists, then JED will force the dimension to use the vanilla single biome BiomeProviderSingle.
  • The dimension will only have a single biome everywhere. And no, you can't specify multiple biomes here. I know many users want that functionality, but the vanilla single biome provider is exactly just that - the same single biome everywhere.
• biomeprovider (string) - Force using the given BiomeProvider class.
  • Note that this may be of limited use, as modded BiomeProviders might use custom constructors, meaning that JED doesn't know how to create the instance.
  • This was mainly added for better compatibility with the Painted Biomes mod. For that, use the value fi.dy.masa.paintedbiomes.world.BiomeProviderPaintedBiomes.
• chunkgenerator (string) - Overrides the ChunkGenerator using the given class.
• disable_teleporting_from (boolean) - If true, then the Forge teleport event is used to cancel any teleports from this dimension.
  • Note that all mods might not use/respect the event, and teleport commands will still work.
• disable_teleporting_to (boolean) - If true, then the Forge teleport event is used to cancel any teleports to this dimension.
  • Note that all mods might not use/respect the event, and teleport commands will still work.
• load_on_start (boolean) - If this is true, then the dimension will be registered earlier than than usual, so that the dimension will get loaded by vanilla/Forge during server start.
  • Usually you don't want the dimension to get loaded for no good reason. There are some special cases when you might need this, but by default leave this out.
• normal_biomes (boolean) - Force the dimension to use the normal vanilla overworld biome provider.
  • This would allow you to get the overworld biomes (as in the biome value saved in the world) in the Nether or the End, however those dimensions use their own ChunkGenerators which don't care about the biome for the terrain generation.
  • A more useful example is using this in a "superflat" dimension, which normally uses the single biome provider. So you can get normal biomes in a flat world with this option.
• post_deletion_command (string) - A command to run after a temorary dimension is deleted (see below).
• spawn_structure (object) - Place a structure/schematic to the world when the dimension is first loaded
• temporary_dimension (boolean) - If this is true, then the dimension is intended to be a "temporary dimension", and it will get deleted as soon as all players leave the dimension, and it's allowed to unload (i.e. no chunks are force loaded). THis might be useful for some type of resetting quest dimensions and such.
• unregister (boolean) - If true, then an existing dimension will be unregistered.
  • Note: It's not possible to unregister the overworld. So many things in the vanilla and mod code assume the overworld to always be loaded, that doing so would break the game entirely.
  • Also be careful with unregistering the other vanilla dimensions. Some mods also break if you unregister the Nether or the End.
  • If you want to disable access to the vanilla dimensions, then instead of unregistering the dimension entirely, it might be better to just override it to be a void dimension, use the disable_teleporting_to option, and maybe also set up the void/sky teleport option to immediately teleport out any player that manages to enter it anyway.
• world_template (string) - Allows using a template world (shipped via the mod config directory) that gets copied to the save location for this dimension when the dimension is loaded for the first time.
  • Note however that you can't "just do it" for any random dimensions due to how in 1.12.2 and earlier the game still uses per-world-global block IDs, which can and will be different in every modded world. That basically means that you would need to take every such template dimension from the same source world so that they all have the same block IDs, and you would need to also ship a template for the overworld i.e. dimension 0, which includes the source world's level.dat file, which contains the Forge block registry (along with all other registries). But then you would need to also have some worldinfo_onetime overrides, you would most likely at least want to reset the world time back to zero, and probably randomize the world seed so that all worlds won't be the same. And you should probably manually edit the level.dat file to delete the player data tag, so that the player in single player won't always spawn in the same place with the same inventory they had in the original template world.
  • So as a summary: This feature is problematic. In most cases you probably don't want to use it.

The spawn_structure option allows you to specify a vanilla Structure Block template file or a schematic file that will be placed to the world relative to the dimension's spawn point when the dimension is loaded for the first time.

The schematic file sould be placed at config/justenoughdimensions/structures/name.<schematic | nbt>, so for example config/justenoughdimensions/structures/spawn_house.nbt.

The schematic can be created with one of the following options:

• The /worldprimer create-structure command from the World Primer mod
• With the Litematica mod
• Vanilla Structure Blocks (these have a 32 block limit per side when saving though)
• The Schematica mod

I would recommend either World Primer or Litematica, but maybe I'm a bit biased in that... But the vanilla Structure Blocks do have the above mentioned size limit, and I don't remember if the Schematica mod has that or is able to save in the vanilla format or not.

Actually neither of these schematic formats is the best option for this. But I haven't added support for the Sponge schematic format or the Litematica schematic format (yet?). The vanilla format is extremely memory-inefficient, and you can't really go beyond something like 100x100x100 blocks volume before you run into some serious issues with memory usage and server crashes with it. And the old *.schematic format doesn't really scale with large number of blocks in the game, and it still relies on the old "magic metadata". That format doesn't work if you use NEID or JEID or something else to extend the number of block IDs beyond the 0..4095 range.

So as a short summary, use the vanilla *.nbt format if your structure is small-ish, let's say around 100x100x100 blocks volume or below, or if you use NEID or JEID or something else to extend the block ID range. Otherwise you can use the *.schematic format for far better memory efficiency and performance.

Below is a sort of "pseudo-json" example showing the possible keys and values (mostly for the rotation and mirror options).

"spawn_structure": {
	"name": "spawn_house.nbt",
	"rotation": "<none | cw_90 | cw_180 | ccw_90>",
	"mirror": "<none | left_right | front_back>",
	"centered": <true | false>,
	"offset": [0, -4, 0],
	"load_around": 16
}

Both rotation and mirror options default to none, so you don't need to specify them if you don't need to rotate the structure. centered defaults to false, but it's quite often a useful option, as it will center the structure horizontally to the dimension's spawn point (plus the specified offset). The offset option allows you to move the structure relative to the dimension's spawn point.

The load_around option specifies how many blocks (scaled up to full chunks) should be pre-loaded around the structure's area before starting to place the structure. This is useful to avoid terrain generation ripping through the just placed structure, when an adjacent chunk is loaded forming the 2x2 loaded chunk area that triggers generation in the middle 16x16 blocks of those chunks.

Here is an actual valid example. The mirror option has been omitted, as it's not being used.

"spawn_structure": {
	"name": "spawn_house.nbt",
	"rotation": "cw_90",
	"centered": true,
	"offset": [12, -9, -8],
	"load_around": 16
}

Note that most of these options need one of the custom JED WorldProviders to be used to work.

TODO: Add a list of the options that work without a JED WorldProvider.

• AverageGroundLevel (int) - ?
• CanDoLightning (boolean) - Enable/disable lightning (and also skeleton trap horses)
• CanDoRainSnowIce (boolean) - Enable/disable water freezing, plus snowing and blocks (like Cauldrons) filling with water while raining.
  • The snowing and blcoks filling with water also depend on HasSkyLight for weather/rain to happen in the first place.
• CanRespawnHere (boolean) - Whether the player can respawn in this dimension after dying
• CanSleepHere (string) - One of allow, deny or bed_explodes
• CanSpawnHostiles (boolean) - Override the normal difficulty-based mob spawning behaviour (peaceful vs. others) with this value
• CanSpawnPeacefulMobs (boolean) - Override the normal value, which is true in hardcore mode and single player, and on servers it's the spawn-animals setting in server.properties
• CelestialAngleMin (float, 0.0 .. 1.0) - Use a customized celestial angle range (needs both min and max set to take effect)
• CelestialAngleMax (float, 0.0 .. 1.0) - Use a customized celestial angle range (needs both min and max set to take effect)
• ChunkGenFactoryWorldProvider (string) - A temporary World Provider override during dimension load, which is just used to create a ChunkGenerator from a mod, that will then be used with some other World Provider later on
• CloudColor (hex color string) - The color for the clouds
• CloudHeight (int) - The render height for the clouds
• CloudRenderer (string) - The fully qualified class name of a custom cloud renderer class
• CustomDayCycle (boolean) - Enable a customized day cycle length. Set the day and night lengths in DayLength and NightLength.
• DayCycleIncrement (int, default = 24000) - The amount of ticks the world time is incremented per day cycle when using the DayTimeMin and DayTimeMax options.
• DayLength (int) - The custom day length, if CustomDayCycle is true
• DayTimeMin (int, 0 - 23999) - Use a customized world time range. This may work weirdly with things... Needs both min and max set to take effect.
• DayTimeMax (int, 0 - 23999) - Use a customized world time range. This may work weirdly with things... Needs both min and max set to take effect.
• DisableDawnDuskColors (boolean) - Disables the sunrise and sunset sky/fog coloring at the horizon
• DisableEnderDragon (boolean) - Overrides the DragonFightManager with a dummy class, disabling the Dragon related stuff. Needs WorldProviderEndJED.
• DisableEndSpikes (boolean) - Uses ChunkGeneratorEndJED, which disables the End Spike (obsidian towers) generation. Needs WorldProviderEndJED.
• DontAdvanceWeatherWhenSleeping (boolean) - Prevents clearing the weather when players sleep to pass the night
• FogColor (hex color string) - The color for the fog effect.
• FoggyBiomes (object) - Defines which biomes either have or don't have fog. See further down for more details.
• ForceGameMode (boolean) -
• GenerateFallbackSpawnBlock (boolean) - If true and the spawn position JED found is in mid-air (void dimensions), then a glass block will be placed right under the spawn point
• HasSkyLight (boolean) - Affects things like weather and light calculations
• HasXZFog (boolean) - (Thick) fog will be rendered around the player
• Horizon (float) - The height of the horizon (used for sky rendering)
• IgnoreSpawnSuitability (boolean) - If true, doesn't check the biome's spawn suitability or try to search for a grass block to spawn on when finding a spawn point for the dimension (in the overworld spawn point search type)
• IsSurfaceWorld (boolean) - Compass & clock models, enables cloud & sky rendering, enables (vanilla) sleeping, enables pigmen spawning from portals
• LightBrightness (array of exactly 16 floats) -
• MoonColor (hex color string) - The color for the moon
• MoonScale (float) - A scaling factor for the moon rendering
• MovementFactor (float) - The Nether Portal scaling factor
• MusicType (string) - The ambient music type that should be used in this dimension. You can get a list of the available values with the musictype dump in the TellMe mod.
• NightLength (int) - The custom night length, if CustomDayCycle is true
• PlayerInventoryGroup (string) - The inventory group this dimension should use, if the JED player inventory swapping is enabled.
• RespawnDimension (int) - The dimension to respawn in, if CanRespawnHere is false
• ShouldClientCheckLight (boolean) - Whether the client should check/re-calculate the light data in the received chunks
• SkyBlend (float) - ?
• SkyColor (hex color string) - The color of the sky
• SkyDisableFlags (int) - A bitmask to disable the sun, moon or stars, if using SkyRenderType ??. (0x1, 0x2, 0x4)
• SkyLightBlend (float) - Allows controlling the sky color blending with the light level, allowing to have a colored sky at night too. Range: 0.0 - 1.0, default = 1.0 (normal light blending).
• SkyRenderer (string) - he fully qualified class name of a custom sky renderer class
• SkyRenderType (int) -
• SpawnPointSearchType (object) - Allows customizing the spawn point search code behaviour, and the algorithm to use for it
• SunBrightness (float) - ?
• SunBrightnessFactor (float) - ?
• SunColor (hex color string) - The color for the sun
• SunScale (float) - A scaling factor for the sun rendering
• VoidTeleportInterval (int) - The interval in game ticks how often entities are checked if they need to be teleported from the void or the sky with the void_teleport and sky_teleport options. Default is 40 ticks (2 seconds).
• WaterVaporizes (boolean) - Overrides whether water should vaporize (on bucket use and ice melting, like in the Nether)
• WeatherRenderer (string) - The fully qualified class name of a custom weather renderer class
• WorldBorderCenteredOnSpawn (boolean) - If true, and the dimension is using WorldInfo overrides, then the World Border will be centered on the dimension's spawn point
• WorldProviderOverride (string) - Allows "manually" overriding the WorldProvider, without using a custom DimensionType entry with the correct provider

This option allows you to specify the spawn point search algorithm and the allowed y-range for the spawn point.

The spawn point search automatically happens for any dimensions that use WorldInfo override. This is so that if the player is teleported to the dimension's spawn point, that position would hopefully be a safe location. If you don't want this search to happen, then use the type none.

• type (string) - One of overworld, cavern or none. The cavern type is used for Nether dimensions by default. none skips the spawn point search for that dimension, and uses the spawn point of the overworld.
• min_y (int) - The lowest y-coordinate to search in. Defaults to 30 in the cavern type and 1 in the overworld type.
• max_y (int) - The highest y-coordinate to search in. Defaults to 120 in the cavern type and the chunk's highest filled section's top + 1 in the overworld type.

Example:

"SpawnPointSearchType": {
	"type": "cavern",
	"min_y": 40,
	"max_y": 100
}

The sky teleport and void teleport features allow you to teleport away any entities from the dimension when the entity goes above or below the specified y height limit. The sky teleport variant will trigger when the entity goes above the configured trigger_y y-height. The void teleport variant will trigger when the entity goes below the configured trigger_y y-height.

Here is a "pseudo json" example showing the available options:

"<sky | void>_teleport": {
	"dimension": 10,
	"trigger_y": -10,
	"find_surface": <true | false>,
	"remove_fall_damage": <true | false>,
	"fall_distance": 4.5,
	"min_health_left": 1,
	"teleport_type": "<same_location | fixed_location | spawn | scaled_location | relative_location | scaled_relative_location>",
	"scale": [8, 1, 8],
	"fixed_location": [256, 64, 256],
	"relative_location": "~ 256 ~+32"
}

• dimension (int) - The target dimension where the entity will be teleported to
• trigger_y (int) - The trigger y height limit for teleportation. (sky = above this, void = below this)
• find_surface (boolean) - If true, then the teleport code will place the entity on the ground (either above or below the configured position), instead of putting it exactly at the configured position.
• remove_fall_damage (boolean) - Whether to completely remove fall damage when teleporting. (How did this work again? What if the entity falls after the teleport?)
• fall_distance (float) - If remove_fall_damage doesn't exist, but this key/value does, then this value will be used as the fall distance when dealing fall damage on teleport
• min_health_left (int) - If this value exists, then the maximum fall damage/distance will be limited such that this amount of health will remain
• teleport_type (string) - One of same_location, fixed_location, spawn, scaled_location, relative_location, scaled_relative_location
  • same_location - the entity will be teleported to the same coordinates in the target dimension (when the teleport triggers)
  • fixed_location - The entity will be teleported to the given exact fixed location in the target dimension
  • spawn - The entity will be teleported to the dimension's spawn point in the target dimension
  • scaled_location - The entity will be teleported to a location that is scaled from its current coordinates by the given scale factors in scale.
  • relative_location - The entity will be teleported to a location that is relative to its current location. You can specify the vanilla command style relative offset in relative_location.
  • scaled_relative_location - The entity will be teleported to a location that is both scaled and relative to its current location. (TODO: scaling happens first, before relative offset, right?)
• scale (array of 3 floats) - For scaled_location and scaled_relative_location. This is the coordinate scale factor from the entity's position in the current dimension to the position in the target dimension.
• fixed_location (array of 3 ints) - The teleport position in the target dimension for the fixed_location type.
• relative_location (string) - The vanilla command style relative position specifier for the relative_location and scaled_relative_location types.

Here is a real example:

"void_teleport": {
	"dimension": 123,
	"trigger_y": -50,
	"find_surface": true,
	"fall_distance": 7.5,
	"teleport_type": "relative_location",
	"relative_location": "~ 256 ~"
}

• generatorName (string) - The WorldType for the dimension
  • Vanilla values: default, default_1_1, flat, amplified, largeBiomes, debug_all_block_states
  • Biomes 'O Plenty: BIOMESOP
• generatorOptions (string) - The generator settings. This is where your "superflat" settings string would go, or the vanilla customized overworld generator settings, or BoP config json strings etc.
• generatorVersion (int) - Certain WorldTypes may be versioned. In vanilla the default WorldType must use 1 here, otherwise it will use default_1_1 type instead.
• GameType (int) - The default game mode for joining players. 0 = survival, 1 = creative, 2 = adventure, 3 = spectator
• GameRules (object) - An object of string-to-string key-value pairs for all the game rules you want to set/override from the default values
• MapFeatures (int) - Use 0 to disable most structure generation. (No mineshafts, witch huts, ocean monuments, mansions, nether fortresses etc. will generate in this dimension)
• RandomSeed (int or string) - The world seed. Either the numeric seed directly, or a string which will get converted into a numeric seed. If not specified, then the same seed from the overworld will be used.
  • A special case is an empty string, which JED will use as indication to generate a new randomized seed for this dimension.
• SpawnX (int) - The dimension's spawn point's X coordinate. You don't need to specify all three coordinates. The ones you leave out will... ??? TODO
• SpawnY (int) - See above
• SpawnZ (int) - See above
• Time (long) - The total world time in this dimension. Note that you should never change this after the dimension is created, as it's used in various blocks and things for timing and delays, and changing it will break some stuff quite badly.
• DayTime (long) - The current day time in this dimension. Sleeping will advance it t othe next morning, and using /time set xxx will set/reset the value.
• LastPlayed
• LevelName
• clearWeatherTime
• rainTime
• raining (0 | 1) - Whether it's currently raining
• thunderTime
• thundering (0 | 1) - Whether it's currently thundering
• hardcore (0 | 1) - Whether hardcore mode is enabled in this dimension
• allowCommands (0 | 1) - Whether commands are allowed in this dimension
• Difficulty
• DifficultyLocked (0 | 1) - Whether chaging the difficulty is allowed (this is mostly for single player menu difficulty button)
• BorderCenterX (int) - World border center point X coordinate
• BorderCenterZ (int) - World border center point Z coordinate
• BorderSize (int) - The size of the world border
• BorderSizeLerpTime
• BorderSizeLerpTarget
• BorderSafeZone
• BorderDamagePerBlock
• BorderWarningBlocks
• BorderWarningTime