Session-safe reconnect.
A player drops mid-round? Their state is snapshotted. They rejoin within the hold window and land exactly where they were — inventory, position, score, intact.
Conduit 0.8.0 · Minecraft 26.1.2
The framework for Minecraft minigames.
A modular server-side toolkit for shipping production-grade Minecraft minigames. Lifecycle, instancing, in-world UI, spectator, session-safe reconnect — out of the box.
Add to build.gradle
implementation "me.zlex:conduit-core:0.8.0+mc26.1.2" Powering live minigames
SaboCraft Block Shuffle Potion Shuffle Sprint Race Pillars MobWheel
By the numbers Built for scale.
Built for scale.
Built to last.
8
0
45
∞
Why Conduit Solves the hard parts.
Solves the hard parts.
Stays out of the rest.
The boring infrastructure of every minigame — teleports, sessions, instancing, lifecycle — solved once. So you spend your time on the round you’re actually shipping.
In-world UI, server-authoritative.
Render menus, labels and HUDs as block displays. Compile a ScreenLayout once, show it anywhere. No server-side mixins — vanilla clients fall back to chat.
Crash-proof spectator.
Promote and demote without the vanilla gamemode-switch crash. Chunk-safe, dimension-safe, no client desync.
Dynamic instance pool.
One server, many parallel game instances. The pool grows on demand and recycles when a round ends.
Authored scenes.
Reusable JSON-defined chunks of world. Structures, props, named zones. Spawn and despawn at runtime, bind variables.
Events-first, mixins minimized.
Fabric API events first; mixins only where no event exists — a handful of accessors. Fewer mixins, cheaper ports. Bumping Minecraft is days, not months.
Step through
Into the Hub.
Scroll to enter the framework.
core
render
arena
world
spectator
fx
prefab
instance
conduit-core
The foundation.
Config, permissions, session-safe teleport, inventory stash, per-player state. The primitives every module above stands on.
Read the docs Developer experience Write a round
Write a round
in real time.
Composable primitives that solve the hard parts — teleports, sessions, in-world UI, lifecycle. Scroll to watch them write themselves.
Safe teleportWorld-anchored UISession policyRegister a game
import me.zlex.conduit.teleport.SafeTeleport; // Defers one tick + ticket-loads the chunk so the// player never lands in unloaded terrain.SafeTeleport.teleport(player, destLevel, pos, yaw, pitch, arrived -> { arrived.heal(arrived.getMaxHealth()); arrived.fallDistance = 0f;});
import me.zlex.conduit.screen.ServerScreenManager;import me.zlex.conduit.screen.ui.layout.ScreenLayout; var panel = new ScreenLayout(Theme.darkBlue(), bg, List.of( Widgets.title("Welcome"), Widgets.button("Confirm", () -> handleConfirm()) )).compile(); ServerScreenManager.showWithId(player, SCREEN_ID, center, normal, 8f, 5f, panel);
import me.zlex.conduit.player.PlayerSessionManager;import me.zlex.conduit.player.SessionPolicies; // Snapshot state on disconnect; on reconnect within// the hold window, restore where they were.PlayerSessionManager.registerGame("example", SessionPolicies.stayWherePlayerWas() .withHoldWindow(Duration.ofMinutes(5)) .onTimeout(player -> onAbandon(player)));
import me.zlex.conduit.arena.InstanceManager; // Spin up a fresh instance on demand;// recycle the dimension when the round ends.InstanceManager.register("block-shuffle", ctx -> new BlockShuffleGame(ctx) .withMinPlayers(2) .withMaxPlayers(16) .withVoidDimension());
Architecture
Built from bedrock up.
Higher layers compose lower ones. No circular dependencies, no surprise coupling — just a clean stack you can depend into at any level. Scroll to raise it.
your application
your-minigame-mod
conduit-arena
InstanceManager
HubManager
LobbyEngine
Game
PhaseMachine
prefab · fx · spectator · world · instance
Scene
PlayerBossbar
SpectatorManager
WorldSettings
RuntimeDimensions
conduit-render
ServerScreenManager
WorldBlockDisplay
ScreenLayout
conduit-core
SafeTeleport
PlayerSessionManager
PlayerInventoryStash
ConduitConfig
Questions
The honest answers.
Why Fabric and not Paper or Spigot?
Fabric is the closest you can stay to vanilla while still having a real API. No NMS reflection, no patched server jar, no eight-month wait for a port. When Mojang ships an MC update, Conduit catches up in days.
Server-side or client-side?
Game logic, state, and authority live on the server. For in-world UI (screens, labels, 3D displays), Conduit ships a small client companion mod that renders what the server tells it to. Vanilla clients can still connect and play — they just skip the rich UI and fall back to chat-driven prompts and entity-based displays. The split keeps the server in charge of every gameplay decision and avoids anti-cheat conflicts.
How does Conduit handle MC version bumps?
Each Conduit release is pinned to a specific Minecraft version (the `+mc26.1.2` part of the artifact). When Minecraft ships a release, a matching Conduit release usually follows within a week. There are no breaking API changes across patches.
Is it production-ready?
Conduit powers a portfolio of live minigames (SaboCraft, Block Shuffle, Sprint Race, Pillars, MobWheel, Potion Shuffle). It survives crashes, reconnects, and long-running sessions. APIs are stable; semver is honored.
What about performance?
The hot paths are written to avoid allocations and reflection. SafeTeleport defers exactly one tick. The instance pool reuses dimension state. There is no background work when no games are running.
Can I use it?
Conduit is a closed-source personal project right now — the source isn't public. This site is a window into what it is and how it's built, not a download. That may change down the line.
Ready when you are
Ship a playable round in an evening.
Walk the quickstart, depend on the modules you need, and have a working game loop running on a local server before you finish your coffee.