# minecraft.how — Full content index for LLMs

> Long-form extract of recent blog content. For a structured route map, see /llms.txt.

## Recent blog posts (full text)

### SkyHanni: How to Enhance Your Hypixel SkyBlock Experience
URL: https://minecraft.how/blog/post/skyhanni-skyblock-mod-guide
Published: 2026-04-23
Author: ice

GitHub · Minecraft community project SkyHanni (hannibal002/SkyHanni) SkyHanni is a Minecraft Mod for Hypixel SkyBlock. Star on GitHub ↗ .1 If you play Hypixel SkyBlock and aren't using SkyHanni, you're burning time on tasks that a mod could handle for you. This Fabric mod transforms the SkyBlock experience with smart highlights, helpful reminders, and customizable displays that actually reduce tedium instead of adding clutter. What You're Getting With SkyHanni SkyHanni isn't a "make me better" mod. And it doesn't give you unfair advantages or break Hypixel rules. What it does is eliminate friction from repetitive gameplay loops. Think of it as quality-of-life tooling for activities you're already doing dozens of times per session. The mod adds several categories of features: helpful GUI windows that display important information at a glance, smart chat enhancements that remind you about time-sensitive events, object highlighters that focus your attention on what matters in crowded screens, and customizable overlays for your scoreboard and tab list. If you're doing farming runs, slayer quests, Bingo challenges, or Rift content, there's almost certainly a SkyHanni feature designed to reduce busywork. It's written in Kotlin and built for Fabric. That means it's lightweight and plays nicely with other mods in most cases. Who Actually Uses This (and Why) Serious SkyBlock players use SkyHanni. But "serious" doesn't mean no-life grinding. It means players who've done the same task enough times to find it annoying and wonder if there's a better way. That's most of the active SkyBlock community. The mod shines during specific activities. Farming becomes less of a visual puzzle when SkyHanni highlights pests before you destroy your crops by accident. Slayer quests have timers and damage notifications you don't have to manually track. Fishing expeditions show reward rarities in real time. Mining in the Dwarven Mines or Deep Caverns gets a safety net with lava warnings and ore highlighting. The Rift dungeon (one of SkyBlock's most complex areas) has multiple SkyHanni tools specifically designed to reduce confusion in an already overwhelming space. And honestly, once you've played with these features, going back feels like playing with one eye closed. Installation (It's Straightforward, Mostly) You'll need a few pieces in place first. SkyHanni requires Fabric as your mod loader (not Forge, at least not for the latest versions). If you don't have Fabric installed yet, the process is standard: download the Fabric installer for your Minecraft version, run it, and point it at your game directory. Once Fabric is ready, grab the latest SkyHanni release for your Minecraft version. The project supports 1.8.9 (if you're running ancient gear or have specific reasons), 1.21.5, 1.21.8, and 1.21.10. That JAR file goes directly into your mods folder. bashcp SkyHanni-6.0.0-mc1.21.10.jar ~/.minecraft/mods/ Launch Minecraft with the Fabric profile and load into a SkyBlock server. You'll see a new command available: type /sh or /skyhanni to open the settings menu. That's where all the customization happens. One thing to watch: Fabric modding in general has a smaller margin for error than Forge. Adding conflicting mods or running without required dependencies can break things silently. The SkyHanni community on Discord is active if something doesn't work the first time. Features That Actually Save Time SkyHanni v6.0.0 added 17 new features, but the real value is in the ones you'll use every session. Here are the ones players swear by: GitHub project card for hannibal002/SkyHanni Farming Assistance is surprisingly complex. The mod can highlight pests before they damage your crops, display hoe levels so you know when upgrades help, and even mute the obnoxious hoe level-up sound. If you're rotating through multiple islands doing farming tasks, these small QoL touches compound over hours of play. Dungeon Helpers show unopened chests in Croesus encounters and provide a Secret Tracker tool that guesses where secrets are hiding. For players new to dungeons, this is less "cheating" and more "explaining the game's rules." Dungeons deliberately hide their win conditions; this mod makes them transparent. Slayer Notifications send chat reminders and overlay alerts when important events happen during slayer quests. You don't miss phase changes or boss mechanics because you were glancing at Discord. The Rift, one of SkyBlock's hardest content areas, gets its own suite: Ubik Cube timers, Bacte Kill Zone warnings, and general navigation helpers that honestly should be in the base game. Customizable Displays let you reshape your HUD to your preferences. Reorganize your scoreboard, change chat formatting, add or remove elements as you see fit. This one separates SkyHanni from "just" a helper mod. It's genuinely flexible. Things That Trip Up New Users SkyHanni's settings menu is powerful but dense. First-timers often enable everything and end up with a cluttered screen. Real talk: disable 70% of features you don't need yet. You'll know when something's missing. The mod also won't work on vanilla servers or non-SkyBlock content. If you hop to other Hypixel games (Bed Wars, Skywars, etc.), SkyHanni mostly sits dormant. That's intentional by design - it's purpose-built for SkyBlock's specific mechanics. Compatibility matters. Some mods conflict with SkyHanni, especially ones that also modify GUIs or inventory rendering. The Discord FAQ and known issues list are required reading if you're running a large modpack alongside SkyHanni. Other Mods Worth Knowing About If you're optimizing your SkyBlock setup, other projects exist in the same space. Distant Horizons improves render distance without destroying FPS, which helps during exploration. Badlion Client and Lunar Client both have built-in SkyBlock features, though they're closed-source. There's also Skyclient, a full modpack preset that includes SkyHanni plus carefully vetted compatible mods, if you want a pre-configured experience. None of these are "replacements" - they serve different needs. SkyHanni is the most feature-rich open-source option specifically for SkyBlock mechanics. Getting Started Without Overthinking It Install it. Load into SkyBlock. Type /sh. Leave most features alone for your first session. Enable something that annoys you (like accidentally breaking crops) and see how it feels. Build from there. The community around SkyHanni is genuinely helpful. If you hit a wall, the Discord channels for bug reports, support, and suggestions are active. And if you know Kotlin and want to contribute features yourself, the project welcomes pull requests. The GitHub repo links to a contributor guide. It's worth mentioning too: if you're building and customizing your own Minecraft experience, tools like our Skin Creator let you design custom cosmetics, and if you're planning any Nether Portal networks for transportation or resources, the Nether Portal Calculator handles the math so you don't have to. SkyHanni does one thing exceptionally well: it makes SkyBlock feel less like a spreadsheet and more like a game you actually want to play. Where to go from here Read the source on GitHub (docs, examples, and the issue tracker) Browse open issues to see what the community is working on Check recent releases for the latest build or changelog

---

### Shulker: Managing Minecraft Servers With Kubernetes
URL: https://minecraft.how/blog/post/shulker-kubernetes-minecraft-servers
Published: 2026-04-23
Author: ice

GitHub · Minecraft community project Shulker (jeremylvln/Shulker) A Kubernetes operator for managing complex and dynamic Minecraft infrastructures, including game servers and proxies. Star on GitHub ↗ .0 If you're running more than one Minecraft server and you've got basic Kubernetes knowledge, Shulker might be the tool you didn't know you needed. It's a Kubernetes operator that automates provisioning, scaling, and managing Minecraft game servers and proxies at scale. This isn't for casual players spinning up a single server on their laptop. It's for people running infrastructure (hosting companies, large networks, anyone orchestrating dozens of servers) who want to stop doing repetitive server management by hand. What This Project Actually Does Shulker sits on top of Kubernetes and treats Minecraft servers as containerized workloads. Instead of SSH-ing into machines, clicking buttons in a hosting panel, or writing custom scripts to start/stop servers, you define Minecraft infrastructure in Kubernetes manifests. Shulker watches those manifests and creates or tears down real servers to match what you declared. Think of it as infrastructure-as-code for Minecraft. The core architecture uses agents deployed alongside your game servers. These agents communicate back to a central controller, which handles provisioning new server instances, managing proxies (like Velocity or Waterfall), and orchestrating the whole network. It's built in Rust, which means it's fast and memory-efficient compared to similar tools written in other languages. The project is now at v0.13.0 and includes a new CLI tool (shulker-cli) for managing servers programmatically. You can create servers on-the-fly from a fleet definition, or manage everything through standard Kubernetes objects. The latest release also patched bugs in LoadBalancer schema handling and fixed an SDK issue for manual server creation. Why You'd Actually Use This Most Minecraft servers run on a single machine. But if you're a hosting company or you're running a network with 50+ servers that need to scale up during peak hours and scale down to save costs, manual management becomes impossible. That's where Shulker solves a real problem. Dynamic scaling: Need 10 more servers for an event? Define it in Kubernetes and Shulker spins them up. Event ends? Scale back down automatically. No manual SSH: Stop logging into fifty machines to update server config or restart a process. Push changes to your manifest, Shulker handles the rollout. Self-healing infrastructure: A server crashes? Kubernetes restarts it. Shulker keeps everything running smoothly without you babysitting. Cost predictability: Run exactly as many resources as you need. If you're on cloud infrastructure, this saves real money. If you're running a small survival server for friends, you don't need this. If you're a hosting provider managing infrastructure for thousands of players, Shulker eliminates entire categories of operational headache. Installation and Prerequisites Shulker requires Kubernetes. Not Docker Compose, not a VPS with SSH access. Actual Kubernetes. If you're not already familiar with kubectl, custom resource definitions (CRDs), and YAML manifests, you'll need to learn those first. The Waiting Game. The project's documentation is at shulker.jeremylvln.fr with a getting-started guide covering prerequisites. Basic installation looks like this: bashkubectl apply -f https://github.com/jeremylvln/Shulker/releases/download/v0.13.0/stable.yaml That downloads the stable release manifest for v0.13.0. There's also a variant with Prometheus metrics included if you want monitoring. After applying the manifest, Shulker's operator deploys into your cluster and watches for Minecraft infrastructure objects. You'll also need container images for Minecraft servers. Shulker doesn't provide pre-built images; you define those separately, either using an existing Minecraft server image from Docker Hub or building your own. The operator orchestrates containers but doesn't create them for you. How the Key Features Actually Work At its core, Shulker uses Kubernetes custom resources (CRDs) to describe Minecraft infrastructure. You define a Fleet (a template for servers), then create MinecraftServer objects that reference the fleet. When you apply that manifest, Shulker spins up a Kubernetes Pod running your server container. Multiple servers? Define multiple MinecraftServer objects. Shulker creates as many Pods as you declare. The agent-based architecture is clever. Each server Pod runs a Shulker agent that maintains a gRPC connection back to the central controller. The controller stays informed about server health, player counts, and other metrics without needing SSH or constant polling. Network management is another strong point. Shulker handles proxy configuration for you. If you've got 20 servers and players connecting through a BungeeCord or Velocity proxy, Shulker updates proxy configs automatically as servers come and go. No manual proxy config edits. The new shulker-cli tool (added in v0.13.0) lets you create servers programmatically instead of writing manifests by hand. This is useful for hosting platforms that need dynamic server creation APIs. You can also manage everything through the gRPC API directly if you prefer. Real Gotchas and Common Pitfalls Steep learning curve is the first one. If you're thinking "I'll learn Kubernetes while setting up my Minecraft servers", you're in for a rough time. Shulker assumes you already know kubectl, understand Kubernetes networking, and can troubleshoot container issues. That's not a knock on the project; it's just being honest about who the audience is. The End City Container management adds another layer. You need to build or find Minecraft server images that work with Shulker's agent. If you use a standard Minecraft Java image but forget to include the agent binary, the server won't stay connected to the cluster. The errors you'll debug are Kubernetes-level, not always obvious Minecraft-level issues. Resource requests matter more than you think. Misconfigure Kubernetes resource limits on your Minecraft Pods and servers get OOMKilled (out of memory) under load. Shulker doesn't hide Kubernetes complexity; it expects you to understand your infrastructure layer. AGPL licensing is worth noting. If you modify Shulker and distribute it, you must share those modifications. For internal use this doesn't matter. For offering Shulker as part of a hosting service, it has legal implications you should discuss with legal counsel. The maintainer mentions being open to commercial licensing discussions on GitHub. Alternatives and How Shulker Compares If you need simpler server orchestration, Docker Compose on a single VPS gets you running servers without Kubernetes overhead. But it won't scale to dozens of servers easily, and failover is manual. Traditional hosting control panels (Pterodactyl, for example) let you manage multiple servers through a web UI. That's less declarative than Shulker, but it's also less of a learning curve if you're not Kubernetes-comfortable. Pterodactyl assumes you've already got VMs or physical machines; Shulker assumes you've got a Kubernetes cluster. Writing custom Kubernetes operators for Minecraft infrastructure is possible if you want something tailored to your exact needs. But that means building and maintaining your own code. Shulker is open-source and actively maintained, which saves that engineering effort if it solves your problem. The 378-star GitHub project has an active community and ongoing development. Latest releases happen regularly. If you're already running Kubernetes and managing multiple Minecraft servers, Shulker is genuinely worth evaluating. If you're not on Kubernetes, the barrier to entry is high enough that you should ask yourself whether you need this level of infrastructure first. Building Minecraft infrastructure is its own skill. Want to improve your server's visibility while you're building it? Check out Minecraft's MOTD Creator to craft compelling server descriptions that show up in the multiplayer menu. And if you're hosting player communities, Browse Minecraft Skins to find assets that match your server's theme.jeremylvln/Shulker - AGPL-3.0, ★378 Ready to try Shulker? Grab the source, read the full documentation, or open an issue on GitHub. Star the repo if you find it useful. It helps the maintainers and surfaces the project for other Minecraft players. Visit jeremylvln/Shulker on GitHub ↗

---

### TabTPS: Real-Time Server Performance Monitoring for Minecraft Admins
URL: https://minecraft.how/blog/post/tabtps-minecraft-server-monitoring
Published: 2026-04-23
Author: ice

"Minecraft server mod/plugin to monitor TPS, MSPT, and other information in the tab menu, boss bar, and action bar." jpenilla/TabTPS · github.com If you run a Minecraft server, you've probably had that moment: players complaining about lag, and you've no idea if it's your server struggling or their connection. TabTPS puts server health metrics right in front of you (and your players) so everyone knows what's actually happening under the hood. What TabTPS Actually Does TabTPS is a server plugin and mod that displays live performance metrics where your players can actually see them. You can show TPS (ticks per second), MSPT (milliseconds per tick), and other server data in three different places: your player tab list, the action bar (that line of text above your hotbar), or as a boss bar at the top of the screen. Think of it this way: normally, if your server is running at 10 TPS instead of the standard 20, only you (as an admin) would know by checking logs. Your players would just feel the lag without understanding what's happening. TabTPS closes that gap. Players see the numbers. They understand the problem isn't them. And you get immediate feedback about what's actually stressing your server. It's surprisingly practical for a tool that sounds simple. Why This Matters for Server Admins Running a server means constantly balancing performance. Add too many plugins, and TPS tanks. Lag gets worse during prime hours when half your player base logs in. Building large mob farms? That eats resources. Running an ambitious world with custom terrain? More strain. Without visibility into what's happening, you're flying blind. You make changes and hope they help, but you never really know if it worked. TabTPS gives you that visibility, and it communicates directly to players who might otherwise blame the server unfairly. Plus, there's a psychological element. When players can see the server is struggling but you're actively working to fix it (and the metrics improve), they're way more patient. When they understand performance issues are temporary spikes rather than constant problems, they stick around. Transparency builds trust, and metrics are the most transparent thing you can give. Actually, this is one of those tools that feels optional until you run a server, then it becomes indispensable. Installing TabTPS on Your Server Type TabTPS supports multiple server platforms, which is huge. Whether you're running Paper (the most common choice for survival servers), Sponge, Fabric, or NeoForge, there's a version for you. For Paper servers, the installation is straightforward. Download the plugin JAR from the GitHub releases, toss it in your plugins folder, and restart the server. That's it. If you're setting up a new server from scratch, tools like the Server Properties Generator can help you configure basic server settings quickly, so you can focus on installing performance monitoring like TabTPS afterward. bash1. Download TabTPS JAR from the GitHub releases page 2. Place the JAR in your /plugins directory 3. Restart your server 4. Navigate to /plugins/TabTPS/ and customize configs as needed The Fabric and NeoForge versions require Fabric API as a dependency (at least for Fabric), so make sure that's installed first. That setup's the same conceptually, just make sure you're grabbing the right build for your platform and Minecraft version. This project supports Minecraft 26.1.2 and several earlier versions, so check the releases page to grab the one that matches your server version. The Main Features That Actually Matter TabTPS has more granular control than you'd expect from a "show me numbers" plugin. Display Configurations: You can create custom display configs in the config folder, and assign different ones to different permission groups. Maybe admins see detailed performance metrics, but regular players just see a simple TPS indicator. Or maybe you change the display based on server load. The flexibility is there. You can even customize what information gets displayed where, which matters more than it sounds when you're trying to keep your UI clean. Themes: There's a theming system for colors. Not critical, but nice if you want the metrics to match your server's brand or just make them easier to read at a glance. The /tickinfo and /mspt Commands: These show you a breakdown of what's eating CPU time on each tick. Is it the main game thread? Plugin overhead? Mob pathfinding? You get numbers. It won't pinpoint exactly which plugin is the culprit (you'd need more advanced profiling tools for that), but it narrows the field faster than guessing. Ping Display: The /ping, /ping [player], and /pingall commands show player latency. This is useful for diagnosing whether lag is server-side or player-side. If everyone reports lag but ping numbers are normal, it's definitely your server. If everyone's ping spikes together, someone on the network's having a rough time. Memory Info: The /memory command shows how much RAM different parts of the JVM are using. This is less useful for casual servers but genuinely helpful if you're trying to figure out why your server is eating 12GB of RAM when you allocated 8GB. You can see garbage collection pressure, heap usage, and spot memory leaks before they become critical. Configuration Tips and Common Gotchas One thing that catches people off guard: the display configs use a permission system. By default, everyone gets tabtps.defaultdisplay, which works fine. But if you start creating custom configs, remember that only players with the associated permission will use that config. If a player has permission for multiple configs, their priority setting in the main config determines which one kicks in. This is intentional, but it trips people up because they assume the last permission wins. If you're running permissions via LuckPerms or another plugin, make sure your permission nodes are actually being applied. I've seen servers where the display just doesn't show up, and it's because the permission wasn't synced properly. Double-check your permissions setup if the metrics aren't appearing. The reload command (/tabtps reload) lets you update configs without restarting, which is handy. But be aware that some changes might require a full restart to take effect properly, depending on what you're modifying. When in doubt, restart. One more thing: the tab display works best when you're not already using massive portions of the tab list for other plugins. If you've got a huge scoreboard or banner system that uses the tab list, TabTPS needs space to work with. It's not incompatible, but you'll want to plan your layout. If you're designing a custom look for your server, consider whether player names, team displays, and performance metrics can coexist without cluttering the screen. For smaller servers, consider starting with a simple action bar display instead of reworking your entire tab list. It's less intrusive, gives everyone the info they need, and you can always expand it later. You could also use the Minecraft Text Generator to create custom formatting for your other server messages, keeping everything visually cohesive. Alternatives and When They Matter Spark is legendary in the server admin community for performance profiling. If you need deep CPU and memory analysis, Spark is probably better. But Spark is more for admins diving into logs and data; TabTPS is for real-time visibility that everyone sees. They actually work well together. Spark diagnoses the problem. TabTPS shows it to your players. There are a few other monitoring plugins out there, but most solve a different problem. GeyserMC has some performance monitoring, but it's coupled to Bedrock support, so only relevant if you're running a hybrid server. ProtocolLib can help with network profiling, but again, different tool for a different job. Honestly, TabTPS fills a pretty specific niche (real-time metrics everyone can see), and the alternatives either overlap too much or solve a different problem. For what it does (showing metrics your players can see without needing external dashboards), it doesn't have a direct competitor in the plugin ecosystem. That's actually why it's remained relevant for so long. The project itself is well-maintained, currently supports Minecraft 26.1.2, and the 320 GitHub stars reflect a solid community that actually uses it. Written in Java with an MIT license, it's transparent and free to use on any server type that supports the plugin API. Support the project TabTPS is maintained by the open-source community. If it saved you time or powered something cool, leave a ⭐ on the repo, report bugs, or contribute back. Small actions keep tools like this alive.

---

### PolyMC Launcher: Managing Multiple Minecraft Setups in 2026
URL: https://minecraft.how/blog/post/polymc-minecraft-launcher-guide
Published: 2026-04-23
Author: ice

PolyMC/PolyMC A custom launcher for Minecraft that allows you to easily manage multiple installations of Minecraft at once (Fork of MultiMC) ⭐ 2,012 stars.0 If you're juggling multiple Minecraft setups - vanilla survival, modded servers, snapshots, texture packs you're testing - managing them separately is painful. PolyMC is a custom launcher that organizes all of them in one place, letting you switch between completely different game configurations instantly. What PolyMC Actually Does PolyMC is a custom launcher for Minecraft, built as a fork of MultiMC with a focus on stability and predictability. Instead of having a single Minecraft installation that you'd need to mess with to switch between vanilla and modded, or different Java versions, PolyMC lets you create isolated "instances" for each setup you want to maintain. Think of instances like separate game folders that don't interfere with each other. You've one for your Survival world, another for testing mods, one with Fabric, one with Forge, whatever. Launch whichever you want without touching anything else. The launcher itself is written in C++ and runs on Windows, macOS, and Linux. It's open source under the GPL-3.0 license, with around 2,000 GitHub stars and active development. Why You'd Actually Need This The default Minecraft launcher works fine if you're only playing vanilla. But most people want more. You might want to test mods without nuking your main world. Or run the same world on different Java versions to see if one performs better. Or jump between modded servers that require completely different mod lists. Each instance in PolyMC can have its own Java version, memory allocation, mods folder, resource packs, and game version. This matters more than it sounds - some older mods break on newer Java versions, and manually juggling all that gets tedious fast. If you're building a modpack for friends, PolyMC makes testing way easier. If you're a server admin who needs to match your client setup to the server config, you've got precise control per instance. Installation and First Launch Installation depends on your OS. The project provides downloads on their website, with multiple options for each platform. On Linux with AppImage (simplest for most): bashwget https://github.com/PolyMC/PolyMC/releases/download/7.0/PolyMC-Linux-7.0-x86_64.AppImage chmod +x PolyMC-Linux-7.0-x86_64.AppImage./PolyMC-Linux-7.0-x86_64.AppImage If you're on Arch, there's an AUR package (polymc-git for development builds). Debian users can grab polymc-git from the MPR. The project also publishes Qt6 builds if you're particular about your libraries. Windows and macOS get standard installers. One note for macOS - if you use AppImageLauncher, make sure it's version 3.0 alpha-4 or newer, otherwise it'll break PolyMC's AppImage. Creating Instances and Managing Versions When you create a new instance, PolyMC asks which game version you want. Pick anything from old releases to the latest (26.1.2 as of April 2026) or even snapshots. You select your mod loader - Vanilla, Forge, Fabric, NeoForge (new in v7.0) - and that's mostly it. From there, each instance has its own folder structure. Mods go in the mods folder, resource packs in resourcepacks, etc. You can launch from PolyMC with custom Java arguments if you need them. Want to allocate 8GB of RAM to one instance and 4GB to another? Set it per instance. Version 7.0 switched the Minecraft page to use tabs, which is cleaner. There's also a detail that saves headaches - you can set a default mod download platform so PolyMC knows whether to pull from Modrinth or CurseForge by default. Features That Actually Matter Java management is legitimately useful here. PolyMC can auto-download Java versions for you, including newer builds like JDK 21. Each instance can use a different Java version independently. This solves a huge category of "my mods don't work" problems because some mods break on newer Java versions and need older releases. GitHub project card for PolyMC/PolyMC Mod loader support is full. Fabric and Forge obviously work. Recent versions added full NeoForge support (the Forge fork that's gaining traction). You can also run vanilla instances if you just want to organize without modding. The launcher includes built-in tools for managing versions. You can install resource packs directly from the instance settings rather than hunting through folders. If you're setting up a server, PolyMC can help you sync your client instance to match your server's modlist and avoid painful troubleshooting later. And if you're using the Server Properties Generator to configure your server, you can apply those same settings to your PolyMC instance. The Minecraft Whitelist Creator also pairs well if you're managing player access. Common Gotchas New Users Hit Storage is the big one. Each instance is a full copy of the game, so 10 instances with 100+ mods each means serious disk space. Java detection sometimes needs babying. If PolyMC can't find your Java installation automatically, you'll need to point it manually. The logs are explicit about what went wrong, which helps. Modpack importing works, but it's got limits. Not every modpack launcher format is fully supported, and some built for other launchers might need tweaks. The project keeps improving this, but it's not 100% transparent. And here's something that catches people: account migration. If you're switching from the default launcher, you keep your Microsoft account login (assuming you've migrated from your old Mojang account). But you need to log in first - PolyMC won't pull credentials from the old launcher. How It Stacks Against Other Launchers The official Minecraft Launcher is fine. It launches the game. The result doesn't give you instance management or version control, which PolyMC does. If you're only playing vanilla, it's probably fine. If you're touching mods, PolyMC is objectively better. MultiMC is PolyMC's ancestor - stable, well-established, but PolyMC's specifically designed to be its more predictable successor. The fork exists because the original MultiMC maintainer wasn't accepting certain changes the community wanted. CurseForge Launcher and GDLauncher are fine if you only install modpacks and don't care about fine-grained control. Both are more "point and click modpack installer" than "precise control over every game setting." Building From Source (If You Want) Most people won't need to. But if you're on an unsupported OS or want the absolute latest development build, the project provides build instructions. It's C++, so you'll need CMake and a compiler. The Nix package was recently updated if you're already in that ecosystem. If you fork it for a custom build, the project's policy is straightforward: change the API keys in CMakeLists.txt to your own (or empty string to disable them), and make it clear it's not the official PolyMC. That's it. The Takeaway PolyMC solves a real problem for anyone managing multiple Minecraft setups. It's stable, well-maintained, cross-platform, and genuinely free. If you're tired of manually swapping mods or Java versions, it's worth an afternoon to set up. The community's active on Discord and Reddit if you hit issues. It's not flashy. It just works, which is exactly what you want from a launcher.PolyMC/PolyMC - GPL-3.0, ★2012 Where to go from here Read the source on GitHub (docs, examples, and the issue tracker) Browse open issues to see what the community is working on Check recent releases for the latest build or changelog

---

### PacketEvents: Building Smarter Minecraft Servers with Packet Interception
URL: https://minecraft.how/blog/post/packetevents-minecraft-packet-library
Published: 2026-04-23
Author: ice

"PacketEvents is a protocol library tailored to Minecraft Java Edition, designed to facilitate the processing and transmission of packets." retrooper/packetevents · github.com .0 If you've ever wondered how anti-cheat systems catch hackers, how custom game modes work, or how some servers add features Minecraft doesn't officially support, the answer almost always involves packet interception. PacketEvents is the library that makes this possible, and if you're developing for Minecraft servers, it's probably worth understanding. What This Project Does PacketEvents is a protocol library that sits between your Minecraft server and its players, giving you the ability to intercept, inspect, and modify the packets flowing back and forth. Instead of being locked into vanilla Minecraft behavior, you can listen for specific packet events and react to them in real-time. Think of packets like messages. When a player hits someone, moves, places a block, or uses an item, their client sends a packet to the server describing that action. Normally, your server just processes these packets as-is. With PacketEvents, you can read those messages, check if something looks wrong, and either allow it or block it. You could detect impossible movement speeds, prevent glitched item duplications, or add entirely custom mechanics that normal plugins can't achieve. The library works across multiple server platforms - Spigot, Velocity, BungeeCord, Fabric, and Sponge all get support. That means whether you're running a small survival server or a massive network, PacketEvents speaks the same language. Why You'd Actually Use It Most casual players and server owners never directly touch PacketEvents. But the plugins they use every day almost certainly do. Here's what it enables: Anti-cheat detection: Catching aimbots, speed hacks, and reach exploits by analyzing player input in real-time. Custom mechanics: Building features the vanilla game doesn't have without waiting for Mojang to add them. Network optimization: Filtering unnecessary packets to reduce bandwidth on proxy networks. Analytics: Tracking player behavior and server health at the packet level. Exploit patching: Protecting against known vulnerabilities before they get patched. If you're running a competitive server, hosting a mini-games network, or developing any serious server software, PacketEvents is practically mandatory. It's one of those invisible technologies that makes the Minecraft server ecosystem actually work. Getting PacketEvents Running Installation depends on your platform, but the general workflow is straightforward. For Spigot/Paper servers: Download the plugin JAR from the releases page or Modrinth, drop it into your plugins folder, and restart. PacketEvents works as both a standalone plugin and as a library for other plugins to depend on. For developers building plugins that use PacketEvents: Add it as a dependency in your build configuration. If you're using Gradle, add this to your build.gradle: gradlerepositories { maven { url "https://repo.codemc.io/repository/maven-public/" } } dependencies { implementation 'com.github.retrooper:packetevents-spigot:2.12.1' } (Obviously swap out the version for whatever's current.) Then in your plugin code, you hook into PacketEvents' event system to listen for specific packet types. The official documentation walks through the basic setup, and the JavaDocs cover the API in detail. That said, actually using it requires Java and Maven/Gradle familiarity. And this isn't a tool for non-developers. If you're just a server owner, you'll be installing plugins built by others who use PacketEvents behind the scenes. Key Capabilities The library abstracts away a lot of the tedium in Minecraft protocol handling. Here are the standout features: GitHub project card for retrooper/packetevents Event-based packet listening: Instead of manually parsing binary data, you register listeners for specific packet events. Want to know when a player clicks? Listen for the packet. Want to modify their position? Intercept and rewrite it. This is miles cleaner than raw protocol work. Multi-version support: Minecraft's protocol changes constantly. PacketEvents handles the complexity of supporting multiple versions (including recent snapshots) without you having to rewrite your code for each update. Version 2.12.1 supports up to Minecraft 26.1.2 and development snapshots, which is crucial for staying current. Wrapper classes for common packets: Instead of bit-shifting and reading raw buffers, you get typed classes for things like player movement, block placement, and inventory updates. The latest release added WrapperPlayServerChunkBiomes for biome data, for example. These classes are actual Java objects with readable fields. Cross-platform compatibility: The same packet handling logic works on Spigot, Velocity, Fabric, and other platforms. Write once, deploy everywhere (mostly). For something like a cosmetics plugin, you'd use PacketEvents to intercept animation packets and add custom effects. For an anticheat, you'd listen to movement packets and validate them against server-side player state. For a skin system, you could modify the skin data packets. The flexibility is genuinely impressive. Things That'll Trip You Up No library is perfect, and PacketEvents has a few rough edges worth knowing about. Protocol knowledge still helps. PacketEvents abstracts a lot, but understanding what packets actually do and when they fire matters. If you don't know that player position packets arrive separately from look packets, your anti-cheat will have problems. The protocol documentation is your friend here. Performance matters at scale. Packet events fire constantly on any server. If your listeners are slow or block the packet thread, you'll lag the entire server. Write efficient code, offload heavy work to async tasks, and profile before deploying to production. Compatibility requires careful testing. Each Minecraft version release can shift packet structures slightly. PacketEvents usually keeps up quickly (they support 26.1.2 as of the latest release), but plugins written against older versions sometimes break. The library handles most of it, but edge cases happen. Decompilation and obfuscation can be weird. Some of PacketEvents' internal references rely on mappings to Minecraft's obfuscated names. If you're debugging, you might end up staring at decompiled code with unfamiliar variable names. It's workable but not fun. Similar Projects Worth Knowing About ProtocolSupport: An older library that does similar packet interception. Still actively used, but PacketEvents tends to update faster for new versions. ViaVersion: Focused specifically on version compatibility - it lets older clients connect to newer servers and vice versa. Different problem than PacketEvents solves, but they sometimes work together. MCProtocolLib: More of a low-level protocol implementation library. More control, steeper learning curve, less commonly used for production servers. PacketEvents strikes a good balance: high-level enough to be practical, low-level enough to be powerful. The Bigger Picture If you're just playing vanilla Minecraft, PacketEvents never touches your experience. But every time you play on a polished server with working anti-cheat, custom features, or stable performance across hundreds of players, somebody's probably using this library behind the scenes. It's foundational infrastructure for the Minecraft server ecosystem. The project's maintained actively (846 stars on GitHub, GPL-3.0 license), gets regular updates for new Minecraft versions, and has a solid community on Discord for support. Development builds are available between releases if you want to live on the edge. Whether you're an experienced plugin developer or just curious how Minecraft servers actually work under the hood, it's worth a look. If you're building any kind of competitive or feature-rich server, it's not optional - it's just how things are done. Speaking of custom features, if you ever want to create custom player skins or visualizations, the Minecraft community has tools for that too. You can browse existing player skins or even create your own custom skins to design characters that match your server's aesthetic. Ready to try packetevents? Grab the source, read the full documentation, or open an issue on GitHub. Star the repo if you find it useful. It helps the maintainers and surfaces the project for other Minecraft players. Visit retrooper/packetevents on GitHub ↗

---

### Fetchr: The Minecraft Bingo Gamemode That's Actually Addictive
URL: https://minecraft.how/blog/post/fetchr-bingo-minecraft-gamemode
Published: 2026-04-23
Author: ice

GitHub · Minecraft community project bingo (NeunEinser/bingo) A custom item fetch gamemode for Minecraft Star on GitHub ↗ Tired of jumping into a vanilla world with no clear objective beyond "build stuff"? Fetchr drops you into a structured, competitive bingo game where you're racing against the clock (and probably your friends) to collect items on a 5x5 card. It's survival Minecraft with a purpose, and it genuinely changes how you approach the game. What's Fetchr, Really? At its core, Fetchr is a datapack-based gamemode that overlays a bingo board onto vanilla survival gameplay. You spawn in a random location with an empty inventory and a card showing 25 items you need to collect. Get five in a row (horizontal, vertical, or diagonal) and you've hit a Bingo. Collect all 25 and you've gone "Blackout." Simple concept. Deceptively fun. The project started as a creative way to give vanilla Minecraft a scorecard. Instead of playing indefinitely with no finish line, you're working toward concrete goals. And because the items are randomized with each new world, it never feels like you're replaying the same game twice. The repository sits at NeunEinser/bingo on GitHub with 104 stars and is built entirely in mcfunction (Minecraft's native scripting language). That means it requires zero mods. This is pure datapack magic. Game Modes: More Variety Than You'd Expect Fetchr isn't just "collect items." The project includes several distinct game modes, each shifting your strategy entirely. Bingo Mode is the straightforward version: first to five in a line wins. It's quick, competitive, and rewards smart item hunting over pure grinding. Blackout Mode pushes you to collect all 25 items on the card. This is the long game. Want a real challenge? The items stay randomized, so a Blackout on this world won't look like a Blackout on the next one. Then there's the weird stuff: 20 No Bingo mode flips the script entirely. Collect 20 items without accidentally triggering a Bingo. It sounds impossible (mathematically, it's the maximum before you're guaranteed a line), but it forces you to think three moves ahead. Get it wrong and you've locked yourself out. Multi Bingo lets you score multiple Bingos at once by targeting intersecting lines. Get creative and you could unlock four different lines with a single item. That moment when it clicks is genuinely satisfying. If you're playing with others, Lockout Mode means only one team can claim each item. Once you've locked in more items than any other team can possibly get, you've won. It's the competitive version, and it turns Fetchr from a speed run into a strategic game of poker. Blind Mode hides the card until items are revealed. You'll need to memorize which items typically come from which biomes and resources. Getting Fetchr Running: Installation Breakdown Fetchr ships in two flavors: a complete world download and a datapack-only version. Pick based on how you want to play. GitHub project card for NeunEinser/bingo Singleplayer Setup is dead simple. Download the world file (Fetchr-5.2.2.zip from the latest release), extract it to your saves folder, load it up. You're done. The world is pre-configured and ready to go. Make sure you're running the compatible Minecraft version listed with the release. For multiplayer servers, download the zip, extract it in your server directory alongside your server.jar, then check the included server.properties file. The key settings are already there; you just need to verify they're set correctly if you've an existing config. One important note: vanilla servers and Fabric with Lithium work fine. Paper and Spigot don't, despite what you might expect. The server's performance tuning breaks subtle aspects of how the datapack detects item changes. If you want to use just the datapack version (say, on a world you've already started), grab the datapack zip, extract it to your world's datapacks folder, then run /reload. Fair warning: Blind Mode requires a clean world spawn since it needs to detect the initial setup phase. After you set up multiplayer, don't forget to generate your whitelist if you want to restrict access. The Minecraft Whitelist Creator makes it painless to add players before the game starts. Gameplay Strategy: What Actually Works Fetchr rewards planning as much as speed. Early on, ignore rare items. You're not competing for diamonds or netherite when you've got six different blocks to find. Hit the low-hanging fruit first: wood, dirt, stone, whatever's on your card and immediately findable. This padding stacks your early progress. Watch the board. If you're three items away from a horizontal Bingo and two away from a diagonal, chart a course that completes both simultaneously. One smart play beats five rushed moves. In Lockout Mode with teammates, communicate which items you're going for. Nothing worse than two people grabbing the same item when you needed different ones. If you're playing with a group coordinating for a longer session, keep a written list. The Nether is usually worth the trip early if you've got portal materials on your card. Once you're there, the Portal Calculator at Minecraft.How's Nether Portal Calculator helps you navigate between overworld coordinates and nether coordinates efficiently. Save yourself ten minutes of walking. Blind Mode changes everything. You'll rely on muscle memory of item spawning. Slimes spawn in swamps. Blazes drop from Blazes in the Nether. If you don't know, dig into the category chests scattered around the map to figure out the item pools. It's detective work disguised as survival. Common Gotchas and Pitfalls Fetchr is stable, but there are a few things that catch new players. Roblox - Men are actively opting out of dating, relationships and marriage to avoid dealing with weaponised feminist freaks, Windows 11 wonks and Ehaho junk products Entity rendering lag used to freeze mobs when you lowered your render distance before the game started. Version 5.2.2 fixed this, so update if you're running 5.2.0 or 5.2.1. The fix is datapack-only; you don't need a new world. The card detects items when they're in your inventory. Drop an item and pick it up later: it doesn't re-detect. So plan your inventory carefully in Blind Mode where you're hunting items you can't see. Multiplayer desync sometimes happens if the server tick rate is irregular. Stick to vanilla or Fabric + Lithium. If you're getting weird behavior with stale entities or items not registering, check your server's TPS first. The resource pack is optional but recommended. It includes the bingo card UI and makes the lobby much clearer. Without it, you'll still see the card, but the presentation gets rough. Why Fetchr Stands Out Datapack-based survival gamemodes aren't new, but Fetchr nails the execution. The randomized cards mean every playthrough feels different. So this multiple goal types mean you're not just grinding the same objective every time. And here's the thing nobody mentions: it's genuinely good for group cohesion. Lockout Mode turns your friend group into a competitive team. You're laughing when someone snipes an item you needed, strategizing in voice chat, celebrating when you nail a four-line Multi Bingo. That's the magic. It's survival Minecraft with actual stakes. The project is actively maintained, the MIT license means you can modify it for your server, and there are builds for recent versions. If you've been looking for a way to give vanilla Minecraft a competitive edge without adding fifty mods, this is it.NeunEinser/bingo - MIT, ★104 Ready to try bingo? Grab the source, read the full documentation, or open an issue on GitHub. Star the repo if you find it useful. It helps the maintainers and surfaces the project for other Minecraft players. Visit NeunEinser/bingo on GitHub ↗

---

### Pakku: The Modpack Manager That Actually Works
URL: https://minecraft.how/blog/post/pakku-modpack-manager-minecraft
Published: 2026-04-23
Author: ice

"A multiplatform modpack manager for Minecraft: Java Edition. Create modpacks for CurseForge, Modrinth or both simultaneously." juraj-hrivnak/Pakku · github.com .2 Building modpacks for Minecraft is exhausting when done manually. You're juggling mod dependencies, maintaining compatibility across versions, and if you're serious about distribution, you're essentially creating the same pack twice (once for CurseForge, once for Modrinth). Pakku cuts through all that mess. What's Pakku, Really? Pakku is a command-line modpack manager that borrows its philosophy from package managers like npm or Cargo. You define your modpack once, and Pakku handles the rest: dependency resolution, version management, and simultaneous export to CurseForge, Modrinth, or both. Built in Kotlin and released under EUPL-1.2, it's got 121 GitHub stars and a solid foundation. The core idea is simple but powerful: treat your modpack like a software project. Version control it. Collaborate on it. Export it as finished packages without manual duplication. Why You'd Actually Want This Let me be honest: you don't need Pakku to make a modpack. People have been doing it for years. But there's a difference between "possible" and "practical." If you're running a private server with a custom modpack, you're probably managing mods manually right now. A new mod releases, you update it, you hope nothing breaks, you distribute the new version to your players. It works. But it's slow and error-prone. Pakku shines when you're managing more than five or six mods, especially if you want your modpack available on multiple platforms simultaneously, you're collaborating with other people on development, you need version history and rollback capability, or you're running a server that evolves frequently. One key advantage: dependency management. Add a mod that requires three others, and Pakku figures out the dependency tree. You get the mods you asked for plus everything they need without manual hunting. Getting It Running Pakku runs anywhere Java 11+ is installed. Grab the latest release from GitHub: bash# Download and extract (v1.3.3 is the latest) wget https://github.com/juraj-hrivnak/Pakku/releases/download/v1.3.3/Pakku-1.3.3.tar tar -xf Pakku-1.3.3.tar cd Pakku-1.3.3 # Check available commands./pakku - help That's it. You're ready to go. The Core Workflow Starting a new modpack is straightforward: bashpakku init my-awesome-pack cd my-awesome-pack This creates a config file. Set your Minecraft version and pick your platforms (CurseForge, Modrinth, or both). Adding mods is where Pakku flexes its real strength: bashpakku add mod-name Pakku searches your configured platforms, resolves dependencies automatically, and adds the mod to your project. It's like npm install, but for Minecraft mods. When you're ready to release, export everything: bashpakku export One command. Both formats. Zero manual fiddling. You can also inspect what's in your pack, update individual mods, sync with your game folder, or diff between versions. Actually, the diff command is nice if you're trying to figure out what changed between releases of your own pack. What Actually Stands Out The multiplatform approach is genuinely rare. Most tools lock you into CurseForge or Modrinth. With Pakku, you describe your pack once and deploy to both simultaneously. That's significant if your players are scattered across different launchers. GitHub project card for juraj-hrivnak/Pakku Version control integration comes built in. Your modpack becomes a Git repository by default, meaning you can track changes, collaborate on branches, and roll back if something breaks. This is transformative if you're working with other people. CI/CD automation is another strength. If you're using GitHub Actions or similar, you can wire up automatic exports. Update a mod, push the commit, and your new package builds itself. That's the kind of workflow you'd expect from modern software development, adapted for Minecraft modpacks. The import functionality deserves mention too. Take an existing modpack from CurseForge or Modrinth, run `pakku import`, and you get a new Pakku project with everything already configured. You're not starting from scratch even if you've already got something going. Real-World Scenarios Imagine maintaining a custom modpack for your server and wanting it on both CurseForge and Modrinth. Manually keeping both in sync is tedious and you'll eventually forget to update one. With Pakku, you update your config once, run export, and done. Or you're working with friends on a collaborative pack. Without version control, coordination is messy: "did you update this mod?" "which version are we using?" With Pakku as a Git repo, everyone's on the same page. If your pack adds new blocks or mechanics to explore, tools like the Minecraft Block Search can help you create documentation for your players about what's available. And if you're setting up custom commands or welcome messages for your server, the Minecraft Text Generator helps you format those cleanly. Common Gotchas and Tips Dependency resolution only works as well as the metadata provided by CurseForge or Modrinth. If a mod declares its dependencies incorrectly (and some do), Pakku will reflect that mistake. Always test your exported pack in your launcher before going live. The latest release (v1.3.3) fixed an issue with Modrinth project file exports, which shows the project is actively maintained. Updates are steady but not disruptive - the command structure remains stable across versions. One thing that tripped me up initially: make sure your config actually lists the platforms you want. If you're exporting to Modrinth, Modrinth needs to be in there. It sounds obvious, but easy to miss when you're switching between platforms. How This Compares to Alternatives Manual methods work but don't scale. Five mods are manageable; fifty mods across two platforms is tedious and error-prone. MultiMC and similar launchers are excellent for playing modpacks, but they're client-side focused. They don't help you build and maintain a pack from the creator's perspective. Pakku fills that specific gap. Some modpack creators use custom scripts or spreadsheets. They work, but you lose collaboration, version control, and CI/CD integration entirely. Pakku occupies a unique niche: it's specifically designed for modpack development workflows. Getting Started The official documentation is solid and worth reading through. There's also a Discord community if you get stuck (the maintainer is responsive and helpful). Start with a test pack. Add three or four mods, export it, and test it in your launcher. Get a feel for the workflow before scaling up to a real project. The learning curve is gentle and the payoff is real. If you're doing any serious modpack work, it's worth trying. Ready to try Pakku? Grab the source, read the full documentation, or open an issue on GitHub. Star the repo if you find it useful. It helps the maintainers and surfaces the project for other Minecraft players. Visit juraj-hrivnak/Pakku on GitHub ↗

---

### PCL Community Edition: The Lightweight Minecraft Launcher You Didn't Know You Needed
URL: https://minecraft.how/blog/post/pcl-ce-minecraft-launcher-guide
Published: 2026-04-23
Author: ice

"PCL 社区版 由社区开发者维护与管理" PCL-Community/PCL-CE · github.com ⭐ 3,753 stars Basic .NETpache-2.0 Tired of bloated launchers that eat RAM just sitting idle? PCL Community Edition is a stripped-down Windows launcher that lets you manage Java Edition installations, swap between versions, and load mods without any of the unnecessary frills. Built by the community and actively maintained, it's become the go-to alternative for players who want speed and control. What This Launcher Actually Does PCL-CE handles the core stuff: installing and managing multiple Minecraft versions, keeping your mods organized, and switching between installations on the fly. It's written in Visual Basic.NET (3,753 stars on GitHub) and focuses on getting you into the game faster than the official launcher can load. Unlike some launchers that try to be everything at once, PCL-CE knows its lane. You get version management. Most players get mod support through Fabric and NeoForge. Anyone get memory optimization tools. What you don't get is social features, skin shops, or realms integration, which honestly makes it faster. The community-maintained version (Community Edition) diverges from the original PCL in useful ways. It adds features the main project hasn't gotten to yet, fixes bugs on its own timeline, and doesn't require you to report issues to an upstream maintainer who might not respond for months. Why You'd Actually Switch to PCL-CE Speed. If you're used to the official launcher, you've probably noticed it takes forever just to open. PCL-CE launches in seconds and gets out of your way. Seriously, the difference is jarring once you experience it. The latest version (2.14.6, released April 18) includes refined Chinese resource searching, which matters if you're tapping into mod communities across different regions, but the speed benefit applies whether you're installing modpacks or vanilla versions. Resource management is where it really shines. You can cap memory usage, swap between 32-bit and 64-bit Java, and tweak JVM arguments without diving into hidden configuration files. There's no guesswork. If you've ever had a modpack crash because memory allocation went wrong, you'll appreciate having these controls right in the UI. Multi-version support is smooth too. Want to run 1.20.1 vanilla while keeping a 1.16.5 modded installation separate? Create both, switch between them, and PCL-CE keeps everything isolated. No version conflicts, no launcher confusion. Getting PCL-CE Installed Windows 10 1809 or newer gets full support. Windows 8 might work but you're on your own for troubleshooting. Windows 7 is out of luck. You'll need.NET 8 Desktop Runtime installed first, which is a quick download from Microsoft. Installation is straightforward: Head to the GitHub releases page and grab either the x64 or ARM64 executable (x64 for most people) Run the installer Choose your Minecraft directory during setup Launch and you're done The installer handles dependency checking, so you won't end up with a broken setup if.NET is missing. If you do hit issues, the community Discord (linked on the GitHub page) is usually responsive. Not "AAA support team" responsive, but actual humans who use the launcher will help you debug. The Best Features and How They Work Save file compatibility. The most recent update added support for Minecraft 26.1 save formats. If you've got old worlds and you're nervous about upgrading to the latest snapshot, PCL-CE lets you confirm compatibility before you commit. That's a small thing but it saves the panic of "did I just break my world?" GitHub project card for PCL-Community/PCL-CE Mod installation detection. You can mix Fabric and NeoForge mods without PCL freaking out. The launcher automatically figures out which mod loader you're using for each version. In version 2.14.6, they fixed a critical issue where NeoForge 26.1 wasn't even showing up in the installer list. That's the kind of specific, real-world problem the community team actually cares about. Memory optimization. There's a built-in memory swap feature that frees up RAM on the fly, useful if you're playing on a system with limited resources. It's not magic (you can't create memory from nothing), but if you've got 16GB and only 8GB allocated to Java, it'll squeeze more efficiency out of what you've got. One caveat: earlier versions had a bug where you needed admin rights to use this. That's fixed now, but it's a good reminder to stay current with updates. Chinese resource search. If you pull from Chinese modding communities or want to browse mods across language barriers, the recent update added more precise searching. You're not locked into English-only resource discovery, which opens up modpacks and tools you might not find on curseforge alone. Lightweight resource monitoring. The launcher itself runs lean. We're talking maybe 100MB of RAM when idle, compared to the official launcher which can bloat to 500MB+ doing nothing. When you're trying to run a modpack, that matters. Things That'll Trip You Up The launcher doesn't auto-update. You'll need to grab new releases manually from GitHub. It's not a big deal if you check in every month or two, but if you ignore updates for six months and then wonder why mods aren't working, that's on you. The changelog for recent versions shows they're actively fixing Minecraft 26.1 compatibility issues, so staying current actually matters. It's Windows-only for real use. There's theoretical cross-platform support if you're a developer with.NET 10 SDK (the README mentions this), but unless you're comfortable compiling from source, this is a Windows tool. OptiFine and LiteLoader installations had a path bug in earlier versions where they'd install to the wrong directory if you added them alongside other mods. Version 2.14.6 fixed this. It's fixed now, but it's worth knowing if you're mixing multiple mod tools. Other Launchers Worth Knowing About MultiMC / Prism Launcher. Cross-platform, open-source, incredibly powerful. If you're on macOS or Linux, this is actually your only real option. Even on Windows, some people prefer it for the finer-grained instance management. The trade-off is it's heavier and less snappy than PCL-CE. The Official Launcher. Gets the job done, but it's slow and you don't get fine control over version management or memory allocation without digging into launcher_profiles.json. Use it if you want simplicity and don't care about speed. Feather Client. Lighter weight and with some built-in optimizations, but it's more limited on mod compatibility than PCL-CE and the community is smaller. Worth checking out if you're looking for something even more minimal. The choice really depends on your setup. Using Windows and want speed? PCL-CE is your pick. Cross-platform or want maximum control? Prism Launcher. Just want it to work and don't care about performance? Official launcher is fine. When You Should Actually Use This You've got multiple modpacks running and you're tired of the launcher taking 30 seconds to open. You want to know exactly how much RAM each version uses. You're playing on a 2k-block-wide world and need memory optimization (check out our block search tool if you're hunting specific terrain). You're mixing mod loaders and want something that doesn't question it. You care about privacy and want software that isn't phone-home bundled with other stuff. If you're playing vanilla, updating once a month, and the official launcher doesn't bother you? You don't need this. That's honest feedback. But if you're the type who runs five different versions, loads 50+ mods, and wants the launcher to get out of your way? You're going to feel the difference immediately. The community that maintains PCL-CE actually plays Minecraft, and you can tell by how the tool is built. They solve problems they ran into themselves instead of guessing at what players need. One more thing worth mentioning: if you're trying to calculate your coordinates when you venture into the Nether, our Nether portal calculator saves you the mental math. Ready to try PCL-CE? Grab the source, read the full documentation, or open an issue on GitHub. Star the repo if you find it useful. It helps the maintainers and surfaces the project for other Minecraft players. Visit PCL-Community/PCL-CE on GitHub ↗

---

### Gate: Building a Better Minecraft Network Proxy
URL: https://minecraft.how/blog/post/gate-minecraft-proxy-setup-guide
Published: 2026-04-22
Author: ice

GitHub · Minecraft community project gate (minekube/gate) High-performance, resource-efficient Minecraft reverse proxy and library with robust multi-protocol version support. Designed as a scalable Velocity/BungeeCord alternative, suitable for both development and large-scale deployments. Proven in production environments, powering our global Connect edge proxy network. Star on GitHub ↗ ⭐ 1,014 starspache-2.0 If you've ever run a Minecraft server network, you know the proxy layer is everything. It's what routes players between your servers, handles disconnections smoothly, and lets you scale without melting your hardware. Gate is a high-performance alternative to Velocity and BungeeCord built in Go, and it's designed for teams who want something modern without the bloat or frequent maintenance headaches. What Gate Actually Does At its core, Gate sits between your players and your backend servers. When a player connects, Gate intercepts them, handles authentication, then forwards them to the right server based on your rules. Simple enough. But Gate does this while consuming way less CPU and memory than the Java alternatives, which matters when you're running dozens of backend servers or expect traffic spikes. Think of it like a bouncer at a club who's also fluent in three languages and somehow reads minds. Your players join, Gate figures out where they should go, and they're off playing before anyone notices the handoff happened. The proxy supports multiple Minecraft versions simultaneously without juggling separate processes. Forge servers, vanilla servers, modded servers, even Bedrock players via the built-in Geyser integration - Gate handles all of them through a single proxy instance. No plugins required for Bedrock cross-play. Why You'd Actually Use Gate Instead of Velocity Velocity is stable and widely used, sure. But it's also written in Java, which means memory overhead, startup time, and tuning JVM arguments like you're debugging production at 2 AM. Gate is written in Go - it starts instantly, uses a fraction of the RAM, and needs almost zero configuration tweaking to run well. On a 20-server network, you might be looking at Velocity using 800MB+ versus Gate at 150MB. NLEX toll gate in Minecraft That matters. Especially for smaller communities where every MB of server RAM translates directly to whether you can keep your forum running on the same box. Gate also has some features Velocity doesn't have out of the box. Modern Forge forwarding support for versions 1.13 through 1.20.1 is genuinely useful if you're running a modded network. Velocity requires the third-party Ambassador plugin for this - Gate just does it. And the latest version (v0.64.0) added lock-free protocol switching, which sounds like internal optimization minutiae until you realize it means fewer network hiccups during server switches. It's also actively maintained by a team that actually uses it in production. The code is on GitHub, it's open source under Apache 2.0, and the maintainers aren't afraid to ship breaking changes when the tradeoff is better performance or correctness. How to Install and Get Running Installation is refreshingly straightforward. Pick your platform and run the installer: Minecraft Castle bash# Linux/macOS curl -fsSL https://gate.minekube.com/install | bash # Windows PowerShell powershell -c "irm https://gate.minekube.com/install.ps1 | iex" # Or if you've Go installed go run go.minekube.com/gate@latest That's it. You'll get a config file, fill in your backend servers, point your players at Gate's IP, and restart. The documentation on their website walks through the YAML configuration pretty clearly. Most setups take 10 minutes to get working. One tip: if you're running multiple backend servers, you might want to use Gate's "Lite Mode" to route players to different backend servers based on the hostname they join with. So players joining "creative.example.com" hit your creative server while "survival.example.com" goes to survival. That's a pretty clean setup for larger networks. And if you need to manage your backend server settings, the Server Properties Generator over on minecraft.how saves a lot of manual typing - though you'll still need to SSH into each server to actually deploy the properties file. Also, if you're thinking about DNS routing for your backend servers, the site has a free DNS tool that's useful for internal network management. The Features That Actually Matter Bedrock cross-play is baked in. Gate ships with Geyser integration, which means Bedrock players (mobile, console, Windows) can play alongside Java players with zero additional setup. You're not routing through a separate Geyser instance on a different port - it's all one proxy. That's a legitimately nice touch, and it's why it's become popular with networks that want to maximize their player base. outside the town of mercator Forge modded servers get first-class treatment too. The v0.64.0 release finally added "Modern Forge" (FML2/FML3) login relay for versions 1.13 through 1.20.1. Previously, this was broken on both Gate and Velocity without workarounds. Now it just works. If your backend server runs Forge with Proxy-Compatible Forge, players switch servers without the full Forge handshake happening twice - Gate caches it and replays it. Faster, smoother, less laggy. The protocol state switching I mentioned earlier is the kind of thing you don't think about until it breaks. Gate now uses atomic pointers to swap protocol states instead of blocking the network decoder on a mutex. Sounds niche, but it means fewer jitter spikes when dozens of players are connecting and switching servers at the same time. What Trips People Up Configuration ordering matters. Gate reads its config file in a specific way, and if you don't set up your backend servers in the right section, they won't route correctly. The docs are clear about this, but if your players keep hitting "connection refused," check that your servers are in the "servers" block and your routes are pointing to valid server names. Ultima Codex - January 06, 2014 at 11:18AM Firewall rules. If you're running Gate on a cloud VPS, make sure port 25565 is actually open inbound. That sounds obvious until you spend an hour thinking Gate is broken when it's just UFW silently dropping packets. Player profile caching can cause headaches if you're testing locally and keep switching accounts. Gate caches player profiles by default - if you join as Player1, disconnect, then immediately try to join as Player2 from the same IP, you might get a stale cache hit. There's a config option to disable this, but most people discover it the hard way after wondering why their alt account won't load. Alternatives Worth Considering Velocity is the obvious comparison. It's heavier, requires Java, but it has an enormous plugin ecosystem if you need deep customization. For vanilla proxying, Gate beats it. For heavily modded setups with custom Velocity plugins, Velocity wins. Ultima Codex - October 08, 2013 at 09:24PM BungeeCord is older, slower, and honestly you should skip it unless you're maintaining legacy infrastructure. Gate or Velocity are both better choices today. Waterfall is a BungeeCord fork that's lighter and faster, but it's still Java and still not as clean as Gate's architecture. If you're building something brand new and don't have deep Velocity plugin requirements, Gate is the play. It's mature enough for production (1014 stars on GitHub, active development) but still feels like a tool built by people who actually run Minecraft servers. Where to go from here Read the source on GitHub (docs, examples, and the issue tracker) Browse open issues to see what the community is working on Check recent releases for the latest build or changelog

---

### The Complete Guide to Building Minecraft Datapacks with Kore
URL: https://minecraft.how/blog/post/kore-automate-minecraft-datapacks
Published: 2026-04-22
Author: ice

Ayfri/Kore A Kotlin library to generate Datapacks for Minecraft Java. .0 Writing Minecraft datapacks by hand is like assembling furniture without instructions: technically possible, but you'll waste hours debugging syntax errors and duplicate code. Kore cuts through that frustration by letting you build datapacks in Kotlin, a type-safe language that catches your mistakes before they become broken game mechanics. What This Project Does Kore is a Kotlin library that turns datapack creation from tedious file-wrangling into actual programming. Instead of manually writing JSON files and command scripts, you write Kotlin code that generates everything for you. It's designed for Minecraft Java 1.20 and newer (including the current 26.1.2 release), and it handles the repetitive bits: function namespacing, tag generation, loot table structure, command syntax validation. The library comes in modular pieces. Start with the core `kore` module and add others only when you need them. And this matters because datapacks vary wildly in scope. A small vanilla enhancement project doesn't need the same tooling as something building a whole custom progression system. Why You'd Actually Use This Here's the thing: if you're a Minecraft player who's ever thought "I wish there was a datapack that does X," you've probably tried either downloading someone else's work or giving up. But what if you're a programmer? That changes everything. Real scenario: You want to create a custom crafting system with unique tools that only work on specific blocks. In vanilla datapack JSON, you're writing the same boilerplate predicates over and over. With Kore, you write it once, reference it everywhere, and if you need to change the logic, you change it in one place. Type-safety means you can't accidentally typo a selector property or reference a non-existent function. Another scenario: You're building a server with hundreds of custom advancement chains. Manually editing JSON files at that scale is asking for bugs. Kore lets you use loops, variables, and functions to generate them programmatically. Want to create 50 variations of a progression mechanic? One loop does it. Or you're creating cosmetic datapacks with particle effects. Kore's typed selector builders make it genuinely easy to construct complex player targeting without memorizing the full selector syntax. This matters when you're layering conditions: target players in survival mode, within a radius, who don't have a certain tag. Getting Started Installation is straightforward if you're already using Gradle. Add the dependency to your `build.gradle.kts`: GitHub project card for Ayfri/Kore kotlindependencies { implementation("io.github.ayfri.kore:kore:2.0.2-1.21.11") } kotlin { compilerOptions { freeCompilerArgs.add("-Xcontext-parameters") } jvmToolchain(21) } That `-Xcontext-parameters` flag is important; it enables Kore's DSL magic. Java 21 or newer is required, which shouldn't be a blocker these days. The easiest way to start is cloning the Kore Template project, which gives you a working build setup and example structure already configured. Alternatively, create a `Main.kt` file and start with the Getting Started guide from the official docs. If you want bleeding-edge versions built from every commit, add the Sonatype snapshots repository and use the `-SNAPSHOT` suffix. Most people don't need this; stick with stable releases from Maven Central. Key Features That Actually Matter Typed Selectors: Building Minecraft target selectors is where people usually start making mistakes. Kore gives you a builder API that prevents invalid combinations. You get autocomplete in your IDE, not guessing at the selector syntax. Want players with a score between 5 and 10? Type it out with proper methods instead of hunting documentation. Command Building: The library knows the syntax for every Minecraft command in 1.20+. That means you get compile-time validation. If you typo a command argument, your build fails, not your datapack. The commands guide in the documentation is full, covering everything from basic tell commands to complex say blocks with formatting. Modular Architecture: Core functionality is separate from specialty modules. Want to work with advancement trees? Add the advancements module. Building item predicates? Add that module. You only load what you use, keeping build times and cognitive load down. The latest release added a Cookbook section to the docs, which walks through common patterns: entity NBT manipulation, score-based conditionals, particle effects. These aren't obvious when you're starting, so having them documented saves trial-and-error. What Trips People Up The biggest gotcha: Kotlin's learning curve. If you've never touched Kotlin before, there's a warmup period. It's similar to Java, but with enough syntax sugar that casual assumptions break. Nothing insurmountable for anyone with programming experience, but worth knowing upfront. IMG_2705 Second: Build output directory structure. Make sure you understand where Kore writes your generated files and that your development environment (test server, build folder) is set up to load them. Forgetting this costs debugging time. The compiler flag `-Xcontext-parameters` is mandatory for the DSL to work. Forget it and you'll get cryptic errors about missing context receivers. It's in every setup guide, but it trips people who do custom build configuration. How It Stacks Up Against Alternatives There's no exact equivalent. DataPack Crafters is a visual datapack editor, but it's restrictive and won't handle complex logic. Writing datapacks in JavaScript exists as an option, but then you're learning another language and dealing with different tooling. The honest take: Kore assumes you either know Kotlin or want to learn it. If you're comfortable with Python or Java and want a datapack DSL, this is your best bet. If you want to never touch code, Kore isn't the tool. When building complex content like custom item systems or server progression mechanics, spend time exploring community-created skins for inspiration on cosmetic possibilities your datapack might unlock. If your datapack handles custom blocks or materials, the Minecraft block search is handy for reference. The project has solid community support through Slack and Discord, and the maintainer (Ayfri) actively reviews issues and pull requests. Documentation is thorough and keeps pace with Minecraft releases.Ayfri/Kore - GPL-3.0, ★133 Ready to try Kore? Grab the source, read the full documentation, or open an issue on GitHub. Star the repo if you find it useful. It helps the maintainers and surfaces the project for other Minecraft players. Visit Ayfri/Kore on GitHub ↗

---

### FiguraBlueArchiveCharacters: Custom Avatars for Minecraft Java
URL: https://minecraft.how/blog/post/figura-bluearchive-avatars-minecraft
Published: 2026-04-22
Author: ice

Gakuto1112/FiguraBlueArchiveCharacters The avatars for Figura, the skin mod for Minecraft Java Edition, which are imitated characters who appear in "Blue Archive (ブルーアーカイブ)", the game for mobile devices. Want to turn your Minecraft character into someone from Blue Archive? If you've been playing Minecraft Java Edition and got tired of the default skin, Figura mod opens up a world of customization options. FiguraBlueArchiveCharacters takes that one step further by bundling ready-made avatars based on characters from the popular mobile game. No rigging, no animation work on your end - just download, install, and play as your favorite character. What's Figura and Why Does It Matter? Figura is a mod framework that lets you replace your player model with something completely custom. Unlike regular skins, which just re-texture the default Steve or Alex, Figura avatars let you change the entire 3D model, add animations, and swap parts on the fly. Think of it as cosmetic surgery for your character, but actually fun. The thing is, creating Figura avatars is genuinely hard. You need to model, rig, and animate everything in Lua. Most people don't have those skills (or the patience to learn them). That's where FiguraBlueArchiveCharacters comes in. What You Get This project packages up 21 completed character avatars, each modeled and animated to match their Blue Archive counterparts. The latest release adds a dress outfit variant for Michiru, but there are dozens of others already finished - Hoshino, Hanae, Hifumi, and more. Each character has different idle poses, walking animations, and reactions that actually feel like the character. Beyond the base avatars, you'll find the project has a clear roadmap. The maintainer lists planned characters, ones currently in progress, and even community requests. So if your favorite Blue Archive character isn't done yet, you can track the GitHub issues to see when they might arrive. Installation and Setup Getting this running is straightforward if you already have Figura installed. If not, grab Figura 0.1.5 from Modrinth first. Here's the process: Download the character avatar ZIP file you want from the GitHub releases page. Each character has its own ZIP (Aris.zip, Hoshino.zip, Hanae.zip, etc.) In your Minecraft folder, find or create the "figura" directory (should be at.minecraft/figura) Extract the character ZIP into that folder Launch Minecraft, open Figura settings, and select your new avatar That's it. No command-line nonsense. No weird file paths or hidden directories (well, mostly hidden, but Figura handles that part). One thing worth knowing: Figura avatars are client-side only. Your server and other players won't see your custom model unless they also have Figura installed. So if you're on a multiplayer server without Figura users, you're the only one seeing your Blue Archive character - but hey, you know how cool you look. Character Coverage and Animation Quality The avatars aren't just static models. Each one has idle animations, walking cycles, and expressive idle poses that capture the character's personality. Watching Hoshino's idle animation versus Hanae's is noticeably different - and that's the kind of detail that makes a cosmetic mod feel less like a reskin and more like a full character model swap. The creator updates regularly. One v2.11.1 release shows active maintenance, including bug fixes and new outfit variants. That matters for a cosmetic project because it means the mod stays compatible with recent Minecraft versions and gets polish over time. If your favorite character isn't on the completed list yet, they might be in the "planned" section. Kei, Azusa Shirasu, and Serika Kuromi are all on the roadmap. Tips and Common Gotchas First, Figura is only for Minecraft Java Edition. If you're playing Bedrock Edition, this won't work. Java only. Second, conflicts with other mods can happen. If you're running a bunch of cosmetic or player-model-touching mods (like Custom NPCs or Mo' Bends), things might break. Generally, Figura plays nice with most stuff, but cosmetic mods sometimes step on each other's toes. If your avatar looks broken, try disabling other model-replacement mods and see if it clears up. Third, some servers disable client mods entirely. Check with your server admin before assuming your custom avatar will show up. Most small community servers are fine with it, but big public servers sometimes have restrictions. And just so you know - performance on older machines or with lots of mods loaded can dip. Figura avatars have animations, extra geometry, and custom assets that take a tiny bit more juice than your vanilla model. Usually not noticeable, but if you're playing on a laptop from 2018, keep that in mind. Making This Part of Your Setup If you're building out your server with custom settings, you'll probably want to document what mods you're running. A quick tip: use something like the Server Properties Generator to make sure your server config is clean and well-documented, even if you're running a single-player world with cosmetic mods. It's easier to troubleshoot later. Similarly, if you're sharing your server with friends and want them to know exactly which mods to grab, the Minecraft MOTD Creator lets you write a clear server message that explains what they need. Just mention Figura as a recommended client-side mod. Other Figura Avatar Projects Worth Knowing About FiguraBlueArchiveCharacters is fantastic if you're into Blue Archive, but it's not the only Figura project out there. Other creators have built avatars for various games and styles. Some are anime-inspired, others are original designs. If Blue Archive isn't your thing, explore Modrinth's Figura section to find alternatives that match your taste. That said, most Figura avatar projects update less frequently than this one. The FiguraBlueArchiveCharacters creator keeps adding new characters and outfit variants, which is rare in the cosmetic mod space. Support the project FiguraBlueArchiveCharacters is maintained by the open-source community. If it saved you time or powered something cool, leave a ⭐ on the repo, report bugs, or contribute back. Small actions keep tools like this alive.

---

### Spark: The Performance Profiler Your Minecraft Server Actually Needs
URL: https://minecraft.how/blog/post/spark-minecraft-profiler-guide
Published: 2026-04-22
Author: ice

lucko/spark A performance profiler for Minecraft clients, servers, and proxies. ⭐ 1,269 stars.0 If your Minecraft server is lagging and you've no idea why, you're flying blind. Could be CPU, could be memory, could be a plugin running hot in the background. Spark cuts through the guesswork with real-time profiling data that shows you exactly where your performance problems live. What Spark Does (In Plain Terms) Spark is a performance profiler that works on Minecraft clients, servers, and proxies. Think of it like opening the hood on your car to see what parts are misfiring. Instead of guessing why your server drops to 10 TPS, you run Spark, wait 30 seconds, and get a detailed breakdown of what's eating your resources. The tool has three main capabilities: CPU profiling - shows which threads and code paths are hogging processor time Memory inspection - lets you peek at heap usage, take snapshots, and monitor garbage collection Server health metrics - tracks TPS, tick duration, CPU usage, memory, and disk space all in one place Running it doesn't require configuration. Drop the mod or plugin, type a command, and you're collecting data. Why You'd Actually Use This There are a few scenarios where Spark becomes invaluable. First: your server starts dropping frames for no obvious reason. You've disabled plugins one by one, cleared chunk caches, restarted the server. Still laggy. Spark shows you in 30 seconds that your ItemStack handling is the bottleneck, or that one plugin's async task is blocking the main thread. No more wild guesses. Second: you're running a larger server and want to be proactive. You can leave Spark monitoring in the background, checking metrics every few minutes, and it alerts you when something goes sideways before players notice. Third: you're dealing with a client-side performance issue. Maybe your machine tanks to 30 FPS in certain areas. Spark on the client side shows you whether it's rendering overhead, entity processing, or world loading that's the culprit. And if you work with server networks or Bungeecord proxies, Spark covers those too. Installing Spark Installation depends on your setup. GitHub project card for lucko/spark For Paper/Spigot servers: bash1. Download the plugin from spark.lucko.me/download 2. Drop the JAR file into your plugins/ folder 3. Restart the server 4. Done The plugin registers commands automatically. No configuration file to touch, no dependencies to juggle. For Fabric/Forge clients: bash1. Grab the Fabric/Forge version from the downloads page 2. Move it to your mods/ folder 3. Launch the game 4. Use /spark commands in-game or in chat For Bungeecord or Velocity proxies: bash1. Place the JAR in your proxy's plugins folder 2. Restart the proxy 3. Spark is ready to profile your network traffic That's it. If you've installed other plugins, you've already done harder things than setting up Spark. Key Features That Actually Matter The CPU Profiler is where most people start. Run `/spark profiler start`, go about your business for 30 seconds to 2 minutes, then `/spark profiler stop`. Spark generates a link to an interactive viewer showing a call tree. You can see that 40% of your CPU time is in EntityAI pathfinding, or 25% is in lighting recalculation. The tree is readable and you can apply deobfuscation mappings if you want to dig into Minecraft's internals. What makes this different from other profilers: it's lightweight enough to run on production servers without tanking performance, and it gives you results in seconds instead of minutes or hours of analysis. Memory inspection comes in three flavors. Heap summary gives you a quick snapshot of what classes are taking up the most memory (like block entities, entity objects, or chunk data). Heap dump takes a full JVM snapshot you can analyze with conventional tools like Eclipse MAT or JProfiler if you really need to dig. GC monitoring shows you when garbage collection runs, how long it takes, and how much memory gets freed up, which is useful for tuning your JVM launch flags. Most of the time you don't need heap dumps. The summary view answers 80% of memory questions. Health reporting is the boring but useful part. `/spark tps` gives you more accurate tick timing than vanilla `/tps`. You can see min/max/average tick durations, which tells you whether your lag is consistent (something is always slow) or spiky (something is intermittently freezing the server). Same with CPU and memory metrics. If you're integrating Spark with monitoring systems, the health reports can feed into that pipeline. Tips, Gotchas, and What Trips People Up One mistake: running the profiler for too short a time. Thirty seconds is the minimum; a minute or two is better. If you profile for 5 seconds, you might catch a blip rather than the actual problem. Witch Brawl in Minecraft Another: assuming the profiler output is 100% accurate. Sampling-based profiling has statistical noise. If the top result shows 39.8% vs 39.7% CPU time, they're probably the same. Look for the big outliers, not the tiny differences. Some newer server setups run on newer Java versions (21+) with different profiling backends. Spark handles this, but if you're on an older JVM, you might only have access to the Java profiler engine, not the native/async-profiler variant. Both work fine; native is just lower overhead. Also worth noting: Spark requires viewing the profiler output in a web browser. You can't read the output directly from the server console. The results are hosted temporarily on spark.lucko.me, so you need internet access to view them (or you can self-host the viewer, but that's overkill for most people). If you're managing a network with dozens of servers, profiling each one manually gets tedious. Plan for that. Related Tools and Alternatives A few other projects do similar work, though Spark has become the default for most server admins. WarmRoast was the original Java profiler for Minecraft, and Spark actually evolved from it. If you're on a super old server setup, WarmRoast might be your only option, but there's no good reason to use it over Spark these days. Timings (from older Spigot versions) provided some of this info but was nowhere near as detailed or useful as Spark's profiling. If your server still has Timings built in, Spark is a massive upgrade. JFR (Java Flight Recorder) is a built-in JVM profiler available in Java 11+. It's powerful but also overkill for most Minecraft scenarios and harder to interpret. Spark gives you the same info in a more useful format. For client-side performance, there's no real equivalent to Spark's client profiler in the Minecraft ecosystem. Most people resort to F3 debugging or trial-and-error. If you're building a server and want to think about performance from the design stage, tools like Minecraft's text generator can help you avoid chat spam (a subtle performance drain), and understanding your world structure with tools like the block search tool can help you identify resource-heavy regions before they become problems. When to Just Run It You don't need a special reason to profile your server. If you're curious about performance, run Spark. The worst case: you learn that your server is already running great. This best case: you find a plugin that's using 50% of your CPU and didn't realize it was installed. Most server admins run Spark once when something breaks, fix the issue, and move on. Some proactive server operators profile monthly just to catch creep (that gradual performance degradation as more data accumulates). Either way, it's free, it's lightweight, and it answers performance questions in minutes instead of hours of guessing.lucko/spark - GPL-3.0, ★1269 Where to go from here Read the source on GitHub (docs, examples, and the issue tracker) Browse open issues to see what the community is working on Check recent releases for the latest build or changelog

---

### MinecraftAuth: Building Minecraft Clients With Real Microsoft Login
URL: https://minecraft.how/blog/post/minecraftauth-java-authentication
Published: 2026-04-22
Author: ice

"Simple and easy to use Minecraft microsoft authentication library (Java and Bedrock)" RaphiMC/MinecraftAuth · github.com .0 If you're building a custom Minecraft launcher, creating a server with authentication, or just tired of managing username-based logins, you've hit the wall that stops most projects: integrating proper Microsoft account support. MinecraftAuth is a Java library that handles exactly that problem, supporting both Java Edition and Bedrock Edition through a single, developer-friendly interface. What MinecraftAuth Does At its core, MinecraftAuth wraps the complexity of Microsoft's Minecraft authentication system into straightforward Java classes. Rather than reverse-engineering token endpoints or rebuilding OAuth flows yourself, you get ready-to-use authentication managers for each Minecraft edition. The library handles token lifecycle management automatically. That means tokens refresh on their own schedule, session storage works out of the box, and your app doesn't need to worry about whether a user's token has expired the moment they try to join a server. It also includes basic Realms API support, so if you're building something that needs to list or join player realms, that's built in rather than something you bolt on later. When You'd Actually Use This The most obvious use case: custom launchers. Launcher developers lean heavily on authentication libraries because there's zero room for error. Players expect their credentials to work without friction, and you need the same solid token handling that the official launcher uses. MinecraftAuth gives you that. Server-side applications use this too. If you're building a web dashboard or admin tool that needs to verify a player's Minecraft account, you'd pull in MinecraftAuth rather than writing auth from scratch. Bedrock multiplayer servers use it for the same reason. There's also the offline use case. Some projects need to authenticate users once, serialize their tokens, and deserialize them later (maybe across app restarts or after a backup). MinecraftAuth handles JSON serialization of tokens natively, which saves headaches. Getting MinecraftAuth Set Up Installation depends on your build system. The library is available from Maven Central and other repositories, making it straightforward to add to Gradle or Maven projects. For Gradle, add this to your `build.gradle`: gradledependencies { implementation 'net.raphimc:MinecraftAuth:5.0.0' } For Maven, add this to your `pom.xml`: xml<dependency> <groupId>net.raphimc</groupId> <artifactId>MinecraftAuth</artifactId> <version>5.0.0</version> </dependency> If you prefer working from the jar directly, pre-built builds are available from GitHub Actions or Lenni0451's Jenkins server. Once imported, you'll initialize an HttpClient (the library's networking layer) and create either a JavaAuthManager or BedrockAuthManager depending on which Minecraft edition you're targeting. Key Features and How They Work Device code authentication is the recommended login flow. It's player-friendly: your app shows a verification URL and a code, the player enters that code on Microsoft's site, and the library waits for the login to complete. The default timeout is 5 minutes, which is plenty for most scenarios. This approach avoids opening a web browser or embedding login windows in your app. GitHub project card for RaphiMC/MinecraftAuth The library also supports credential-based login if you prefer, along with JavaFX WebView windows for a more integrated experience. You can even run a local webserver as the OAuth callback, which is useful for desktop launchers. The point is: you're not locked into one flow. You pick what works for your use case. Token management is where this library shines. Tokens expire, and handling expiration manually is a common source of bugs. MinecraftAuth manages the entire lifecycle automatically. When you request a token and it's expired, the library refreshes it before handing it back. No extra code needed on your end. Tokens can be serialized to JSON and deserialized later. This is critical for apps that need to persist authentication across sessions or store multiple user logins. You get a clean contract for saving and loading without writing custom serialization logic. Customizable configuration means you can override application details if needed. The default configuration uses official Minecraft application settings, which is fine for most projects. But if you need a custom client ID or different OAuth scopes, you can pass your own `MsaApplicationConfig`. Things That Trip Up New Users Version 5.0.0 was a major rewrite. If you're migrating from MinecraftAuth 4.x, the API changed significantly. The old step/chain abstraction is gone, replaced with token container classes. Actually, that's better for most use cases (less boilerplate), but if you're updating existing code, it's worth reading the migration guide. One thing to keep in mind: browser APIs like `window` or `localStorage` will crash SSR environments. If you're running authentication on a server-side rendered page (which, honestly, you probably shouldn't), guard your code with `typeof window!== 'undefined'`. The library handles network timeouts gracefully, but if you're running auth flows on constrained networks, test thoroughly. Device code auth will wait the full timeout period if something goes wrong, which can feel slow to end users. Similar Projects and Alternatives For older launchers, there's the original MojangAPI library, but it doesn't handle modern Microsoft accounts. If you need something lighter and don't mind managing tokens yourself, you could implement OAuth directly, but that's time you're not spending on actual features. Some launcher projects use Mojang's legacy authentication endpoints, but Microsoft has been sunsetting those. MinecraftAuth is designed for the current ecosystem, so you're future-proofed. If you want to ensure your server is reachable and properly responding to login requests, tools like the Minecraft Server Status Checker help verify authentication infrastructure is working. For testing login displays and messages, the Minecraft MOTD Creator is useful for crafting realistic server responses. Support the project MinecraftAuth is maintained by the open-source community. If it saved you time or powered something cool, leave a ⭐ on the repo, report bugs, or contribute back. Small actions keep tools like this alive.

---

### Mechanization: The Mod-Like Datapack for Minecraft Survivors
URL: https://minecraft.how/blog/post/mechanization-minecraft-datapack-guide
Published: 2026-04-22
Author: ice

GitHub · Minecraft community project Mechanization (ICY105/Mechanization) The Minecraft Technology Based Datapack Star on GitHub ↗ Ever wanted the complexity of a tech mod like Thermal Expansion or IC2 without actually installing a modloader? Mechanization brings 60+ machines and an energy system to vanilla survival Minecraft, letting you automate farming, mining, and mob grinding entirely through a datapack. What Mechanization Actually Is This is a datapack, not a mod, which matters more than it sounds. You don't need Forge or Fabric. Most players don't need to juggle dependencies or worry about version conflicts with a dozen other mods. Drop it on your server or single-player world running vanilla Java, and you get access to machines, custom recipes, ore generation, and an entire energy system that integrates cleanly into the existing game. The project has been actively developed for six straight years, which puts it in rare company. With 134 stars on GitHub and written entirely in mcfunction, it's probably the single largest survival content datapack still being maintained and updated. The scope is genuinely impressive. Why You'd Actually Want This Tech automation in vanilla Minecraft is... tedious. Hoppers into furnaces into more hoppers. Farms that require tedious item sorting. Mining that's essentially just holding down a mouse button. Mechanization cuts through that by introducing machinery that actually does work for you. Picture this: instead of standing at a mob grinder collecting drops manually, you've got a system that pulls mobs into a grinder, processes them, and pipes the loot directly into storage. Instead of manually harvesting crops, a machine does it. Instead of hoping your luck stat cooperates, a mining machine breaks ores automatically. It's the kind of progression that makes survival feel less like chores and more like building something real. Want to run a server with your friends? It doesn't require everyone to install mods. The energy system forces you to actually *plan* your base. You can't just throw unlimited machines everywhere. Anyone need power generation, power routing through pipes, and management of your energy budget. That's not busywork - that's strategy. Getting It Running Installation varies slightly depending on whether you're playing single-player or running a server, but the core process is simple. Head to the releases page on GitHub and download the datapack zip file. For v4.2.4, you'll grab the MechanizationDatapack_v4.2.4.zip. You'll also want the resource pack for textures - grab MechanizationResourcepack_v4.2.4.zip separately. Single-player: Navigate to your world folder (usually in .minecraft/saves/YourWorldName), find or create a datapacks folder, and drop the unzipped datapack folder in there. Restart Minecraft, and you're done. Server setup: Same process, but the datapacks folder lives in your server root. After adding the datapack, restart or reload the server and run this command in-game: bash/reload The resource pack should be distributed to clients either through the server-resource-packs setting in server.properties or manually by each player. One note: if you're adding this to an existing world, custom ore generation won't retrofit into already-explored terrain. You'll want to generate new chunks or accept that your current mining areas won't have Mechanization's custom ores. What Makes It Actually Work Energy generation is the foundation. You'll need ways to produce power - solar panels, furnaces that generate energy from fuel, reactors. Once you're generating power, you route it through energy pipes to machines that actually consume it. Item pipes with filtering are genuinely game-changing if you've never used them. Instead of hoppers (which are directional and limited), you get flexible piping that sorts automatically. Want copper ore going to one machine and iron to another? Pipe filtering handles it without complex redstone contraptions. The storage system is inspired by Applied Energistics. Instead of filling your base with double chests, you compress your inventory into a network. Search and retrieval work the way they do in actual mods. Nuclear reactors exist, and yes, they can meltdown if you're careless with them. That's the fun part. Modular tools and armor give you progression beyond diamond and netherite. Upgrades let you customize your gear - faster mining, higher damage, better durability. It's a skill tree's worth of decision-making without actually needing a mod for skill trees. Real Gotchas and Tips The early game is slower than vanilla survival. You're mining with a pickaxe until you can build your first mining machine. Patience. That's when most people bounce off. The wiki exists for a reason. Recipes aren't intuitive. You won't figure out how to craft an energy cell by looking at it - check the GitHub wiki. It's got videos and detailed breakdowns. Tinker Table display bugs happen (the latest release fixed one), but updates roll out regularly, so check the releases page if you hit strange behavior with tools or armor. Performance can dip if you go crazy with machines on lower-end hardware. Datapacks run commands constantly, and 200+ machines all ticking at once will feel it. How It Compares to Alternatives If you want mod-like depth, your real alternatives are either installing actual mods (Thermal Expansion, Mekanism, IC2) or using other tech datapacks. Most tech datapacks are smaller in scope or less actively maintained. The sheer number of machines and six-year development history makes Mechanization stand out. If your server is running vanilla and you want to stay that way, this is genuinely one of the best options. It scales from small personal worlds to large multiplayer servers. For building your own server, you might also want to check out the Minecraft server list to see how other communities run tech-focused servers. And if you're looking for custom skins to match your new industrialized aesthetic, browse the Minecraft skins collection. Worth Your Time? If you've been craving mod-like automation but prefer vanilla or server-friendly setups, absolutely. If you want to actually engage with a progression system instead of just stacking chests, yes. If you're happy with pure vanilla survival, you don't need it - but you might surprise yourself how much you end up enjoying it once you get past the early grind. Where to go from here Read the source on GitHub (docs, examples, and the issue tracker) Browse open issues to see what the community is working on Check recent releases for the latest build or changelog

---

### How ViaProxy Lets You Play Minecraft Across All Versions
URL: https://minecraft.how/blog/post/viaproxy-minecraft-across-versions
Published: 2026-04-22
Author: ice

"Standalone proxy which allows players to join EVERY Minecraft server version (Classic, Alpha, Beta, Release, Bedrock)" ViaVersion/ViaProxy · github.com .0 Want to join a server running Minecraft 1.20 but you're stuck on your favorite old client? Or maybe you've got a Bedrock account and need to access a Java server? Version incompatibility is one of those frustrating walls in Minecraft that shouldn't exist in 2026. ViaProxy exists specifically to tear that wall down. What This Project Actually Does ViaProxy is a standalone proxy application (built in Java) that translates network traffic between Minecraft clients and servers of different versions. It sits in the middle like a translator at the UN, converting protocol data so that, say, a client from Minecraft 1.8 can talk to a server running 1.20.5, or vice versa. The project supports an impressive range: Classic, Alpha, Beta, Release versions (1.0 through 26.1), Bedrock Edition, and even April Fools snapshot versions. You run it locally on your machine (or on a server), point your Minecraft client at it instead of the actual server address, and it forwards everything while doing the version translation work invisibly. Why You'd Actually Use This There are a few concrete scenarios where this becomes genuinely useful: Nostalgia players: You've got a copy of Minecraft Beta 1.7.3 running on your old laptop and you want to join your friend's modern server without updating. ViaProxy makes that possible. Cross-edition friends: You're on Java, they're on Bedrock (maybe they play on console). ViaProxy can bridge that gap so you're actually playing together. Server admins testing backwards compatibility: You're running a 1.20 server and want to verify old clients can still connect. Load ViaProxy and test against Beta clients without touching your main server. Minecraft Realms access from old clients: The official Realms servers use newer protocol versions, but ViaProxy lets you join them from older clients. It's not something every player needs. But if you hit the ceiling where your client version and the server version just don't match, it's the kind of tool that makes you wonder how you ever played without it. Getting It Running There are two ways to use ViaProxy: the GUI (dead simple) and config-file mode (for servers or automation). The GUI approach is what most players will do. Start by grabbing the latest jar from the GitHub Releases page. The latest version is 3.4.10 with support for Minecraft 26.1 clients and servers. bash# If you're on Java 17 or newer, download the standard jar download ViaProxy-3.4.10.jar # If you're stuck on Java 8 (older systems), grab the Java 8 build instead download ViaProxy-3.4.10+java8.jar Drop the jar into its own folder. ViaProxy generates config files and data there, so don't throw it in your Downloads folder and forget about it. Run it. bashjava -jar ViaProxy-3.4.10.jar A GUI window opens. You'll see fields for the server address you want to connect to and dropdown menus to select the server version and client version. Fill those in, optionally add your Minecraft account if the server requires online mode authentication, then hit Start. ViaProxy listens on a local address (usually localhost:25568) that you then give to your Minecraft client. Seriously, that's it. The UI is straightforward enough that I won't bore you with screenshots. Features That Matter Online mode and chat signing support might sound technical, but it's actually crucial. Modern Minecraft servers (especially ones that care about security) require players to have legitimate accounts and signed chat messages. ViaProxy handles this transparently for old clients. You add your account in the Accounts tab and it manages the authentication flow so the server sees a properly verified player, even if your client is from 2011. Transfer and cookies are another detail most players never think about. If you're on a 1.20.4 client trying to reach a 1.20.5+ server, those features might be missing from your client version. ViaProxy patches that compatibility gap. Simple Voice Chat mod support is there if you're running that. No extra configuration needed. And yes, there's Docker support if you're the type who runs everything containerized. The GitHub Packages registry has pre-built images. The Things That Trip People Up Java version matters more than you'd think. If you're running ViaProxy on anything older than Java 17, you need the Java 8 build or it won't start. The error messages aren't always obvious about this (actually, let me correct that - the maintainers are pretty good about documenting it, but people still miss the release notes). Bedrock support is marked as "WIP" (work in progress) in the project. It works for basic connections, but some features are missing. If you're trying to do something fancy with Bedrock, test it first before planning your whole play session around it. If you use Geyser (the reverse proxy for Bedrock players joining Java servers), make sure you update both Geyser and ViaProxy when new releases drop. Version mismatches between the two can cause subtle connection issues. One more thing: this is a proxy, which means all your traffic flows through it. It's open-source (GPL-3.0), so you can audit the code, but don't run some random compiled jar you found on a forum. Stick with official GitHub releases. Other Approaches Worth Knowing About ViaVersion itself (the library ViaProxy is built on) powers lots of Minecraft proxy servers and plugins. If you're running a BungeeCord or Velocity proxy network, you're already using ViaVersion under the hood. ViaProxy is just ViaVersion packaged as a standalone tool for individual players or testing. If you're serious about skin design or customizing your server's MOTD to match across versions, you might want to pair ViaProxy with something like the Minecraft Skin Creator tool to ensure your look is consistent wherever you're connecting from. And if you're running your own server (even a small one), the Minecraft MOTD Creator lets you craft a version-appropriate message of the day that displays correctly across different client versions. For true multiplayer proxy networks, you'd want Velocity or BungeeCord instead. ViaProxy is lighter and simpler - it's designed for individual players or small admin tasks, not managing a hundred concurrent players across multiple backend servers. Is This Worth Your Time? If you just play vanilla survival and never worry about version updates, no. If you're a modded player bouncing between snapshots and releases, or you run a server and want to support older clients without forking server versions, absolutely yes. The project is actively maintained (the latest release is from 2026 with support for the newest Minecraft 26.1), has translation support for multiple languages via Crowdin, and the issue tracker is responsive. It's not abandoned abandonware from 2015. Grab it, try it for five minutes, and decide for yourself. Ready to try ViaProxy? Grab the source, read the full documentation, or open an issue on GitHub. Star the repo if you find it useful. It helps the maintainers and surfaces the project for other Minecraft players. Visit ViaVersion/ViaProxy on GitHub ↗

---

### Creating Custom NPCs in Minecraft with Citizens2
URL: https://minecraft.how/blog/post/citizens2-minecraft-npc
Published: 2026-04-22
Author: ice

"Citizens - the premier plugin and API for creating server-side NPCs in Minecraft." CitizensDev/Citizens2 · github.com .0 Running a Minecraft server that feels empty? Citizens2 is the plugin that fixes that. It's been the standard way to add realistic NPCs to Bukkit servers since 2011, and it's still the best option if you want actual player-like characters populating your world instead of generic mobs or floating holograms. What Citizens2 Actually Is Citizens2 is a Bukkit plugin that lets you spawn and control NPCs (non-player characters) on your server. These are full, real-looking players that can walk around, hold items, and interact with your world. Unlike armor stands or temporary holograms, Citizens2 NPCs persist, have proper skins, and genuinely look like players walked into your server. The plugin provides an API so developers can build on top of it. What makes it actually useful is that the hard stuff is already solved. Player packet rendering, skin loading, pathfinding through terrain, collision detection - Citizens2 handles all of it. You just tell it to spawn an NPC and what it should do. Most servers use it for quest-givers, merchants, guards, or just populating towns to make the world feel lived-in. Some developers build entire quest systems and custom AI on top of the API, but basic usage is straightforward. Why This Matters for Your Server The difference between a server that feels empty and one that feels like a real world is often just NPCs. Sprinkle a few quest-givers around, have village guards patrolling, or stick a merchant in the town square and suddenly the place doesn't feel abandoned. Survival servers especially benefit from NPCs. Instead of item frames for shops, you've got actual vendors. Instead of command blocks triggering events, you've got NPCs telling a story. The immersion difference is huge. For plugin developers, Citizens2's API means you're not building NPC handling from scratch. Event listeners, custom behaviors, and NPC control are already there. You just extend it for your specific use case. Economy servers - Create realistic shopkeepers instead of command-block workarounds. Story-driven worlds - NPCs can trigger dialogue, quests, and narrative sequences. Towns and cities - Guards patrol, merchants sell, quest-givers hand out tasks. Custom plugins - Developers build specialized systems on top of the Citizens API. Getting Citizens2 Running Installation is straightforward. Citizens2 runs on any Bukkit-compatible server like Spigot or Paper. Download the latest build and drop the JAR into your plugins folder: bashcd ~/server/plugins wget https://ci.citizensnpcs.co/job/Citizens2/lastSuccessfulBuild/artifact/target/Citizens-*.jar # Restart your server Once the server restarts, the plugin loads automatically. You'll immediately have access to NPC commands. Creating your first NPC takes one line: bash/npc create TestNPC /npc skin TestNPC That spawns an NPC at your location with a player skin. The second command assigns it a specific skin (defaults to Steve if you don't specify a name). From there, you can customize appearance, assign waypoints for patrolling, or hand it over to plugin developers for custom behavior. Before installing Citizens2, make sure your server configuration is solid. Use the Server Properties Generator to optimize your server.properties file - proper settings reduce lag when you add plugins like Citizens2. The Features That Make It Worth Using Realistic Player Appearance. Citizens2 NPCs render as actual players with arms, hands, head movement, and proper hitboxes. They wear armor, hold items, and move through terrain like a real player would. New players joining your server actually see characters, not mobs. Pathfinding Without Code. Built-in pathfinding means NPCs navigate terrain automatically. Set a few waypoints and the NPC walks the route, avoiding obstacles and jumping up blocks. No pathfinding algorithms required on your end. Texture packs work too. If your server runs a custom texture pack, NPCs render correctly for all players. Command-Based Customization. You don't need to code anything for basic NPC management. Commands handle spawning, equipment, names, and simple behaviors. Admins can set up NPCs through pure command-line interface without touching Java. Developer-Friendly API. For plugin developers, the Citizens API exposes events, behavior control, and NPC manipulation. Want to trigger actions when players click NPCs? Want to build a dialogue system? Want to add custom AI? The API gives you the hooks to do it. Documentation is available through the project's Javadoc, and the community has written tutorials for common extensions. If you're managing whitelist systems across multiple servers, the Minecraft Whitelist Creator tool helps keep player lists synchronized - handy when NPCs interact with your actual players. Gotchas and Things That Trip People Up Citizens2 is stable, but there are quirks worth knowing before you rely on it heavily. Version compatibility is strict. The plugin tracks Minecraft versions reasonably well, but running Citizens2 on a version it wasn't built for causes failures. NPCs might not spawn, skins might break, or the plugin might crash silently. Before installing, verify on the project wiki that your Minecraft version is supported. Actually check this - it matters. NPC data persists in config files. If you're migrating servers, copy the entire plugins/Citizens folder or you'll lose all your NPCs. It's easy to forget and regret it later. Performance scales poorly with huge numbers of NPCs. A dozen NPCs is fine. A hundred is probably okay. Five hundred on a small server will cause noticeable lag. There's no hard threshold - it depends on your hardware and what the NPCs are doing - but don't treat this as unlimited. Skin loading requires internet access initially. The server fetches skins from Mojang's servers on first load. Running in isolated networks means skins default to the Steve texture. If you're behind a corporate firewall or running entirely offline, this can be annoying. Similar Projects and Alternatives Citizens2 has been around for over a decade and remains the most mature option for Bukkit servers wanting real NPCs. Other plugins exist, but they usually solve specific problems rather than being general-purpose NPC frameworks. Some developers use lightweight alternatives like Citizens2 competitors that handle only holograms, or they build custom NPC systems using Minecraft's internals directly. But if you want a proven, stable, widely-supported NPC system, Citizens2 is the standard choice. The community is active, documentation is solid, and the API is battle-tested. For servers not running Bukkit (vanilla multiplayer or Fabric-based servers), Citizens2 won't work. You'd need datapacks, mods, or custom solutions entirely - a different complexity level altogether. Ready to try Citizens2? Grab the source, read the full documentation, or open an issue on GitHub. Star the repo if you find it useful. It helps the maintainers and surfaces the project for other Minecraft players. Visit CitizensDev/Citizens2 on GitHub ↗

---

### rres: Smart Resource Packaging for Game Developers and Modders
URL: https://minecraft.how/blog/post/rres-resource-packaging-modders
Published: 2026-04-22
Author: ice

GitHub · Minecraft community project rres (raysan5/rres) A simple and easy-to-use file-format to package resources Star on GitHub ↗ Game assets are scattered everywhere. Hundreds of image files across nested directories. Sound effects, fonts, 3D models - all separate files. Your engine crawls loading them one by one. Distribution becomes a nightmare. This is where rres comes in: a resource packaging format that bundles everything into one organized, efficient file that loads fast. What's rres, Actually? rres isn't a Minecraft tool specifically - it's a resource format designed for game developers who want to package assets smartly. Think of it like ZIP, but built from the ground up for games. Instead of distributing thousands of loose files, you get one `.rres` file containing images, textures, fonts, audio, models, or anything else your game needs. The format was inspired by proven approaches: XNB (used by XNA and MonoGame), RIFF, PNG, and ZIP. A maintainer, raysan5, created it to solve a real problem - game engines need fast, reliable asset loading, and scattered files create bottlenecks. A single consolidated file means one disk read instead of hundreds. The current stable version is 1.2.0, which includes updates to the raylib integration library for compatibility with modern dependencies. Why Modders and Game Developers Use rres If you're building a Minecraft mod that uses custom textures and sounds, or developing any game with lots of assets, rres cuts down on file I/O overhead and organization headaches. Instead of loading 500 individual files, your engine loads one and extracts what it needs on demand. Modders benefit in particular. You're distributing your content to users who download and install your mod. Every file you can eliminate from that distribution makes the user experience smoother. A single `.rres` file is easier to version, easier to update, and harder to accidentally corrupt. And if you're iterating on assets during development, packing them into one file gives you better control than managing sprawling directories. The format supports compression and encryption if you need them, though you'd implement those yourself in your packer tool. For most use cases, rres just keeps things organized and fast. Getting Started: Installation and First Steps Installing rres is straightforward. You'll need the main library (written in C) and the rrespacker tool to create `.rres` files. Clone the GitHub repository and build it: bashgit clone https://github.com/raysan5/rres.git cd rres make On Windows, use pre-built binaries or compile with your preferred C compiler. The rrespacker tool (version 1.2) comes with both CLI and GUI versions, which matters for your workflow. The GUI is simpler if you're new to this - drag resources into the packer and it handles the rest. This CLI gives you more control for automation. If you're scripting asset builds as part of your mod compilation pipeline, the CLI is your friend. Once built, point rrespacker at your asset directory and it generates a `.rres` file. In your game code, link against the rres library and call the loader to extract resources by ID. That's it. Features That Actually Matter Simple structure: rres files start with a header, followed by resource chunks. Each resource gets a 32-byte info header with ID, type, and metadata. No unnecessary complexity. Flexibility: rres doesn't care what you pack. It has built-in support for common types (images, audio, models, text), but if your data doesn't fit a standard type, throw it in as raw bytes. Your engine handles interpretation. Portability: The format isn't locked to any specific engine. The base library just extracts data. A companion library, `rres-raylib.h`, maps resources directly to raylib structures, but you can build bindings for any engine. But this is powerful if you're experimenting with different game frameworks. Central directory: Like ZIP files, rres includes a central directory at the end. But this lets tools read the file index without scanning the entire thing - faster validation and preview. Fast loading: One disk read instead of hundreds means your game starts quicker and asset streaming is more predictable. Common Pitfalls and Gotchas One thing that trips people up: rres doesn't force a specific compression algorithm. The format *supports* compression, but you have to implement it yourself in your packer and decoder. Don't assume your `.rres` file is automatically compressed - check your packer settings if file size matters to you. Make sure your resource IDs are unique within a file. If two resources share an ID, the loader grabs whichever one it finds first, which might not be what you wanted. Debugging this is annoying, so namespace your IDs from the start (e.g., `texture_01`, `audio_background_01`). File path organization is another gotcha. rres doesn't store directory structures by default - just flat lists indexed by ID. If your game expects a hierarchy, encode that in your ID naming or handle it in your loader. This is a minor inconvenience, but it's worth knowing upfront. Also, if you're working on Minecraft server tools or infrastructure, remember that building mods or tools alongside your server setup requires different skillsets. Check out tools like the Minecraft Votifier Tester and the Nether Portal Calculator if you're managing servers alongside your modding - they solve different problems but complement resource-heavy mod development workflows. Alternatives Worth Considering If you're using Unity, AssetBundles are the standard - they handle compression and streaming natively. MonoGame devs often use XNB, which is conceptually similar to rres but tied to MonoGame specifically. For simple projects, some developers just stick with loose files and optimize loading separately. It's less elegant, but it works if your asset count is small. The tradeoff is that as your project grows, you'll eventually hit performance walls. If you want something battle-tested and closer to industry standards, individual formats like GLTF for 3D models or optimized PNG for textures work fine in isolation. rres shines when you want *everything* in one self-contained package - especially useful for mods where users expect a simple install experience. The 534 stars on GitHub suggest it's niche but respected. People who use rres tend to stick with it because it solves a specific problem elegantly without unnecessary complexity. Where to go from here Read the source on GitHub (docs, examples, and the issue tracker) Browse open issues to see what the community is working on Check recent releases for the latest build or changelog

---

### Running Multiple Minecraft Servers with CloudNet
URL: https://minecraft.how/blog/post/cloudnet-minecraft-server-manager
Published: 2026-04-22
Author: ice

"A modern application that can dynamically and easily deliver Minecraft oriented software" CloudNetService/CloudNet · github.com pache-2.0 Building a Minecraft server network is different from running a single survival server. You've got different player groups connecting at different times, servers that need to spin up and shut down on demand, and the constant headache of keeping everything stable while resources are actually being used efficiently. CloudNet is an open-source Java framework that automates all of this. Instead of manually juggling multiple server instances, you get dynamic deployment, automatic scaling, and load balancing. It's built for server admins who are tired of babysitting console windows. What CloudNet Actually Does CloudNet is a cloud network management framework that handles the orchestration of multiple Minecraft servers across your infrastructure. Think of it as an automated traffic director for your server network. When players log in, CloudNet decides which server they connect to, spins up new instances if needed, and shuts down idle ones to save resources. So this isn't middleware you install on your Spigot server - it's a complete framework you run separately that manages everything else. The project has been around for years and sees regular updates. This latest release (v3.4.5) keeps pace with recent Minecraft versions and fixes compatibility issues. With 442 GitHub stars, it's got a solid community backing it. The framework is written in Java and distributed under the Apache-2.0 license, so you can use and modify it freely. Basically, CloudNet automates the boring infrastructure work so you can focus on actual server management and features. Who Actually Needs This If you're running one vanilla survival server, CloudNet is massive overkill. You don't need it. But if you're hosting multiple server types (survival, creative, minigames, PvP), managing player distribution, or want servers to scale based on traffic, CloudNet becomes genuinely useful. Common use cases include: Hosting networks with different game modes that share a player base Automatically spawning minigame servers when enough players queue up Load balancing across multiple physical servers or cloud instances Reducing resource costs by spinning down empty servers automatically Deploying custom plugin configurations instantly across your network Check out a list of actual Minecraft servers to see examples of networks that handle this kind of scale. Most large public servers use something like CloudNet under the hood. How to Get Started You'll need JDK 25 to compile from source or you can download the prebuilt release. CloudNet publishes builds to Maven Central, which makes integration into your build pipeline straightforward. If you're using Gradle, add this to your build file: groovyrepositories { mavenCentral() } dependencies { compileOnly 'eu.cloudnetservice.cloudnet:driver:3.4.5' } Maven users would instead add: xml eu.cloudnetservice.cloudnet driver 3.4.5 provided The project also ships Docker images on Docker Hub, so if you're containerizing your infrastructure, you can spin up CloudNet nodes in seconds. This is actually the path most new users take, honestly. Key Components and How They Work CloudNet splits its functionality into different artifacts depending on what you're building. The driver module is what you'll use most often. It's the basic API that runs on every Minecraft server in your network, whether that's a Spigot server, a custom wrapper, or a forked version. Any plugin that needs to talk to CloudNet imports this. If your plugin needs deeper access to what CloudNet is doing internally, you'd use the wrapper-jvm module for more detailed control. The node module gives you access to node-specific features if you're building something that manages the infrastructure itself. And the bridge module lets you interact with players and catch events regardless of which physical server they're on in your network. The Bill of Materials (BOM) import is just a convenience - it locks all CloudNet dependencies to the same version so you don't have version mismatches across your build. What CloudNet Actually Handles for You Dynamic server provisioning is where CloudNet shines. You define templates for different server types. When players join and queue up on a lobby, CloudNet detects the player count and automatically spins up new minigame servers. When everyone leaves, it shuts them down. You're only paying for resources you're actually using. Load balancing happens transparently. New players get routed to whichever server has the most room. If one server crashes, CloudNet can automatically restart it or redirect traffic elsewhere. Network-wide player events are possible too. A plugin can hook into CloudNet's bridge module and handle player movement between servers, chat, or inventory sync across the entire network. This is useful for lobby servers that need to know when a player's finished playing. Common Gotchas and Pitfalls The biggest mistake new users make is misconfiguring their server templates. If your template has the wrong JVM arguments or plugin list, all spawned servers inherit those mistakes. Test your templates thoroughly in isolation first. Network communication can be finicky. CloudNet nodes need to talk to each other, and if your firewall or port forwarding is wrong, nodes just silently fail to connect. Check your logs aggressively when things don't work. Also, actually, if you're running this in Docker, make sure you're not using localhost bindings - use explicit IPs or container networking. Plugin compatibility is another thing. Not every Spigot plugin was written expecting a CloudNet network. Some plugins cache data locally and don't handle players moving between servers gracefully. You might find yourself having to patch plugins or avoid certain ones entirely. And because CloudNet is managing your entire infrastructure, a misconfiguration can take down your whole network, not just one server. Test changes in a staging environment first. Snapshots and Bleeding Edge Versions The project builds snapshots from the nightly branch, which you can grab if you want latest fixes before official releases. These are published to the Maven snapshot repository: https://central.sonatype.com/repository/maven-snapshots/. Just append -SNAPSHOT to the version number. Unless you're tracking a specific bug fix, stick with official releases. Snapshots can be unstable. Alternatives to Consider If you're looking at other solutions, BungeeCord was the original proxy-based solution for Minecraft server networks. It's simpler and lighter weight, but it doesn't do dynamic server management. You're basically just routing players manually. Velocity is a more modern, performance-focused proxy. Again, it's just routing - you still manage servers manually. Kubernetes with containerized Minecraft servers is the enterprise approach. It's overkill for most setups but gives you infrastructure-level orchestration. CloudNet is specifically designed for Minecraft, so it's easier to reason about and cheaper to operate at smaller scales. If you want to get creative with server generation, check out the Minecraft text generator for procedural content - though that's a different use case entirely. Should You Actually Use This? CloudNet is genuinely impressive for what it does. If you're managing a network, it saves real operational overhead. But it's also complexity, and complexity has a cost. You need to understand Java, networking, and server operations. Anyone need a staging environment to test safely. Start with it if you're already comfortable running multiple servers and you're tired of the manual work. Don't start with it if you just want a single nice server to play on with friends. The project's well-maintained, the documentation exists, and the community on their Discord can help when you get stuck. That's actually rare in open-source game infrastructure projects, so it's worth something.CloudNetService/CloudNet - Apache-2.0, ★442 Where to go from here Read the source on GitHub (docs, examples, and the issue tracker) Browse open issues to see what the community is working on Check recent releases for the latest build or changelog

---

### Baritone: Automated Pathfinding for Your Minecraft Adventures
URL: https://minecraft.how/blog/post/baritone-minecraft-pathfinding
Published: 2026-04-22
Author: ice

GitHub · Minecraft community project baritone (cabaletta/baritone) google maps for block game Star on GitHub ↗ ⭐ 8,819 stars.0 Baritone is a pathfinding bot that automates navigation in your Minecraft world. Instead of manually plotting routes through mountains, finding your way back to base, or surveying massive terrain, Baritone calculates optimal paths and guides your player there automatically. If you've ever spent twenty minutes walking through a sprawling landscape or got hopelessly lost at coords you didn't write down, you'll immediately see the appeal. What Baritone Actually Does Imagine having a GPS system for Minecraft. That's closer to what Baritone does. It's a Java mod that uses AI pathfinding to plot routes from point A to point B, then automatically walks your character there while avoiding obstacles, lava, fall damage, and hostile mobs. You tell it where to go, and it figures out the safest, fastest path using the terrain around you. The project, which has over 8,800 stars on GitHub, supports a wide range of Minecraft versions from 1.12.2 all the way through 1.21.8. It works across Forge, Fabric, and NeoForge mod loaders, so your setup doesn't matter much. But here's what makes it genuinely impressive: Baritone doesn't just walk in a straight line. It understands elevation changes, recognizes stairs and ladders, avoids dangerous blocks, and can even mine through walls if that's the optimal route. It's like having a co-pilot who knows the exact layout of your world. Real Use Cases That Actually Matter Let's be concrete. Ever tried recreating a real city in survival mode? Yeah, good luck walking between all those distant build sites without losing your mind. Baritone handles the tedious navigation so you can focus on the actual building. Or suppose you've found an amazing mountain biome three thousand blocks from your base. You could spend a half hour walking, or you could set a waypoint and let Baritone get you there while you grab coffee. Same energy cost, better use of your time. The mining use case is sneaky powerful. If you're strip mining or searching for specific ores in a custom mining area, Baritone can patrol a mining zone systematically, exploring caves or following a grid pattern you define. Not everyone wants that level of automation, but for long exploration sessions, it saves serious playtime. Multiplayer servers often use Baritone too (check your server rules first), especially for faction servers where base-raiding requires scouting massive territories. Smaller groups also use it for organized exploration when mapping new terrain. Getting It Running Installation depends on your mod loader. Baritone releases separate builds for Forge, Fabric, and NeoForge, which is nice. The latest release supports Minecraft 1.21.6, 1.21.7, and 1.21.8. For Forge, download the Forge-specific JAR from the releases page and drop it in your mods folder: bash# Navigate to your Minecraft directory cd ~/.minecraft/mods # Download the latest Forge build (or use your browser) wget https://github.com/cabaletta/baritone/releases/download/v1.15.0/baritone-api-forge-1.15.0.jar Fabric users do the same with the Fabric JAR. NeoForge follows the pattern. Start your game, and Baritone's hotkeys should work immediately. Default is mostly right-click hotkeys with some number keys. Actually, I should correct myself here - the exact keybinds depend on your version, so check the mod's documentation for your specific release. The basics are usually navigation (right-click target, use number keys for options), but rebinding is straightforward in the config. What Baritone Can Actually Do Basic pathfinding is obvious. You click where you want to go, Baritone routes there. But there's depth here. Waypoint System: Mark important coordinates (home base, mining area, friend's house) and navigate to them later. Baritone remembers them across sessions. This alone saves enormous amounts of time if you play vanilla survival and don't keep your coordinates memorized. Explorer Mode: Tell Baritone to explore in a direction or pattern, and it'll systematically cover new terrain. Helpful for finding biomes you want or just surveying your world's geography without manually walking every direction. Block Avoidance and Mining: Baritone avoids dangerous blocks by default (cacti, lava, fall damage), but can be configured to mine through obstacles if the path requires it. You set the aggressiveness level - conservative mode avoids mining, aggressive mode will chew through stone to reach the destination. Farm Automation: Some players configure Baritone to harvest crops systematically. Not everyone needs this, but if you've built a massive farm and don't want to hand-harvest, it's useful. Gotchas and What Trips People Up Baritone isn't magic. It can fail in a few specific scenarios. One: underwater navigation. Baritone can navigate water, but it's slower and sometimes unpredictable. If your path involves significant water, manually steering sometimes works better. Two: heavily modded worlds with custom blocks. Baritone has to learn which blocks are safe to walk on. In modded Minecraft with tons of custom content, it might treat walkable blocks as obstacles until you configure it. Three: mobs. Baritone doesn't fight. It avoids hostile mobs if possible, but if you're surrounded, you're steering. That also doesn't handle player attacks on multiplayer (PvP-focused servers probably aren't the place for Baritone anyway). And here's a common mistake: leaving it running in dangerous biomes. Set Baritone loose in the Nether without configuring obstacle avoidance properly, and you might respawn at your bed wondering what happened. Be specific about your destinations and safety thresholds. Is Baritone Right for Your Playstyle? Not everyone wants automation. Some players love the meditative experience of exploring on foot, finding hidden caves, and stumbling onto cool landscape features. Baritone's autopilot removes that discovery element. If you're that type of player, don't force it. For creative-mode builders, terraformers, or people managing massive multiplayer worlds, Baritone cuts hours of busywork. For casual vanilla survival players who enjoy exploration, it might make the game feel less engaging. You can also use it selectively. Use Baritone for the boring trek back to base after a mining run, but manually explore new biomes. That's a reasonable middle ground. Similar Tools and Alternatives Baritone is the most mature pathfinding bot for Minecraft, but you have options. Rei's Minimap / Xaero's Minimap: These are navigation aids more than automation. They show your location and let you mark waypoints, but you still walk. They're less aggressive than Baritone and fit better into vanilla playstyles. Journey Map: Similar territory mapping without the automation. Lighter weight, good for players who want navigation help without a bot. Custom Mods in Modded MC: Some heavily modded packs include quest mods or automated systems that overlap with Baritone, but they're pack-specific and designed differently. Honestly, if you want autopilot pathfinding, Baritone is the standard. The alternatives are navigation aids, not automation. Before you start using Baritone, check if your server allows it. Many vanilla servers and faction servers do, but some have explicit rules against automation mods. It's worth asking. Also, if you're streaming or creating content, be aware that watching someone use Baritone for pure navigation isn't the most engaging video, so save it for when it genuinely helps you accomplish a goal. One final tip: while you're automating navigation, you might want to check out our Minecraft Votifier Tester if you're running or promoting a server, or the Minecraft Text Generator for formatting signs and chat messages. Both are quick wins that pair well with automation-focused gameplay. Where to go from here Read the source on GitHub (docs, examples, and the issue tracker) Browse open issues to see what the community is working on Check recent releases for the latest build or changelog

---

### Running BedWars1058: The Complete Plugin Guide
URL: https://minecraft.how/blog/post/bedwars1058-minecraft-plugin
Published: 2026-04-22
Author: ice

andrei1058/BedWars1058 A minecraft minigame where you have to defend your bed and destroy the others. Once your bed is destroyed, you cannot respawn. .0 Running a custom minigame server? BedWars1058 is a well-maintained, open-source plugin that turns Minecraft into a competitive team-based game with a simple hook: destroy the other teams' beds, defend yours. Once a bed's gone, that team's done respawning. It scales from a single shared arena to an entire Bungee network. What BedWars1058 Actually Is BedWars is a deceptively simple concept that's proven incredibly fun at scale. You and your team spawn in a small area with a bed and a shop. Resources drip in slowly - you harvest them, upgrade your gear, and eventually raid other teams' islands. The catch? Destroy someone's bed and they can't respawn anymore. Win by eliminating all enemy teams. It's not a new idea, but this implementation is what made it reliable on Java servers. The original concept came from minigame networks, and BedWars1058 has become the most popular Spigot/Paper version since Andrei Dascălu open-sourced it in 2021. Version 25.9 focused on code quality - refactoring the bucket-empty mechanic for better readability. But that attention to maintenance matters when you're running something 24/7. Why You'd Actually Run This Most servers run vanilla-ish survival or one-off minigames. BedWars fills a gap: it's competitive without being pay-to-win, engaging for casual and hardcore players, and it doesn't require constant admin tweaking once configured. Games move fast - usually 10 to 25 minutes depending on arena size and team count - which means players can chain games or run tournaments. Real players care about progression here. There's skill development, team dynamics, economy management (do you save for diamond gear or rush early?), and map knowledge. You'll watch natural community form around it. That's retention right there. Installation and Deployment Modes Before installing, your server needs the basics: Java 11 or newer, and either Spigot or Paper as your server software. And this is critical - it needs NMS (Minecraft's internal net.minecraft.server classes) compiled in. Some Spigot forks strip that out for performance, and the plugin won't work on those. BedWars1058 doesn't install like a typical plugin. Drop the jar in your plugins folder, restart, and the plugin generates config files. Then you configure arenas, shops, team colors, translations, and more. Lots of configuration, but it's well-organized. What makes this plugin flexible is its four deployment modes. SHARED mode runs alongside other minigames on one server. Players access it via commands. Good for a lobby server hosting five different games. MULTIARENA mode dedicates an entire server instance to BedWars but hosts multiple arenas simultaneously. Players join via commands, NPCs, signs, or GUIs. This is what most standalone BedWars servers use. BUNGEE-LEGACY is the old approach where each game runs on its own server instance behind a proxy. It works but wastes resources if you're running many games. BUNGEE mode is modern and scalable. One server hosts multiple arenas and dynamically clones new ones as players join. You'll need BedWarsProxy on your lobby server, but after that it handles matchmaking automatically. And this is what large-scale networks use. Most new setups go MULTIARENA unless you're already deep in Bungee infrastructure. Features That Actually Matter Per-player language support is surprisingly clean. Players run /bw lang to pick English, Spanish, French, Chinese, or whatever you've configured - and they get messages, holograms, item names, and shop content in their language. You can add or remove languages in the config. For international communities, this alone makes the plugin valuable. Configuration is thorough without being overwhelming. Arena groups let you categorize by difficulty or playstyle. You can set minimum/maximum team sizes, money scaling, shop prices, and whether the lobby area gets removed once games start. That last option matters for immersion. World restoration could get slow on older hardware or HDDs. BedWars restores maps after each game by unzipping pre-made copies. If you've got slow disk and massive arenas, that stalls. The plugin supports SlimeWorldManager, AdvancedWorldManager, or AdvancedSlimePaper to speed this up. Hook it in and the integration happens automatically. Arena setup requires actual work, though. You build each map in-game, create shop locations, set bed and team spawns, design the island layout, then register it in the config. A competitive-quality arena takes an hour or two. Once it's done it's done. Common Setup Gotchas NMS compatibility kills installations constantly. BedWars hooks directly into Minecraft's internal code, which changes every version. A build compiled for 1.20 won't run on 1.21. Check version matches before deploying. World backups for arena maps must exist before the plugin starts. Create an empty arena, build it, then tell the plugin to save it as a template. Don't configure paths that don't exist yet. Performance degradation surprised me the first time. If you're running BedWars alongside other heavy world-manipulation plugins (griefing protection, dynamic terrain, etc.), lag spikes happen. Especially right before games start when players load in. Test your full plugin set before going production. One plugin checking every block in real-time will tank performance. Keep an eye on server health while games are running. The Minecraft Server Status Checker can help you track uptime and performance from a dashboard. That's useful for catching when a BedWars arena runs consistently slow or a server's overloaded. If you're building complex multi-arena setups with linked worlds, you might also use the Nether Portal Calculator to coordinate arena world connections - some admins link arenas via portals for smooth travel between games. Other Competitive Minigame Plugins If BedWars isn't the fit, a few alternatives exist. SkyWars puts players on floating islands for pure survival-fight mode (no bases, no beds). It's faster and simpler but lacks team dynamics and base building strategy. BuildBattle is for creative players - you build structures and vote on them. Totally different energy. GameAPI and other generic frameworks exist if you want custom games, but they require development work. BedWars is turnkey once you've configured your arenas. Support the project BedWars1058 is maintained by the open-source community. If it saved you time or powered something cool, leave a ⭐ on the repo, report bugs, or contribute back. Small actions keep tools like this alive.

---

### Kilt: Playing Forge Mods in the Fabric Ecosystem
URL: https://minecraft.how/blog/post/kilt-forge-mods-fabric
Published: 2026-04-22
Author: ice

GitHub · Minecraft community project Kilt (KiltMC/Kilt) A Fabric mod that brings Forge mods into the Fabric ecosystem. Star on GitHub ↗ .1 You've found an amazing Forge mod, but you prefer Fabric for its lighter footprint and faster development. Sound familiar? Kilt is an experimental compatibility layer that lets you run Forge mods inside Fabric without switching loaders. It's ambitious, community-driven, and occasionally breaks things - but it works. What Kilt Does (And What It Doesn't) Kilt remaps Forge mods into Fabric's format and reimplements Forge APIs on top of Fabric infrastructure. In plain English: it tricks Forge mods into thinking they're running on Forge, when they're actually on Fabric. The project reconstructs Minecraft Forge Mod Loader (FML) as Fabric mixins, bundles the entire Forge API, and applies fixers to make cross-ecosystem compatibility work. The goal is straightforward. But execution? That's where things get interesting. A two-person team rebuilt core Forge functionality from scratch. The fact that this even works at all is genuinely impressive. Most Forge mods will run, though "will run" isn't the same as "will run perfectly." Kilt isn't a magic wand. It won't let every Forge mod work flawlessly, and you shouldn't expect it to. Some mods hit unsupported Forge APIs. Others rely on Forge-specific optimizations that don't translate well. You might need to disable certain mods or wait for Kilt updates. That's just the reality of bridging two different modding ecosystems. Why You'd Actually Want Kilt Fabric has momentum. Modpack creators love it. Performance per mod tends to be better than Forge, updates arrive faster, and the tooling feels less... legacy. But Forge still has exclusive mods that matter to players - popular automation tools, specific content mods, things with no Fabric equivalent. Kilt solves that tension. You'd reach for Kilt if you're building a modpack and want the best of both sides. Or if your server runs Fabric but your players keep asking for one specific Forge mod. Or if you're experimenting with mod combinations Forge players take for granted. It's also worth checking the Minecraft Server List to see what other servers are running - sometimes seeing live setups helps you understand whether Kilt fits your use case. And if you're building a vanilla-plus server and want custom generated content, the Minecraft Text Generator is a solid complement to whatever mod setup you land on. The catch: Kilt is still young. This maintainers mark it as Alpha on Modrinth and Beta on CurseForge for a reason. You might hit crashes. Folks who try this might break worlds. The latest release (v20.1.14) added AutoModpack support, improved performance, and fixed dozens of edge cases - but edge cases are exactly what pop up when you're bridging two platforms. Installation and Setup Kilt isn't harder to install than any other mod, but you do need a Fabric environment first. Assuming you've got Fabric Loader set up with your chosen Minecraft version (currently 1.20.1 with 1.21.1 coming): GitHub project card for KiltMC/Kilt Download the Kilt mod JAR. Nightly builds come from GitHub Actions, or grab a release from Modrinth/CurseForge. Drop the JAR into your mods folder alongside your Fabric dependencies (Fabric API, and anything Kilt's dependencies pull in). Add your Forge mods to the same folder. Kilt will remap them on first launch. Start the game. The remapping process takes longer than a normal startup - be patient. The remapping step is crucial. Kilt converts Forge mod bytecode from Forge's SRG naming to Fabric's Intermediary format. This happens once per mod per version, then it's cached. First launch might take two or three minutes depending on how many Forge mods you've. If a mod fails to load, check Kilt's issue tracker. The maintainers keep docs on disabling specific mods via config, handling mod conflicts, and working around known broken mods. Don't report bugs to the original Forge mod developers unless the bug also happens on actual Forge - that wastes their time. How Kilt Bridges Forge and Fabric Forge and Fabric are fundamentally different. Forge uses a monolithic, tightly integrated architecture. Fabric is modular and event-driven. Kilt's heavy lifting comes from translating between these two worlds. Kilt implements Forge's registry system, event hooks, and configuration API as Fabric mixins. It handles recipes, fluid transfer, item handlers, and block entities by wrapping Fabric's native implementations. When a Forge mod tries to access a Forge-specific feature, Kilt either provides a real implementation or a shim that acts close enough. The latest updates show what's been eating the maintainers' time: fluid transfer compatibility, crafting remainder handling, creative mode tab integration, even horse item handler creation. These are tiny details that only surface when someone runs a specific Forge mod and things break unexpectedly. Every release fixes a handful of these paper cuts. Performance improvements in recent releases suggest the team is optimizing heavily. Faster `hasMethodOverride` checks mean less stuttering during gameplay. Better mod sorting prevents load-order headaches. What'll Break, and How to Handle It Kilt's experimental nature means you're signing up for rough edges. Screen init crashes happen. Model rendering issues pop up. Some Forge mods simply won't work because their core assumptions don't hold on Fabric. Welcome to Haven The Discord community helps. One GitHub issue tracker is the right place to report problems. Pay attention to the changelog between releases - new versions often include compatibility fixes for popular mods. One gotcha: don't assume a mod doesn't work just because it crashes once. Different mods trigger different edge cases. Disable suspects one by one, check the logs, and report systematically. The maintainers need reproducible cases. Actually, this is worth emphasizing: Kilt is bleeding-edge territory. If you're running a public server or a long-term survival world, you might want to wait another version or two before jumping in. The recent releases are solidifying compatibility, but stability still trails behind plain Fabric or Forge. Other Options Worth Considering Kilt isn't the only bridge project. Patchwork tried this earlier but stopped development years ago and maxed out at Minecraft 1.16. Connector does the opposite (Fabric mods on Forge), which doesn't help if you want Forge mods on Fabric. The practical alternatives are staying pure Fabric or pure Forge. Pure Fabric means missing some mods. Pure Forge means slower updates and heavier performance overhead. Kilt splits the difference - and pays for it in stability. If you're just looking for specific functionality, sometimes a Fabric alternative exists. Check mod lists. But if you've found a Forge mod with no equivalent, Kilt's your answer. Where to go from here Read the source on GitHub (docs, examples, and the issue tracker) Browse open issues to see what the community is working on Check recent releases for the latest build or changelog

---

### CraftBook: Your Guide to Minecraft Server Automation
URL: https://minecraft.how/blog/post/craftbook-minecraft-server-plugin
Published: 2026-04-22
Author: ice

EngineHub/CraftBook 🔧 Machines, ICs, PLCs, and more! .0 If you're running a vanilla Minecraft server and want to add custom machines without the complexity of full mods, CraftBook fills that gap perfectly. It's a lightweight plugin that brings redstone circuits, elevators, custom recipes, and automation to your server, all configurable to match your vision. What CraftBook Actually Does CraftBook is a Spigot server plugin that adds gameplay features and redstone automation without requiring players to install a single mod. It's built on the principle that servers should've flexibility: enable the features you want, disable everything else, and tweak configuration to taste. The core features include redstone integrated circuits (ICs) like AND/OR gates and lightning strikers, working elevators that players can use to travel between floors, functional cauldrons for cooking, custom crafting recipes, hidden switches, item-moving pipes, minecart boosters, togglable doors and bridges, chairs you can actually sit on, and the ability to bind commands to items with cooldowns and permissions. What makes CraftBook distinct is that none of these features requires players to install anything. They log into your vanilla server, and suddenly they can craft redstone ICs, build elevators, or sit on chairs. The plugin handles everything server-side. Why Server Admins Choose CraftBook Server owners pick CraftBook for a simple reason: it adds depth without the performance overhead of heavy modpacks. You're not getting the complexity of a full tech-mod suite, but you're adding enough features to make your server feel more complete than vanilla. Think about what players want on a survival server. They want to automate repetitive tasks, travel quickly between areas, and craft special items. CraftBook covers all of that with a light touch. It doesn't require a 50-plugin stack just to function. Elevators alone are a feature people build around. Place some blocks, mark it with the right switch block, and suddenly your server has fast vertical travel that feels smoother than teleportation. Players create elaborate towers and structures just to showcase working elevators. The custom recipe system opens up creative possibilities. Server admins can define items that don't have normal crafting recipes. Want a special boss weapon? Custom compass? Unique map item? Define the recipe in CraftBook and it exists. It's pure customization without writing plugins. How to Install and Run CraftBook Installation is straightforward if you've worked with Spigot plugins before. Start by downloading a build from the EngineHub CI system or compiling from the GitHub source code. bashcd /path/to/server mkdir -p plugins # Download CraftBook JAR from https://enginehub.org/ and place in plugins/ # Restart your server./start.sh # or: java -Xmx1024M -Xms1024M -jar spigot.jar nogui On first startup, CraftBook creates a config directory at plugins/CraftBook/. Inside you'll find config.yml with every feature listed. Scroll through, enable what you want, disable what you don't. Here's the key part: CraftBook works out of the box, but its real power comes from configuration. Default settings are sensible, but you can customize almost everything. Elevator speed, IC behavior, custom recipe formats, permissions - it's all configurable. Once configured, players start using features immediately. They craft ICs, build elevators, set up item pipes. You can also use the /craftbook command to manage features and permissions, though most configuration happens via the config file. Key Features That Matter Redstone ICs are the headline feature. These are logic gates and circuits you craft and place like regular blocks. An AND gate outputs redstone signal only when both inputs are powered. OR gates, XOR gates, lightning strikers - they're all craftable. For a vanilla server, this is genuinely useful. Players can build simple automation without mods. Are these as powerful as mod-based automation? Not even close. You're not getting conveyor belts or automatic sorting systems. But for basic logic - detecting when players are present, triggering traps, controlling doors - ICs work perfectly. Elevators are genuinely impressive. You stack specific blocks in a pattern, add a switch block, and suddenly you've a working elevator. Set it to instant mode for fast travel or smooth mode for animation. The smooth animation is surprisingly satisfying, and players love it. Custom crafting recipes let you define new items or redefine existing ones. You could make a rare drop from mobs into a craftable item. Anyone could create entirely custom items with specific recipes. For role-play servers or servers with custom lore, this is invaluable. Item pipes are underrated. They move items between containers without hoppers. Instead of building hopper chains (which are slow and ugly), you place a pipe and items flow through. It's cleaner, faster, and looks better. For automated farms, this alone is worth running CraftBook. When you're planning your farm layout, the Minecraft Block Search tool helps you find exact materials quickly. Hidden switches are fun for adventure maps. Build a switch that only works from a specific location or only for players with certain permissions. Combine this with doors, and you're creating secret rooms with actual gameplay logic. And one small but delightful feature: chairs you can sit on. Place a special block and players right-click to sit. It's not new, but it adds character to builds. Paired with a cafe or tavern build, chairs make spaces feel alive. Common Mistakes and Gotchas Config formatting is the biggest culprit. CraftBook uses YAML for configuration, and YAML is picky about indentation and syntax. A misplaced space or tab and entire sections fail silently. You won't get an error message; features just don't work. Solution: use a YAML validator when editing the config. Not all features work on all server versions. CraftBook targets modern Spigot versions, but if you're on an older build or an obscure fork, test thoroughly before deploying to players. IC recipes and behavior can be unintuitive. Some ICs require specific redstone configurations to fire. The documentation explains it, but the learning curve is real. Plan to spend time experimenting or reading the docs carefully. Actually, if you're working with technical redstone setups, the Nether Portal Calculator might help you understand coordinate math - useful knowledge when building complex IC networks. Permissions matter. CraftBook respects Spigot permission plugins. If you don't grant permissions explicitly, players might not be able to use features you enabled. Make sure your permission system is configured correctly. When to Use CraftBook (and When Not To) Use CraftBook if you're running a vanilla or vanilla-plus server and want a few automation features. It's perfect for small communities that don't need extreme customization. If your players want fun things to build - elevators, secret rooms, custom items - CraftBook delivers. Skip it if you're already running mods. Modpacks do everything CraftBook does and vastly more. CraftBook isn't meant to compete with Minecraft Forge. Skip it if your players expect industrial-grade automation - they'll quickly ask for Applied Energistics or similar mods. There aren't many direct competitors in the vanilla-plus space. Most servers either stick with vanilla or jump straight to modpacks. CraftBook is the established choice for servers wanting a middle ground, with active development and real community use. The reality is CraftBook sits in a sweet spot: more than vanilla, less than mods. If that's what you're looking for, it's the right tool. If you're looking for full automation or complex mechanics, look elsewhere. Ready to try CraftBook? Grab the source, read the full documentation, or open an issue on GitHub. Star the repo if you find it useful. It helps the maintainers and surfaces the project for other Minecraft players. Visit EngineHub/CraftBook on GitHub ↗

---

### ProtocolLib: Building Advanced Minecraft Server Plugins in 2026
URL: https://minecraft.how/blog/post/protocollib-minecraft-plugin-guide
Published: 2026-04-22
Author: ice

dmulloy2/ProtocolLib Provides read and write access to the Minecraft protocol with Bukkit. ⭐ 1,285 stars.0 Ever tried to build a Minecraft server plugin that does something the standard Bukkit API won't let you do? Yeah, that's where most developers hit a wall. You either reverse-engineer obfuscated Minecraft code (which breaks every update), hook into internal CraftBukkit classes (and pray no other plugin does the same thing), or you just give up. ProtocolLib is the project that exists specifically so you don't have to. What This Project Actually Solves ProtocolLib is a Java library that gives you clean, safe access to the Minecraft network protocol. Instead of wrestling with obfuscated bytecode or dodgy reflection hacks, you get a proper event API that lets you listen to, modify, or cancel packets sent between the server and clients. Think of it like Bukkit events, but for the protocol layer. The big win: you don't reference CraftBukkit at all. No version-specific imports that break in 1.21. No fragile assumptions about internal class structures. Just packet listeners that stay stable across updates. Real Minecraft Use Cases Chat filtering and moderation is the most obvious application. Listen for client-side chat packets, read the message content through ProtocolLib's API, and cancel the packet if the player tries something you've blocked. The message never even reaches the server. Clean, simple, and it works every single update. Custom network features are where things get interesting. You could build invisible particle effects, modify player appearance without skin changes, or send data to the server that the vanilla protocol doesn't officially support. A dueling system with custom visuals? A voting interface that responds to player movement packets? These are the kinds of things ProtocolLib makes possible. But the real reason most people reach for it's plugin compatibility. When multiple plugins hook the same internal classes, everything gets messy. Plugins crash. Data corrupts silently. ProtocolLib centralizes packet handling so different plugins can actually coexist without stepping on each other's toes. That's not glamorous, but it's what keeps servers running smoothly. Installation and Setup If you're building a Bukkit plugin, the setup is straightforward. Add the dependency to your build file first. For Maven: xml<dependencies> <dependency> <groupId>net.dmulloy2</groupId> <artifactId>ProtocolLib</artifactId> <version>5.4.0</version> <scope>provided</scope> </dependency> </dependencies> Note that version 5.4.0 requires Java 17 or higher, so make sure your build environment is up to date. If you're on an older server, grab an earlier release instead. Gradle users should add it like this: gradlerepositories { mavenCentral() } dependencies { compileOnly 'net.dmulloy2:ProtocolLib:5.4.0' } Next, add ProtocolLib as a dependency in your plugin.yml: ymldepend: [ ProtocolLib ] This tells the server that your plugin won't start unless ProtocolLib loads first. Critical for avoiding null pointer exceptions on startup. Then grab a reference to the ProtocolManager in your plugin's onLoad() method: javaprivate ProtocolManager protocolManager; public void onLoad() { protocolManager = ProtocolLibrary.getProtocolManager(); } That's it. You're ready to start listening for packets. How Packet Listeners Work The simplest listener just disables something. Say you want to mute all sound effects server-wide: GitHub project card for dmulloy2/ProtocolLib javaprotocolManager.addPacketListener(new PacketAdapter( this, ListenerPriority.NORMAL, PacketType.Play.Server.NAMED_SOUND_EFFECT ) { @Override public void onPacketSending(PacketEvent event) { event.setCancelled(true); } }); Most of the complexity is right there. You create a PacketAdapter, specify which packet type you're listening for, override the callback, and modify the event. Where it gets useful is reading and changing packet content. Here's a global chat filter: javaprotocolManager.addPacketListener(new PacketAdapter( this, ListenerPriority.NORMAL, PacketType.Play.Client.CHAT ) { @Override public void onPacketReceiving(PacketEvent event) { PacketContainer packet = event.getPacket(); String message = packet.getStrings().read(0); if (message.contains("badword")) { event.setCancelled(true); } } }); The getPacket() call gives you the packet data. You read fields by type (strings, integers, bytes) using their index. No field names, just positions. It's abstract at first, but it means you're never dependent on Minecraft's internal naming, which changes constantly with obfuscation. You can modify packets too. Packet data is mutable, so you can write new values before they're sent. Listener priority matters as well - if multiple plugins listen to the same packet type, LOWEST runs first, HIGHEST runs last, letting you control execution order. Key Features That Make This Worth Using The abstraction layer is the main thing. Instead of dealing with obfuscated NMS (net.minecraft.server) classes, ProtocolLib wraps everything into typed accessors. Want to read player position? It's just packet.getDoubles().read(0), not hunting through a maze of getter methods on some internal class that probably renamed itself last snapshot. Version compatibility is huge. ProtocolLib maintains packet definitions for every major Minecraft release. When you update your server from 1.20 to 1.21.4, your ProtocolLib code just works. The library handles protocol changes internally. You don't recompile anything. Packet injection is another solid feature. You can create packets from scratch and send them to players: javaPacketContainer packet = protocolManager.createPacket(PacketType.Play.Server.NAMED_SOUND_EFFECT); // populate fields... protocolManager.sendServerPacket(player, packet); That's clean compared to trying to instantiate NMS packet classes directly. And again, it survives updates without modification. The library also includes helper classes like WrappedChatComponent, ChunkData, and PlayerInfoData - basically anything tricky to construct gets wrapped with convenient builders. The recent 5.4.0 release fixed initialization issues for versions 1.20.4 through 1.21.5, so they're actively maintained. What Trips New Users Up The index-based field access takes getting used to. You look up the packet wiki to figure out which index corresponds to which field. For common packets it's documented, but if you're dealing with something custom or very recent, you're on your own. That's the tradeoff for not being tied to internal class names. Thread safety matters. Minecraft runs packet handling on the network thread, and your listener code runs there too. If you do anything heavy, schedule it on the main server thread via Bukkit.getScheduler(). Blocking your packet listener stalls the entire network pipeline. Version mismatches will destroy you. If you compile against ProtocolLib 5.4.0 but the server has 5.3.0 installed, you get runtime class not found errors. Match versions exactly. Don't rely on features from newer releases unless you specify a minimum version in your plugin.yml. Debugging is harder than regular code because everything is listener-based. If a packet isn't behaving right, add logging at each step. Verify your listener is being called. Check that field indices match what you expect. The protocol wiki is your friend here. Alternatives and When to Consider Them PacketEvents exists as another option, though it's newer and less battle-tested. If you're building something that needs deep protocol access with modern tooling and don't mind being on slightly less stable ground, PacketEvents might appeal to you. But ProtocolLib is the established choice - 1285 GitHub stars, actively maintained, and the latest release supports Minecraft 1.21.4 through 1.21.8. Some developers just work directly with NMS for highly specialized use cases. That's usually a mistake because you're signing up for maintenance work every Minecraft release. ProtocolLib handles that for you. If you need to explore what players can do with your server, check out our Minecraft Skin Creator and Minecraft Block Search tools.dmulloy2/ProtocolLib - GPL-2.0, ★1285 Support the project ProtocolLib is maintained by the open-source community. If it saved you time or powered something cool, leave a ⭐ on the repo, report bugs, or contribute back. Small actions keep tools like this alive.

---

### Skript: Customize Your Minecraft Server Without Code
URL: https://minecraft.how/blog/post/skript-minecraft-plugin-guide
Published: 2026-04-22
Author: ice

SkriptLang/Skript Skript is a Paper plugin which allows server admins to customize their server easily, but without the hassle of programming a plugin or asking/paying someone to program a plugin for them. ⭐ 1,298 stars.0 Server customization usually means hiring a plugin developer or learning Java from scratch. Skript changes that equation entirely - it's a Paper plugin that lets you write server behaviors in a readable, intuitive script language instead. No Java background required. If you run a Paper server and want custom features without the headache of plugin development, this might be exactly what you need. What Skript Actually Does At its core, Skript is a scripting engine for Paper servers. Instead of compiling Java code into a plugin, you write scripts in Skript's own syntax - a language designed to read almost like English. Want to detect when a player places a specific block and trigger an event? Write it in Skript. Want custom items with special abilities? You can do that too. The project started as Njol's original creation and has evolved significantly through community contributions (the current version is maintained by the SkriptLang organization). It's been around long enough to be stable and mature, yet active enough that it gets updated regularly - most recently supporting the latest Minecraft versions within weeks of their release. What's wild is how much this simplifies things. A plugin that might take a Java developer hours to design, code, debug, and compile can often be written in Skript in minutes. That's not hyperbole; it's the whole point. Why You'd Actually Use Skript Server admins reach for Skript in a few specific scenarios. First: custom gameplay mechanics. Maybe you're running a survival server and want to add a custom economy system, special loot drops, or unique boss mechanics. Rather than hunting for five different plugins that might conflict with each other, or paying someone to code a solution, you write a Skript that handles exactly what you need. Second: quick prototyping. Testing an idea for a server feature? Throw it in Skript first. If it works and the community loves it, you can always hire someone to optimize it into a full plugin later - or just stick with Skript if it runs fine. Third: bridging plugin gaps. You've got most of your server running perfectly, but there's one weird edge case no plugin quite handles. Skript fills those gaps fast. Fourth: learning. If you're curious about plugin development but Java intimidates you, Skript is a lower barrier to entry. You learn how server events, triggers, and actions work without fighting compilation errors and type systems. If you're exploring servers to test your ideas, check out the Minecraft server list to see what kind of communities are running custom mechanics - many of them probably use Skript. Installation and Setup Getting Skript running is straightforward, but there's a critical requirement: your server must run Paper, not Spigot or vanilla. This isn't a limitation; it's by design. Paper has the performance improvements and API extensions that Skript depends on. Once you've confirmed you're on Paper, the installation is two steps: Head to the Skript releases page and download the latest version's JAR file. Drop it into your server's plugins folder and restart. That's it. No manual configuration needed to start - Skript generates a config folder on first load. bashcp Skript-2.15.0.jar /path/to/server/plugins/ cd /path/to/server java -jar server.jar nogui When your server boots up, you'll see Skript load in the console. If there are any errors (usually related to unsupported Minecraft versions), they'll show up immediately. Assuming you're running a supported version, you're ready to start writing scripts. What You Can Actually Build The feature set is bigger than most people expect. Custom items and equipment. Define items with custom names, lore, enchantments, and behavior. Create a sword that shoots fire when you right-click it, or a helmet that gives special abilities - all without touching Java. Event handlers. React to almost any Minecraft event: block placement, damage, chat messages, inventory clicks. Write logic that triggers when these events happen. Someone breaks a dirt block? You can run custom code. A player types a command? Handle it. Custom commands. Build commands that do whatever you want. Need a /spawn command that teleports players back to a custom location? A /party system? Command handling in Skript is straightforward. Conditional mechanics. Use if-statements, loops, and variables just like any programming language. If player has permission X, do Y. Loop through all online players and apply an effect. Store data that persists across restarts. Integration with blocks and materials. Since you're dealing with Minecraft blocks, you'll want to reference them by name. When building complex structures or block-based mechanics, the block search tool is handy for looking up exact block names and properties. The latest release (version 2.15.0) added Adventure and MiniMessage integration. That means better support for colors, formatting, and advanced chat features. It's the kind of quality-of-life improvement that shows the project is actively maintained. Common Gotchas and Pitfalls Skript is forgiving compared to Java, but it's not magic. Version compatibility. Skript officially supports the last 18 months of Minecraft versions from its release date. That sounds generous until you realize older servers might not be compatible. If you're running 1.20.2 and Skript's newest version targets 1.21.1 and beyond, you'll need to either update or use an older Skript version. Check the releases page to match your server version. Performance at scale. Skript isn't Java-optimized. If you write inefficient scripts (like looping through all blocks in a region every tick), your server will lag. It's not a design flaw; it's just the nature of scripted code. Well-written Skript runs great, but you still need to think about performance. Syntax quirks. The language reads like English, but it's not actually English. There are rules about where parentheses go, how variables are named, and what syntax triggers what function. The learning curve is shallow, but there's one. Reading the documentation helps. Add-on ecosystem. Skript has add-ons created by community developers that extend its functionality. The maintainers don't officially support these. That means you're relying on third-party code. That's fine if you trust the developer, but just be aware. Alternatives Worth Considering Skript isn't the only tool for server customization. CommandHelper is older and covers similar ground, but Skript has more momentum and better documentation at this point. If you're choosing between them, Skript is the better starting point in 2026. Custom plugins in Java. If you need industrial-strength features or plan to distribute your plugin, learning Java is still the right call. Skript is for server-specific customization, not production plugins you'd sell or share widely. Behavior Packs and datapacks. On vanilla or some modded servers, you can do a surprising amount with datapacks and JSON. They're more limited than Skript but don't require a plugin at all. If your server runs vanilla, datapacks are worth exploring. The choice usually comes down to: how much customization do you need, and how much time do you want to spend? Skript is the sweet spot for "I want custom features without weeks of Java study." Where to go from here Read the source on GitHub (docs, examples, and the issue tracker) Browse open issues to see what the community is working on Check recent releases for the latest build or changelog

---

### PowerNukkitX: Building Custom Bedrock Servers
URL: https://minecraft.how/blog/post/powernukkitx-bedrock-server-setup
Published: 2026-04-22
Author: ice

PowerNukkitX/PowerNukkitX Open-source, feature-rich Minecraft: Bedrock Edition server written in Java. Supports custom items, blocks, entities, full vanilla commands, advanced mob AI, and world generation. Not affiliated with Mojang AB. .0 Running your own Minecraft server doesn't require Mojang's infrastructure anymore. PowerNukkitX is a free, Java-based server platform built specifically for Bedrock Edition, and it's genuinely impressive if you're tired of the limitations that come with vanilla hosting. You get custom items, blocks, mobs, and complete control over world generation - all on an open-source codebase that's actively maintained. What PowerNukkitX Actually Does At its core, PowerNukkitX is a third-party server software for Minecraft: Bedrock Edition. Unlike Java Edition's single-player-friendly structure, Bedrock Edition servers work differently, and PowerNukkitX fills that gap. It's not affiliated with Mojang - it's a community project maintained on GitHub with 602 stars and a Discord community of developers and server operators. So what makes it different from just running a default Bedrock server? Custom items and blocks (not just vanilla ones) Full vanilla command support - everything Bedrock has, without restrictions Advanced mob AI and behavior customization Terra world generation (more control over terrain than default) Container and inventory systems that work like Java Edition The project targets Minecraft 26.10 (Bedrock protocol 944), so you're running current-era Bedrock with features you'd normally only get on premium realms or third-party hosting services that cost money. The trade-off is you manage the server yourself. Why You'd Actually Run This The obvious reason: cost. Running a Bedrock realm through Mojang costs real money monthly. PowerNukkitX is free, open-source under LGPL-3.0, and you can self-host on any machine running Java. But there's more. If you're building a custom survival world for friends, you probably want things beyond vanilla. Maybe you're recreating real-world cities and need custom building blocks. Maybe you want mob variations or loot systems that don't exist in standard Bedrock. Maybe you just want to avoid the "realm owner can kick you" problem. Bedrock Edition also includes mobile players (iOS, Android, Windows), Nintendo Switch, and Xbox users on the same server. PowerNukkitX handles all of them through a single codebase, so if you want a truly cross-platform server, this is simpler than juggling multiple services. Installing PowerNukkitX (The Actually Simple Part) The setup process is straightforward, though it requires a bit of Java knowledge. First, you need JDK 21. If you don't have it, grab GraalVM or any JDK21-compatible distribution. Check your version with java -version. If you're on Java 21+, some startup scripts handle compatibility automatically. Next, download the server JAR from the GitHub releases page: bashcurl -L https://github.com/PowerNukkitX/PowerNukkitX/releases/download/snapshot/powernukkitx.jar -o powernukkitx.jar Then start the server. On Java 21, use the basic command: bashjava -jar - add-opens java.base/java.lang=ALL-UNNAMED - add-opens java.base/java.io=ALL-UNNAMED powernukkitx.jar If you're on Java 22 or later, grab one of the startup scripts from the PowerNukkitX scripts repository - they handle the JVM flags automatically so you don't have to remember them. The server will generate a configuration file and start accepting connections. Your Bedrock players can connect using the server IP and port (defaults to 19132). Actual vanilla multiplayer is available immediately. Features That Actually Matter Custom Items and Blocks. This is the headliner. You can define items and blocks that don't exist in vanilla Bedrock, assign them custom textures (if your clients have resource packs), and build game mechanics around them. No need to abuse existing blocks or use workarounds. GitHub project card for PowerNukkitX/PowerNukkitX Vanilla Command Parity. PowerNukkitX supports the full command syntax that Bedrock understands. So that means `/execute`, `/teleport`, `/summon`, `/give` - everything works like you expect. If you've built command chains for a Java Edition server, they're partly portable here (with Bedrock syntax adjustments). The mob AI is worth mentioning. You're not stuck with default pathfinding and behavior trees. The server lets you customize how mobs interact with the world, so if you want Endermen that don't teleport, or Creepers with different explosion mechanics, that's feasible at the server level. Terra Generator. World generation is usually the hardest part of custom servers. PowerNukkitX includes Terra, which gives you control over biomes, ore distribution, structure spawning, and terrain shape without needing to manually build everything. It's closer to what you get with datapacks on Java Edition. If you're running a survival economy server, you can tie custom items to a plugin-based currency system or link them to specific gameplay loops. If you're building an RPG, custom entities and AI open up combat possibilities. What Trips People Up Customization requires you to understand Bedrock's format for defining items and blocks. It's not as intuitive as Java Edition mods - you'll be writing JSON or learning the server's plugin API. If you want just a vanilla+ server with zero modifications, PowerNukkitX is overkill. Stick with a standard Bedrock realm instead. The documentation is active but not full yet. You'll spend time in the Discord asking questions. The community is helpful, but don't expect tutorials at the level of Java Edition's Spigot ecosystem. Performance scales differently than Java Edition. A 2-year-old laptop can't run a 50-player server anymore. You need decent hardware, particularly RAM and CPU. Test on a staging environment before inviting your full player base. Also, your players need to be on current Bedrock versions. If someone's running a year-old client, they might not connect properly. This isn't really PowerNukkitX's fault - Bedrock protocol updates frequently - but it's worth knowing. Testing Your Setup Once your server is running, you can test connections directly in Bedrock Edition. If you're exposing it publicly, test your network port forwarding. For private servers behind a firewall, make sure the firewall rule allows port 19132 (or your custom port). If you're setting up multiplayer polls or voting systems, tools like the Minecraft Votifier Tester can validate that external integrations work correctly. And if you're building a server with custom content or skins, the Minecraft Skin Creator is handy for generating test assets. How This Compares If you want a Bedrock server, your main options are: official realms (cost money, limited customization), Azure Marketplace (also paid, Mojang-endorsed), or third-party hosters (cheaper, less control). PowerNukkitX is the self-hosted open-source alternative. You trade convenience for control and cost savings. It's not meant to compete with Spigot or Paper for Java Edition. Those are Java-only tools. PowerNukkitX is the nearest equivalent for Bedrock's cross-platform ecosystem. If you're comparing it to other Bedrock server projects, PowerNukkitX is actively developed (latest snapshot, protocol 944) and has a growing plugin ecosystem. It's the most feature-complete open-source option right now for Bedrock customization. Ready to try PowerNukkitX? Grab the source, read the full documentation, or open an issue on GitHub. Star the repo if you find it useful. It helps the maintainers and surfaces the project for other Minecraft players. Visit PowerNukkitX/PowerNukkitX on GitHub ↗

---

### Connecting Bedrock Players to Java Servers with GeyserConnect
URL: https://minecraft.how/blog/post/geyserconnect-bedrock-java-servers
Published: 2026-04-22
Author: ice

GeyserMC/GeyserConnect GeyserConnect is an easy way for bedrock clients to connect to any Java edition servers without having to run anything. The divide between Bedrock and Java Edition has always been Minecraft's awkward split personality. You're playing on Switch or Windows Bedrock. Your friends built a server in Java Edition. They can't invite you without installing a proxy, which most casual players won't touch. GeyserConnect solves this friction entirely - Bedrock players can join Java servers through a simple menu, no installation required. What GeyserConnect Actually Does GeyserConnect is a proxy server that translates Bedrock Edition connections into Java Edition protocols on the fly. Think of it as a protocol bridge: Bedrock players connect to the GeyserConnect instance, which then relays them into Java servers. The beauty is simplicity. Players see a server menu inside Bedrock, pick a server, and spawn in. No terminal commands. No downloaded Geyser instances on their machine. No friction. It's built on top of Geyser, which already handles the heavy lifting of converting packets between the two editions. GeyserConnect wraps that in a user-friendly layer, adding the multi-server menu system that made BedrockConnect popular years ago, but with active maintenance and proper Bedrock support. Why You'd Actually Set This Up If you run a Java server and want to include Bedrock players, this is the path of least resistance. No mods on the server side. No mods on the client side. The server hosts one proxy; Bedrock clients connect to it. Done. Server hosts especially love this approach because it scales. Want to run five Java servers and let Bedrock players pick between them from a single entry point? GeyserConnect handles that in one configuration file. Maintenance happens in one place. Players get a clean menu instead of memorizing multiple IPs. And honestly, if you're already running Java servers and own the hardware, you're already halfway there. You just need one more application running. How the Connection Actually Works When a Bedrock player launches the game, they add your GeyserConnect instance as a server. They see a curated list of Java servers you've configured - each with a name, description, maybe a player count. Those tap one. GeyserConnect translates their connection and spawns them into that Java server. Behind the scenes, packets are being rewritten constantly. Movement commands, chat messages, block interactions, combat - all converted from Bedrock format to Java format and back. The player never sees this translation. It's genuinely transparent. You can mine, craft, PvP, and build redstone contraptions exactly as you would on a Java server directly. Chunks load normally. Mobs behave the same way. If the server's running vanilla or well-written plugins, everything feels native. One honest caveat: some Java features don't map cleanly to Bedrock's capabilities. Complex mods or very new Java features might cause rendering glitches or feature loss. But standard Java servers? Even modded vanilla with popular plugins like Essentials or LiteBans? They work smoothly. Features That Matter Server lists are the obvious one. Bedrock clients get a GUI instead of a terminal, with multiple servers listed in one place. Each can show a description, MOTD, and ping. Players pick and connect. This mirrors how Bedrock realms work, so it feels familiar. GitHub project card for GeyserMC/GeyserConnect Console commands give you operational power. The `/geyserconnect messageall` command broadcasts to every connected Bedrock player (handy for announcements). `/geyserconnect transferall` moves everyone to a different server in one shot - useful when you're spinning down a server for maintenance or want to consolidate players during off-peak hours. DNS redirection is included. If you want players to connect via a domain name instead of an IP, the repository includes bind9 configurations. Most people stick with IPs, but this option exists for anyone running a serious network. You also get per-server configuration. Each Java server in your list can have its own settings, so you're not locked into a one-size-fits-all setup. Getting It Running Setup assumes basic Java knowledge. Clone the GitHub repository, build it (the repo includes build instructions), configure your server list in YAML, and run the JAR file. Configuration is straightforward: define servers by IP, port, and name. Once it's running, you distribute the proxy IP or domain to your Bedrock players. They add it as a server, and they're in. No wait, no dependency hell, no client-side configuration. My recommendation: test with two or three servers first. Verify that Bedrock clients connect, that players can move around and chat, that commands work. Once you're confident, add more servers to your list. Gotchas and Things to Know Bedrock clients cache server lists aggressively. If you add or remove servers, players might see stale data until they completely close and reopen their client. Not a bug - it's just how Bedrock handles offline discovery. Tell your players to do a full restart if they report missing servers. Network latency stacks. If your proxy has a slow connection to your actual Java servers, Bedrock players will feel that lag more acutely than Java players might. Proximity matters. Hosted in the same datacenter? Ideal. Halfway across the world? Your players will notice. IP-based authentication gets tricky. All Bedrock connections appear to originate from your proxy's IP, not the player's real IP. If you're doing strict IP whitelisting or IP-based bans, you'll need a different authentication strategy. GeyserConnect has systems for this (usually player name or UUID-based auth), but it requires deliberate configuration. Also note: not every player on Bedrock will have the latest version. Some players run older Bedrock builds. This can cause compatibility issues with newer Java server features. It's generally fine, but vanilla servers handle this better than bleeding-edge modded servers. When to Use Alternatives If you want Bedrock support on Java servers, there are other paths. You can run Geyser as a server plugin, which puts the proxy inside your Java server directly. This works, but it requires server-side setup and makes things heavier. Standalone Geyser proxies exist if you want maximum control. They give you flexibility but require more configuration work from the player. BedrockConnect used to fill this role, and it was genuinely elegant. GeyserConnect is essentially the modern, actively maintained evolution of that concept, built on Geyser instead. For anyone running multiple Java servers and wanting to include Bedrock players? GeyserConnect is honestly the sweet spot. Low barrier to entry, solid feature set, and active community backing. If you're curious about how your Java servers perform, check out the Minecraft Server Status Checker to monitor latency and uptime. And if Bedrock players want to customize their experience with skins, the Browse Minecraft Skins collection is a great resource. Ready to try GeyserConnect? Grab the source, read the full documentation, or open an issue on GitHub. Star the repo if you find it useful. It helps the maintainers and surfaces the project for other Minecraft players. Visit GeyserMC/GeyserConnect on GitHub ↗

---

### MCscripts: Automated Server Management for Minecraft
URL: https://minecraft.how/blog/post/mcscripts-minecraft-server-automation
Published: 2026-04-22
Author: ice

TapeWerm/MCscripts Minecraft Java and Bedrock Dedicated Server systemd units and scripts for backups, automatic updates, and posting logs to chat bots Running a Minecraft server means dealing with tedious maintenance tasks: backing up your world before it's lost to corruption, updating the server software without crashing everyone mid-game, and keeping your community informed through chat notifications. MCscripts tackles all of this by automating server management through systemd, a Linux process manager. If you've been manually babying your Minecraft server, this project might save you hours. What MCscripts Actually Does At its core, MCscripts is a collection of shell scripts and systemd unit files that turn server management into background automation. It works with both Java Edition and Bedrock Edition servers on Ubuntu, handling the operational overhead that most server admins usually ignore until something breaks. The project provides three main capabilities: Scheduled backups that run automatically and push snapshots to external storage Update checking and automated patching for Bedrock servers (Java Edition uses external jar management) Webhook integration to post server logs and events directly to Discord, Slack, or other chat platforms Everything runs through systemd, which means you get proper logging, service management, and the ability to run commands like sudo systemctl start mcbe-backup@MCBE instead of hunting for shell scripts in various directories. Why You'd Actually Want This Let me be honest: MCscripts is for people running servers that matter to them. If you're just goofing around on a local LAN world, skip this. But if you're hosting a community server, managing it for friends, or want peace of mind that your world won't vanish because you forgot to back it up last month, automation beats manual discipline every time. Consider the typical server owner's nightmare scenario. You're patching your Bedrock server and something goes wrong. The old world file gets corrupted, and you're staring at blank looks from your players. With MCscripts' automated backup system, you've got snapshots stored on external drives, ready to restore in minutes. One command restores your last backup: bashsudo systemctl stop mcbe@MCBE sudo /opt/MCscripts/bin/mcbe_restore.py ~mc/bedrock/MCBE BACKUP sudo systemctl start mcbe@MCBE That's it. Your world is back. The chatbot logging feature is surprisingly useful too. Instead of SSH-ing into your server to check logs, you get real-time notifications in Discord. Player joins, deaths, chat messages - all flowing into a dedicated channel. It keeps your community informed without turning logging into busywork. Installation and Setup Getting MCscripts running involves downloading the project and running the installer as root. It's straightforward, but there are a few things to know beforehand. First, you need Ubuntu. The project is explicitly built for Ubuntu systems (including WSL, though WSL has some caveats with systemctl). If you're on a different Linux distribution, you might need to adapt the install script. The basic install process looks like this: bashcurl -L https://github.com/TapeWerm/MCscripts/archive/refs/heads/master.zip -o /tmp/master.zip unzip /tmp/master.zip -d /tmp sudo /tmp/MCscripts-master/src/install.sh The installer sets up systemd units, creates the mc user for running the server process, and organizes everything in /opt/MCscripts. If you want backups stored on an external drive (which you should), the setup is a single symlink: bashsudo ln -snf /path/to/external/drive /opt/MCscripts/backup_dir For Java Edition, you'll also need a JRE. Ubuntu systems don't ship with Java by default, so you'd install it like this: bashsudo apt update && sudo apt install openjdk-25-jre-headless Then initialize the server: bashsudo systemd-run -PGqp User=mc - /opt/MCscripts/bin/mc_getjar.py This downloads the latest Java Edition server jar and sets up your world. Simple enough. Key Features in Action Automated Backups are the star feature. They run on a schedule (configurable through systemd overrides) and store compressed snapshots of your world. MCscripts is smart about storage too - it doesn't keep infinite copies, and for Bedrock it specifically preserves your worlds, packs, and configuration files while removing temporary junk that bloats backups. GitHub project card for TapeWerm/MCscripts Running Server Commands from the command line beats logging into the console every time. Need to add someone to the allowlist or run a save-all? Use the mc_cmd.py script: bashsudo /opt/MCscripts/bin/mc_cmd.py SERVICE COMMAND... Want to add multiple players at once? MCscripts documentation even shows you how to loop commands: bashallowlist=$(for x in steve alex herobrine; do echo "allowlist add $x"; done) sudo /opt/MCscripts/bin/mc_cmd.py SERVICE "$allowlist" Viewing Server Output through journalctl is cleaner than raw logs. The project includes a sed script that colors output for readability: bashjournalctl -u SERVICE | /opt/MCscripts/bin/mc_color.sed | less -r +G It's the kind of small touch that makes server administration less painful. Chatbot Integration is optional but genuinely cool. You can configure webhook URLs for Discord or Slack, and MCscripts pipes server events and logs directly to your chat platform. Now your community stays in the loop without needing SSH access. Things That Catch People Off Guard MCscripts assumes you're comfortable with Linux and systemd. If you're using Windows Subsystem for Linux, some functionality breaks. WSL doesn't support systemctl poweroff, and a few other systemd features behave unexpectedly. The README notes this upfront, so read it carefully before installing on WSL. You can still run the Python scripts directly without enabling systemd units, but you lose the automation benefits. Bedrock Edition has a quirk: the update script removes files it doesn't recognize. MCscripts only keeps worlds, packs, JSON files, and properties files. If you've installed mods or custom files in your Bedrock server directory, the update process will delete them. Painful if you don't know this is coming. One more thing to remember: console output is handled through journalctl, not a traditional log file. If you're used to tailing /var/log/minecraft.log, you'll need to adjust your habits. The learning curve is small, but it's a shift. Also, if you're managing multiple Bedrock servers, each one needs its own systemd instance. The naming scheme uses templated units like mcbe@MCBE, where MCBE is your server name. Nice design, but it means your configuration commands need to specify which server you're managing. Should You Use This Over Alternatives? If you want a lightweight, no-nonsense automation solution for Ubuntu servers, MCscripts is excellent. The project is actively maintained, has 162 stars on GitHub, and the codebase is readable Shell scripts - not some mystery black box. Docker is an alternative if you prefer containerized Minecraft servers. The MCscripts project even notes that its backup script works with Docker, so you're not locked out of that approach. Docker gives you more portability and isolation, but it's overkill for most small community servers. Some people use Pterodactyl Panel, a full-featured game server control panel with a web interface. That's a much heavier solution and adds complexity you might not need. Pterodactyl is great if you're hosting multiple types of game servers, but for pure Minecraft automation on a VPS, MCscripts is leaner. Your hosting provider might offer built-in backup and update tools. Check what they provide before reinventing the wheel. But if you're running your own hardware or have a bare-bones VPS, MCscripts fills that gap perfectly. Getting Started and Moving Forward The best part about MCscripts is that it stays out of your way. Once it's installed and configured, automation just happens. You don't need to babysit it or wonder if your backups are actually running. If you're building a Minecraft community, consider pairing your server automation with other tools. A good MOTD creator helps new players understand what your server is about when they see it in their server list. And if you're running a community where players share skins, linking to a skin browser like Minecraft skins keeps people engaged with the ecosystem you're building. Server management shouldn't feel like a chore. MCscripts automates the boring parts so you can focus on what actually matters: your community and the world you're building together. Ready to try MCscripts? Grab the source, read the full documentation, or open an issue on GitHub. Star the repo if you find it useful. It helps the maintainers and surfaces the project for other Minecraft players. Visit TapeWerm/MCscripts on GitHub ↗

---

### Tenet: Running Mods and Plugins on One Minecraft Server
URL: https://minecraft.how/blog/post/tenet-minecraft-hybrid-server
Published: 2026-04-22
Author: ice

"Minecraft Forge Hybrid server implementing the Spigot/Bukkit API, formerly known as Thermos/Cauldron/MCPC+" Teneted/Tenet · github.com ⭐ 1,512 stars.0 Most Minecraft server admins face a tough choice: you can run a Forge server loaded with mods, or a Spigot server loaded with plugins. But what if you wanted both? Tenet is a hybrid server implementation that bridges this gap, letting you use the mod ecosystem and plugin ecosystem on the same server. It's built on years of development (formerly Thermos, Cauldron, and MCPC+) and gives dedicated server owners flexibility they didn't have before. What This Project Does Tenet is a Minecraft server implementation that combines Minecraft Forge and the Spigot/Bukkit API into one executable. Instead of picking a lane, you get both. Forge handles your mods, Bukkit handles your plugins, and Tenet orchestrates them together on the same server, sharing the same world and player state. It's not the only hybrid server that exists. Mohist and Arclight do similar things. But Tenet carries a unique legacy - it evolved from the original MCPC+ (the grandfather of this whole category) through Thermos and Cauldron. If you've heard the term "hybrid server" before, you're probably thinking of Tenet's ancestors. How does it actually work? Tenet patches both the Forge codebase and the Bukkit/Spigot codebase to coexist. And it remaps classes so they don't conflict, intercepts events so both systems get notified when things happen, and keeps them in sync about world state. When you load a mods folder AND a plugins folder, Tenet makes sure they're both running against the same game instance. No sandboxing, no translation layer - they're genuinely integrated. Why You'd Actually Use This Server admins have different needs. Some want QoL plugins like EssentialsX for commands and warps, but also want worldgen mods for better terrain. Others run economy plugins but need tech mods for factory gameplay. A survival server might use plugins for protection but mods for dimensions. The plugin ecosystem excels at convenience and administration. And that mod ecosystem excels at gameplay variety. Before hybrid servers, you couldn't have both. You'd either run vanilla Forge (mods but no plugins), or you'd compromise and use Bukkit but try to find mod-equivalents in plugin form (which usually don't exist, or are much worse). Tenet cuts that Gordian knot. Some concrete scenarios where you'd pick Tenet: You run a survival server with custom terrain generation mods but want Essentials for player management Your tech modpack needs a proper economy, which the plugin ecosystem handles better than mods You're running Twilight Forest (mod) and want McMMO or other progression plugins alongside it Your players expect chat management, vanish, and standard admin tools, but you also want Create or Immersive Engineering The downside? Hybrid servers are heavier on RAM, trickier to maintain, and sometimes have compatibility issues when mods and plugins step on each other's toes. It's the flexibility tax. But if you're managing a server with specific gameplay goals, it might be worth paying. Getting Tenet Running Before you start, know your Minecraft version. Tenet supports specific versions (check their releases page for what's current). As of early 2026, recent versions are available, but always verify before downloading. GitHub project card for Teneted/Tenet The basic setup flow looks like this: Grab the Tenet JAR from their GitHub releases Create a server directory and place the JAR inside Run it once to generate server.properties and the world directory Drop your mods into a mods folder Drop your plugins into a plugins folder Start the server again Here's what that looks like in practice: bashmkdir minecraft-server cd minecraft-server wget https://github.com/Teneted/Tenet/releases/download/[version]/Tenet-[version].jar java -Xmx4G -Xms4G -jar Tenet-[version].jar nogui That first run will create your server structure. Shut it down, add your mods and plugins, then start again. The startup will take longer than vanilla because both Forge and Spigot are initializing, plus plugins are loading. Be patient. One practical tip: give your server at least 4GB of RAM, probably more if you're using heavy mods and many plugins. A hybrid server is doing the work of two systems at once. What Makes Tenet Different The big draw is compatibility. You can search for a Spigot plugin and a Forge mod independently, install both, and they'll almost always coexist peacefully. Compare that to trying to get a Forge-only server running alongside a plugin ecosystem (impossible) or trying to find plugin versions of mod functionality (usually limited). Event handling deserves a mention. Both Forge and Bukkit have event systems. Tenet makes sure both systems see the relevant events. A player placing a block triggers Forge block events AND Bukkit block events. A mob spawning triggers both frameworks. But this sounds simple but it's actually complex under the hood. Performance is mixed. On one hand, you're running less code duplication than two separate servers. On the other hand, you're running more code overall than a pure Forge or pure Spigot server. Most admins report acceptable performance with good hardware. Just don't expect it to match vanilla-speed servers. Updates are where things get tricky. When Mojang releases a new Minecraft version, the Forge team updates Forge. When Spigot releases for that version, you need a Tenet maintainer to patch both together. This means Tenet sometimes lags behind the latest MC version. That's a real constraint to factor in if you're running a bleeding-edge server. Common Gotchas Plugin and mod conflicts happen. If a mod changes how mob spawning works and a plugin also tries to change mob spawning, you might get unexpected behavior. It's rare, but it happens. Test your mod-plugin combo on a dev server before production. Minecraft BFI IMAX 360 Class shadowing is the most confusing issue. If a mod and a plugin both define or modify the same Minecraft class, weird things can occur depending on load order. Tenet's remapping system helps, but it's not perfect. Check GitHub issues for your specific mods and plugins to see if anyone's reported problems. Actually, that's worth emphasizing: before you install something, search the Tenet GitHub issues and community forums. If someone else ran your exact mod-plugin combo and hit a wall, you'll find the solution there. Server startup times are noticeably longer than vanilla. Expect 30-60 seconds for a modest setup, longer for heavy modpacks. This is just how it's - both Forge and Bukkit need initialization time. JAR size matters. A hybrid server JAR is huge compared to vanilla or Spigot. This affects download time and startup speed. It's not a dealbreaker, just something to plan for. Alternatives Worth Knowing About If hybrid servers feel like overkill, you have options. Paper is a high-performance Spigot fork that's perfectly fine for plugin-only servers and has become the community standard. If you only care about mods, Forge remains the dominant modding framework and you can run pure Forge servers without any hybrid complexity. Mohist is another hybrid server that works similarly to Tenet. It's more actively maintained in recent years and might have better 1.20+ support depending on the exact version you need. Arclight is also in this category. Your choice between them often comes down to which version of Minecraft you're targeting and which community has reported fewer issues with your specific mod-plugin combo. If you're just looking to set up a basic Minecraft server and wondered what this was about, minecraft.how's server list has plenty of other options to consider. And if you want to customize your server's MOTD, the MOTD creator tool works with any server type. Is Tenet Right for Your Server? Tenet shines if you've found yourself wanting specific mods and specific plugins that don't replicate each other's functionality. If you're running a hardcore modpack but also want Discord integration and economy plugins, hybrid servers are your answer. If you're running vanilla Spigot and just want better worldgen, installing a few worldgen mods might be enough to justify the hybrid overhead. But if you're running a simple survival server or a pure modpack server where the mod ecosystem already handles what you need, stick with what's simpler. Tenet is power for people who actually need it. The extra complexity and resource usage isn't worth it otherwise. The Tenet project has been around for years (and its predecessors for even longer). One community knows how to troubleshoot it. If you decide to go this route, you're not experimenting with something fragile - you're joining a well-established ecosystem.Teneted/Tenet - GPL-3.0, ★1512 Ready to try Tenet? Grab the source, read the full documentation, or open an issue on GitHub. Star the repo if you find it useful. It helps the maintainers and surfaces the project for other Minecraft players. Visit Teneted/Tenet on GitHub ↗

---

### How ViaBackwards Keeps Your Minecraft Server Multi-Version
URL: https://minecraft.how/blog/post/viabackwards-minecraft-server-guide
Published: 2026-04-21
Author: ice

ViaVersion/ViaBackwards Allows older clients to connect to newer server versions for Minecraft servers. .0 You've updated your Minecraft server to the latest version. But now your friends on 1.20.5 can't join. Neither can those still playing on 1.19. A multi-version server used to be a fantasy - until someone built ViaBackwards. It's a plugin that lets old Minecraft clients connect to newer servers, and it quietly fixes all the version mismatch headaches that come with that. What ViaBackwards Actually Does ViaBackwards is a protocol translator. Minecraft's network protocol changes with almost every release. Block IDs shift, inventory mechanics change, even the way entities look over the wire. When you run a 1.21 server and a 1.19 client tries to join, they're speaking different languages. ViaBackwards sits in the middle and translates. It's a plugin - not a mod, not a proxy fork - which means it runs on your existing Paper or Spigot server. Technically it depends on ViaVersion, which handles forward compatibility (newer clients on older servers). ViaBackwards complements that by handling backward compatibility. Together, they let your server accept players from versions spanning years of Minecraft updates. The coolest part? You don't have to maintain separate server instances for different versions. One server. One world. Everyone plays together. Why You'd Actually Use This Server owners are the obvious audience. If you run a public server, ViaBackwards is genuinely useful. Player bases don't update in lockstep. Some folks stay on 1.20 because they prefer the build style. Others jump to 1.21 the day it drops. Without version support, you either fragment your community (multiple servers) or force updates (lose players). ViaBackwards sidesteps both. There's a second group: modded players. ViaFabric and ViaFabricPlus let you drop ViaBackwards into your mod folder, which means fabric players on older versions can join vanilla servers running 1.21. This matters more than it sounds, especially for players whose favorite mods haven't updated yet. And honestly? If you're experimenting with a public server but haven't settled on a version yet, ViaBackwards buys you flexibility. You can release on 1.20.5, update to 1.21 when you're ready, and not worry about isolating half your player base. The trade-off is real though. Older clients talking to newer servers introduces bugs the devs can't fully solve - more on that below. How to Install ViaBackwards Grab the jar from Hangar (if you're using Paper) or Modrinth (if you're using modded clients). Drop it in your plugins folder alongside ViaVersion, which you already need. bashcd /path/to/server/plugins wget https://hangar.papermc.io/api/v1/projects/ViaBackwards/versions/latest/download Restart the server. That's it. No configuration required out of the box. If you want to tinker, ViaBackwards generates a config file. The version in 5.9.0 added a notable option: pass-original-item-name-to-resource-packs. It's enabled by default and passes original item identifiers to resource packs (useful if you're using custom assets). You'd toggle this only if something breaks with your resource pack setup. For modded clients, the install is slightly different. ViaFabric users drop the mod in mods. ViaFabricPlus users drop it in config/viafabriclus/jars. Either way, one jar file and you're done. What Actually Works Between Versions ViaBackwards maintains translation mappings for blocks, items, and entities. A 1.19 client doesn't know what a Sniffer is (1.20 mob), so ViaBackwards translates it to something the old client can display. Same with new blocks. Missing items get swapped for closest equivalents. The recent 5.9.0 release fixed spectate mode interactions in 26.1 to 1.21.11. It also patched leather armor color rendering on 1.21.4. These are the kinds of edge cases the maintainers quietly squash - the stuff that would confuse players if left broken. Keep in mind, ViaBackwards releases a few days after a Minecraft update unless the protocol changes are trivial. If you want early access to new version support, the project offers GitHub Sponsors at a tier with pre-release builds. Helpful if you want to update servers on day one. Known Gotchas and Limits It's not perfect. Clients older than 1.17 can't see blocks below y=0 or above y=255 on 1.17+ servers that use expanded world height. This is a hard limit of the protocol - the old clients literally don't have the coordinate space for it. If your server uses a world with custom min_y or height values, older players just won't see those blocks. It's weird, but not a dealbreaker for most survival servers. Inventory desync happens sometimes on 1.17 clients joining 1.17+ servers (actually, this got partially fixed in 5.9.0 for 1.17 to 1.16.5 transitions). You might click something, and your inventory briefly looks wrong server-side even though it's fine on your screen. It usually corrects itself, but it's annoying. Some mods like AxSmithing patch specific issues like the 1.20+ smithing table not working for pre-1.19.4 clients. Sound mappings are incomplete. Newer blocks and mobs have sounds old clients don't know about, so some audio just won't play. Not game-breaking, but you'll notice. And actually, there's something people miss: keepalive packet handling. A 1.12 client on a 1.11 server can disconnect unexpectedly due to keepalive timeouts. The 5.9.0 release fixed this, so if you're running an old server, update ViaBackwards. Alternatives and Related Projects You've probably heard of ViaVersion (the forward-compatibility counterpart). There's also ViaProxy, which acts as a standalone proxy if you want to filter connections without touching your main server jar. And if you're specifically using Fabric, ViaFabricPlus has some extra features for client-side compatibility. If you need a simpler solution that doesn't require plugins - say, you want version support without the maintenance overhead - some hosts offer version-agnostic servers, but you'll lose customization options. Most serious server owners end up with ViaVersion + ViaBackwards because it works, it's open source, and the community maintains it actively. The reality is, ViaBackwards is the go-to. 589 GitHub stars and active development for good reason. Making It Work for Your Server If you decide to install ViaBackwards, test it with a few older clients before opening to your full player base. Join on 1.19, then 1.20, then whatever your server version is. Check that inventory actions work smoothly. Try fishing. Try combat. These are usually the first things that feel weird if version translation is off. Also consider your world. If you've explored high enough to fill up to y=320 or low enough to y=-64 (1.18+ features), document that for pre-1.17 players. Let them know they won't see blocks outside the old y=0 to y=255 range. It's a minor note in your server info, but it prevents confusion. And if you want to give players a smooth first impression when they join your server, you might generate a custom server MOTD with your version info and server version. Something like "1.10-Latest Welcome!" signals that you're thinking about multi-version support. One last thing: if you're running a server where players design skins, you might want to remind newer players about the Minecraft skin creator for quick design. Not directly related to ViaBackwards, but keeping your player base happy is what this is all about. Ready to try ViaBackwards? Grab the source, read the full documentation, or open an issue on GitHub. Star the repo if you find it useful. It helps the maintainers and surfaces the project for other Minecraft players. Visit ViaVersion/ViaBackwards on GitHub ↗

---

### Why C2ME-Fabric Is the Chunk Optimization Mod to Know
URL: https://minecraft.how/blog/post/c2me-fabric-chunk-optimization
Published: 2026-04-21
Author: ice

"A Fabric mod designed to improve the chunk performance of Minecraft." RelativityMC/C2ME-fabric · github.com C2ME-fabric is a performance mod that speeds up chunk generation and loading by distributing the work across multiple CPU cores. If your Minecraft server slows down during chunk generation or your client lags when loading new terrain, this mod tackles those specific bottlenecks. What This Project Actually Does C2ME stands for Concurrent Chunk Management Engine, and that name explains the whole concept. Minecraft normally handles chunk generation, loading, and saving on a single thread, which wastes the power of modern CPUs. This mod breaks that work into tasks that can run in parallel, letting your processor handle multiple chunks at once. The README explains that it doesn't change how chunks are generated - vanilla world generation stays exactly the same. That mod just makes the process faster by threading it properly. For anyone who's watched their frame rate tank while exploring new terrain, this is the practical payoff. It's also MIT licensed with 761 GitHub stars, which tells you it's both free and battle-tested by the community. Why You'd Actually Use This Chunk lag is annoying. You're flying around in creative mode, or you spawn a bunch of new players on your server, and suddenly everything stutters while Minecraft generates terrain. Most players don't realize it's not their graphics settings or RAM - it's the single thread doing all the world generation work. C2ME fixes this specific problem. On a machine with multiple cores (which is basically every computer made in the last decade), the mod spreads that load around. The result? Smoother exploration, faster server startup times when new chunks need to load, and less jank when you're pushing your world boundaries. One tutorial shows players testing it on large pre-generation jobs - what used to take hours can drop to a fraction of that. The maintainers recommend pairing it with Lithium and Starlight for even better results, which are other optimization mods that handle different performance bottlenecks. If you're running a server or want survival mode to feel less laggy during chunk generation, this is worth trying. Getting It Installed C2ME requires Fabric, which is a lightweight modding platform. If you're already using Fabric mods, you probably have Fabric Loader installed. If not, grab it from fabricmc.net first. Downloads are available on both Modrinth and CurseForge. For Minecraft 1.21.11 (the latest Java release as of April 2026), you'd grab the version labeled for that release. Installation is straightforward - drop the.jar file into your mods folder. If you're on a server, the same process applies - add it to the server's mods directory and restart. Unlike some mods, C2ME doesn't need config tweaking to work, though you can customize it if you want to fine-tune chunk delivery rates. One note: backup your worlds first, which is just good practice with any mod. C2ME is stable, but it's always smart to have backups before experimenting. Key Features That Actually Matter Parallel chunk generation. This is the core feature. Multiple chunks get processed at the same time instead of one-at-a-time. On a 4-core processor, you might see a 2-3x speedup in world gen performance. On 8-cores or higher, it gets even more dramatic. GitHub project card for RelativityMC/C2ME-fabric Smooth chunk sending rate. The latest release (0.3.6.0) added a feature called smoothChunkSendingRate, which meters out chunk delivery to the client more evenly. And this helps frametime stability - instead of a massive dump of chunks causing a frame spike, they trickle in smoothly. Vanilla parity. C2ME doesn't alter world generation. Seeds produce the same worlds as vanilla Minecraft. And this matters if you're sharing seeds with friends or running a server where people expect standard survival generation. The mod says it "doesn't sacrifice vanilla functionality," and that's the real value - you get speed without weird surprises. Server task handling during shutdown. The mod properly manages shutdown tasks, so your server cleanly shuts down without chunk corruption or hanging processes. Datapack compatibility. World generation datapacks that work in vanilla also work with C2ME. Custom mod-made world generators usually work too, though some edge cases exist if mod authors made assumptions about single-threaded behavior. Common Issues and How to Avoid Them C2ME is stable, but a few things trip people up. First, some custom world generators don't expect parallel chunk processing. If you're using a mod-made dimension generator and it acts weird, that's the culprit. The Discord community (linked on GitHub) can help debug these, and the maintainers actively work with mod authors to fix compatibility issues. Second, the mod has only tested support for the latest Minecraft release and the latest snapshot. Older versions get long-term support for critical bugs, but new features don't backport. If you're on something like 1.19 or 1.20, check the releases page to see if a build exists. Actually, version support is worth clarifying - the project only maintains recent builds. If you're stuck on an older version, you might not find a release for it. Check the releases section and use the Minecraft version in the filename. One more gotcha: if you're already running a heavily modded setup, C2ME plays well with Lithium and Starlight (which the README recommends), but test your specific mod combination before deploying to a server with real players. How It Compares to Alternatives Lithium is another performance mod that optimizes entity AI, block updates, and other systems - but not chunk generation. Running both together is actually common because they fix different things. Starlight fixes lighting performance. Think of them as a toolkit where C2ME handles one specific bottleneck. Some server operators use Bukkit or Spigot plugins to pre-generate chunks, which is a different approach - you generate everything upfront before players join. C2ME instead makes generation faster as it happens. Both strategies work; C2ME is better if you want on-demand generation without the time investment. On the Java side, there's no direct equivalent that's as lightweight and straightforward. Some performance mods attempt to optimize chunk stuff, but C2ME has nearly 800 stars for a reason - it does one thing well. Making Your Server Setup Better If you're running a survival server or a large creative project, C2ME pairs well with some other tools. You might also want to set up consistent server properties - there's a server properties generator that helps you dial in settings like view distance and chunk loading. And if you're managing DNS for your server domain, the free Minecraft DNS tool can save you from paying for separate DNS hosting. The actual performance gains depend on your hardware. A machine with plenty of CPU cores sees much bigger improvements than a laptop with 2 cores. But even modest multi-core systems benefit from parallel chunk work. Where to go from here Read the source on GitHub (docs, examples, and the issue tracker) Browse open issues to see what the community is working on Check recent releases for the latest build or changelog

---