SliceWorld

SliceWorld is a challenging world-generation plugin for Paper 1.21.4 and Java 21.

It transforms the Overworld, Nether, and End into fragmented slices while preserving vanilla terrain, biomes, caves, ores, structures, and mobs inside the remaining pieces.

Build from platform to platform, make every resource count, and find your own way to defeat the Ender Dragon.

Note

SliceWorld is currently in beta.

Core gameplay has been extensively tested in singleplayer. Multiplayer support is implemented and has been reviewed for common issues, but has not yet been thoroughly tested with multiple live players.

Bug reports and feedback are very welcome.

Features

• Sliced Overworld, Nether, and End
• Reproducible generation based on the world seed
• Configurable slicing for each dimension
• Lazy Nether and End creation
• Preserved End portal frames and Blaze spawners
• Separate challenge inventories
• Shared multiplayer challenge worlds
• Persistent player positions
• Safe challenge spawn system
• Challenge-specific respawn handling
• English and German localization
• Context-sensitive join messages
• Clickable commands in join messages
• Full challenge reset with a new random seed

World generation

• Each new chunk has a reproducible 20% chance to be completely empty.
• A non-empty chunk keeps a reproducibly selected X- or Z-aligned strip that is 5–16 blocks wide.
• Only a reproducibly selected vertical section 3–5 blocks high remains.
• Everything outside the horizontal and vertical selection becomes air.
• All decisions depend only on the world seed and chunk coordinates.
• Existing generated chunks are never modified retroactively.

Vanilla strongholds still generate. END_PORTAL_FRAME blocks are preserved individually, including their direction and eye state, while the surrounding portal room remains subject to slicing.

Reliably detected Blaze spawners are also preserved.

The End's dragon fight, obsidian pillars, crystals, exit portal, gateways, and safe arrival platform remain functional.

Challenge dimensions and lazy creation

The challenge logically consists of:

• sliceworld
• sliceworld_nether
• sliceworld_the_end

/sliceworld create creates only sliceworld.

The Nether and End are created lazily when a player first uses the corresponding portal. Their seeds are deterministically derived from the main challenge seed.

Simultaneous first portal attempts share the same preparation process, and missing dimensions are not created automatically when the server starts.

Portal routing is isolated from normal server dimensions:

• sliceworld ↔ sliceworld_nether
• sliceworld ↔ sliceworld_the_end

When Nether slicing is disabled, Paper's normal portal search and creation are used inside sliceworld_nether, with the search starting below the logical Nether ceiling.

When Nether slicing is enabled, SliceWorld uses its safe portal and fallback-platform strategy.

Coordinate scaling remains the vanilla 8:1 ratio in both directions.

Configuration

The default plugins/SliceWorld/config.yml is:

language: en

dimensions:
  overworld: true
  nether: true
  end: true

Languages

Supported languages:

• en – English (default)
• de – German

All player-visible plugin messages are provided through the bundled messages_en.yml and messages_de.yml files.

The current language value is read fresh from config.yml whenever a player joins. Changing:

language: en

to:

language: de

therefore affects the next player join without requiring a server restart.

This live language check does not reload or modify dimension settings.

Unknown or missing language values fall back to English at runtime. Missing localized message keys first fall back to their English equivalent and then to a safe technical fallback message.

Join messages

Players receive a compact localized message shortly after joining.

The message depends on the current challenge state:

• If no SliceWorld exists yet, the player receives instructions for creating and starting a challenge.
• If a SliceWorld already exists and the player joins outside the challenge, the player receives a hint for continuing with /sliceworld start.
• If the player joins inside a challenge dimension, a short motivational message is shown instead.

Commands displayed in the introduction and continue messages are highlighted and clickable. Clicking them runs the same player command that could otherwise be typed manually.

Localized hover descriptions are also provided.

Normal command permissions still apply.

The join check only inspects already loaded worlds and existing world folders. It never loads or creates dimensions, teleports players, changes inventories, or modifies the challenge state.

Dimension modes

For each dimension:

• true enables SliceWorld generation.
• false keeps full vanilla terrain.

The configuration is read fresh from disk immediately before a dimension is created for the first time.

For example:

dimensions:
  overworld: true
  nether: true
  end: false

creates:

• a sliced Overworld
• a sliced Nether
• a vanilla End

Once a dimension has been created, its selected generation mode is stored with the world and later configuration changes do not modify existing or future chunks in that world.

Missing or invalid dimension values default to true.

Commands

Command	Description
/sliceworld create	Creates only the challenge Overworld and prepares its persistent safe spawn.
/sliceworld start	Enters the challenge at the player's last safe position or the persistent challenge spawn.
/sliceworld end	Saves the player's challenge position and safely returns them to a normal Overworld.
/sliceworld reset	Evacuates players, deletes existing challenge dimensions and data, generates a new seed, and creates a fresh challenge Overworld.

The alias /sw is also available.

Permissions

• sliceworld.use – allows create, start, and end
• sliceworld.admin – allows reset and inherits sliceworld.use

Both permissions default to server operators.

Safe spawn and teleportation

When a challenge Overworld is created, SliceWorld searches at most 25 chunks in an outward spiral for a suitable starting position.

Chunks are prepared through Paper's asynchronous API and evaluated over multiple ticks to avoid blocking the server thread.

Spawn candidates must:

• be above Y=20
• have open sky
• provide solid and safe ground
• provide two free blocks for the player

Natural ground is preferred, while logs and leaves receive a strong penalty so players are not intentionally spawned directly on valuable resources.

If no suitable candidate is found, SliceWorld creates a safe 5×5 stone fallback platform.

The resulting safe spawn is stored with:

• world UUID
• world seed
• coordinates
• yaw
• pitch

Later /sliceworld start attempts validate only the player's stored chunk. If a personal return position is invalid, the player falls back directly to the persistent challenge spawn without another large search.

The generated safe spawn is stored separately in:

plugins/SliceWorld/safe-spawn.yml

SliceWorld never rewrites config.yml while saving or clearing this internal state. Manually selected language and dimension settings therefore remain untouched.

Persistent player positions

Player positions are stored in:

plugins/SliceWorld/playerdata.yml

Stored data includes:

• UUID
• world
• coordinates
• yaw
• pitch

Positions are updated after entering the challenge, before leaving it, on logout, and during server shutdown.

A reset removes all saved challenge return positions.

Inventory separation

Normal server worlds and SliceWorld challenge worlds use completely separate player states.

The shared challenge inventory group includes:

• sliceworld
• sliceworld_nether
• sliceworld_the_end

Travel between these three worlds does not switch inventories.

Stored player state includes:

• inventory
• hotbar
• armor
• offhand
• Ender Chest
• experience
• health
• hunger
• saturation
• exhaustion
• remaining air
• potion effects

Inventory data is written to:

plugins/SliceWorld/inventories.yml

Persistence uses a temporary file, atomic replacement where available, and a backup.

Per-player transition locks and in-memory rollback protection help prevent duplication or data loss during inventory transitions.

Normal death drops and keepInventory behavior apply only to the currently active inventory group.

Logout, login, shutdown, plugin teleports, portals, and external cross-world teleports preserve the correct player state.

Multiplayer

SliceWorld uses one shared set of challenge worlds for all players.

Everyone sees the same:

• seed
• chunks
• Overworld
• Nether
• End

New players without a personal saved challenge position use the same persistent initial challenge spawn.

Once a player has entered the challenge, their later return position remains individual.

Inventories, saved positions, bed locations, respawn states, pending deaths, command transitions, and portal cooldowns are tracked separately for each player by UUID.

Lazy dimension preparation is shared, preventing concurrent first entries from starting independent Nether or End creation processes.

During /sliceworld reset, new challenge entries and pending teleport completions are rejected until all current players have been safely evacuated.

Multiplayer behavior has been reviewed for common race conditions, but live-server testing with multiple accounts is still limited during the beta.

Challenge respawn behavior

Deaths in any SliceWorld challenge dimension never respawn a player in a normal server world.

Respawn priority depends on the dimension and available respawn points.

Valid SliceWorld beds are used where appropriate.

After deaths in the SliceWorld Nether, a valid Nether respawn anchor has priority.

If no valid personal respawn point exists, the persistent safe spawn in sliceworld is used.

Pending challenge deaths survive logout from the death screen and are cleared after a successful respawn or challenge reset.

Respawn handling does not create unused dimensions or perform broad synchronous chunk searches.

Reset behavior

/sliceworld reset completely starts the challenge over with a new random seed.

The reset process:

1. Restores the normal inventory of every player currently inside a challenge dimension.
2. Evacuates those players to a safe normal Overworld spawn.
3. Unloads only challenge worlds that actually exist.
4. Validates their exact world-container paths.
5. Deletes the challenge world folders without saving them again.
6. Clears challenge positions, inventories, beds, and pending respawn states.
7. Generates a new random main challenge seed.
8. Creates only a fresh sliceworld.

The Nether and End remain absent until they are used for the first time and will read the then-current dimension configuration.

Normal server inventories are never deleted.

If evacuation, unloading, deletion, or data handling fails, the reset stops and logs the technical details instead of continuing with a partially reset challenge.

Requirements

• Paper 1.21.4
• Java 21

Installation

1. Stop the Paper server.
2. Copy SliceWorld-0.1.8.jar into the server's plugins/ directory.
3. Start the server.
4. Run /sliceworld create.
5. Wait for the safe spawn preparation to finish.
6. Run /sliceworld start.

You're ready to begin the challenge.

Good luck — you're going to need it.

Building

Maven 3.9 or newer is required.

Build the project with:

mvn clean package

The resulting plugin is written to:

target/SliceWorld-0.1.8.jar

Inspiration

SliceWorld was inspired by Minecraft challenge videos featuring worlds divided into thin slices, particularly challenges played by BastiGHG.

I really liked the core idea and wanted to create my own interpretation of the challenge. SliceWorld expands on the concept with randomized slice widths and heights, completely empty chunks, configurable dimensions, and additional gameplay mechanics for the Overworld, Nether, and End.

SliceWorld is an independent, unofficial project and is not affiliated with or endorsed by BastiGHG.

Development

SliceWorld was developed with the assistance of AI tools, including OpenAI Codex.

The project concept, gameplay design, feature decisions, testing, configuration, and release decisions are managed by RodJays. AI-assisted development is used to help turn these ideas and designs into working code.

License

This project is licensed under the MIT License.