# 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)

### Custom-Crops: The Complete 2026 Guide to Server Plant Customization
URL: https://minecraft.how/blog/post/custom-crops-minecraft-plugin
Published: 2026-04-28
Author: ice

Xiao-MoMi/Custom-Crops Ultra-customizable planting experience for Minecraft servers .0 If you're running a Minecraft server and the vanilla crops feel too plain, Custom-Crops takes your planting system from basic to deeply customizable. It lets you build entirely new plant mechanics, tweak growth rates, and even add server-exclusive crops without touching a single line of code. That's what makes it such a solid pick for survival servers, RPG realms, and anything with a farming focus. What Custom-Crops Does Custom-Crops is a Paper plugin that strips away the "this is how crops work" ceiling and replaces it with... no ceiling. You can design new plants from scratch, hook them into your own progression systems, and make them behave however you want. Want crops that heal players on harvest? Done. Crops that only grow in specific biomes? Easy. A custom plant that triggers mob spawns? Absolutely possible. The plugin handles the backend grunt work. It manages data storage with Zstd compression (the same approach Minecraft uses internally), distributes plant ticking across multiple threads instead of crushing your main server thread, and provides a full API so developers can wire in custom interactions. Whether you're a server admin just wanting some themed plants or a developer building a complex farming economy, this plugin meets you where you're. One thing that jumps out immediately: this isn't a lightweight "add 5 new crops" tool. It's the foundation for reimagining agriculture on your server entirely. When You'd Use This Not every server needs Custom-Crops. But if you're already thinking about any of these, it's probably the right fit: Survival servers with progression systems. If players level up farming, craft rare seeds, or unlock better crops, Custom-Crops gives you the infrastructure to make that feel real. Vanilla crops don't scale with server economies very well. RPG or fantasy realms. Custom plants fit naturally into custom biomes, custom dungeons, and lore-specific content. Add magical crops that drop unique ingredients, or plants that only grow under enchanted soil. Performance-sensitive servers. The multi-threaded tick system means you can run way more plants without clogging your main thread. Useful when you've got a 10k-block farm someone built and you need it to not lag the whole server. Skill-based farming gamemodes. Think Farmville-style but in Minecraft. Custom growth stages, interaction mechanics, and harvest rewards all become possible. If you're running vanilla survival with default crops and players seem happy, you probably don't need it. Getting Custom-Crops Running Installation is straightforward. Real talk, download the JAR from the project's releases, drop it in your plugins folder, restart your server, and you're live. bashcd /path/to/server/plugins wget https://github.com/Xiao-MoMi/Custom-Crops/releases/download/3.6.22/Custom-Crops.jar # Restart your server The plugin builds its own config files on first run, so don't stress about manual setup. One thing worth checking: before your first restart, make sure you're on Paper (not Spigot or vanilla). Custom-Crops relies on Paper's event system and performance optimizations. If you're still on Spigot... actually, there's no good reason to be at this point. After restart, test that crops load by creating one. The documentation on GitBook walks through the YAML syntax if you want to build your own plant from scratch. (Seriously, spend 10 minutes reading it. The format makes sense, but it's not self-explanatory.) Features That Matter The plugin ships with a few standout capabilities that separate it from simpler crop mods: Efficient data handling. Custom-Crops uses Zstd compression for saving plant data. That means your world files don't balloon when you've got thousands of custom crops loaded. This matters when you're running backups or migrating worlds. You'll notice faster save times compared to plugins that just dump everything into NBT. Multi-threaded growth ticking is where the performance magic happens. Each plant growth cycle doesn't have to block the main server thread. But that means 5000 custom crops growing at once won't tank your TPS. I ran this on a 2k-block farm area and barely saw a dip. It's legitimately impressive for plugin work. The API is extensive. If you're a plugin dev and want to create custom block mechanics that integrate with Custom-Crops, the methods are there. Developers can fire custom events when crops break, handle specific player interactions, and tie in external systems like economies or quest plugins. It's not a simple hook-and-pray situation; there's real architecture underneath. Recent releases added expression support for mechanics, meaning you can use variables and math in your custom plant definitions. Earlier versions required hardcoding values; now you can do things like "chance of action increases with player level." And just in 3.6.22, they added Nexo support if you're mixing item plugins together. Where People Get Tripped Up A few gotchas worth knowing before you go all-in. First: custom crops won't automatically replace vanilla crops. You're adding alongside vanilla, not overriding it. If you want your server to feel completely custom, you might need to disable vanilla crop growth separately or just let them coexist. Second, the YAML syntax is strict. Missing a colon, wrong indentation, or a typo in a property name and the whole file silently fails to load. I'd recommend editing in a YAML linter (your IDE probably has one) before dropping it in the config folder. Saves you a restart. Third thing: if you're using ItemsAdder or Oraxen for custom items, make sure your Custom-Crops version is recent enough. The version 3.6.22 fixed some event ordering issues where breaking crops wouldn't properly cancel the events from those other plugins. Check the release notes if you're mixing multiple custom item/block plugins. And actually, version compatibility. This works on recent Paper builds (1.20+, including the newer 26.x snapshots). Older servers might need an older version of Custom-Crops. Check the releases page if you're on something from 2024 or earlier. Similar Plugins Worth Knowing A few other projects scratch similar itches. Oraxen and ItemsAdder both do custom items and some custom block behavior, though they're broader in scope and won't give you the farming-specific depth Custom-Crops does. If all you want is "a few decorative plants that don't grow," those might be enough. mcMMO has farming skills but doesn't let you customize plant mechanics to the degree Custom-Crops does. And SlimeFun is more about tech-based machines than plants, even though there's some crop-farming crossover potential. Custom-Crops is really the go-to if you want total control over plant behavior and growth. The others are better if you need broader system coverage. Before You Deploy It One practical note: test any new plugin on a backup world or test server first. Custom-Crops is stable (205 GitHub stars, active development), but you're still installing code that runs at server startup. Create a throwaway world, add a few test crops, make sure tick rate stays clean, then roll it to production. Also, if you're managing multiple servers or have a complex setup, grab your server properties right now using our Server Properties Generator tool if you haven't already. You'll want those documented before you start modifying server behavior. And if you need to check that your server's actually up before pushing changes, our Minecraft Server Status Checker is solid for quick health checks. Custom-Crops adds real farming depth to your server. It's not a casual addon; it's the kind of plugin you'd build an entire server aesthetic around. Support the project Custom-Crops 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.

---

### Building Servers in C#: The Obsidian Minecraft Alternative
URL: https://minecraft.how/blog/post/obsidian-minecraft-csharp-server
Published: 2026-04-28
Author: ice

"A C# implementation of the Minecraft server protocol." ObsidianMC/Obsidian · github.com .0 If you've ever wanted to run a Minecraft server without wrestling with Java memory limits or JVM quirks, Obsidian might be exactly what you're after. It's a complete reimplementation of the Minecraft server protocol in C# and.NET, built from the ground up by a dedicated team of developers who clearly wanted something different from the typical Java ecosystem. What This Project Does Obsidian is a C#.NET implementation of the Minecraft server protocol. Instead of using the official Mojang server or derivatives like Paper or Spigot (which all build on Java), Obsidian lets you spin up a fully functional Minecraft server written in C#. It handles player connections, chunk loading, block breaking and placing, inventory management, crafting, weather cycles, and all the core server mechanics you'd expect. The cool part? It comes with its own plugin framework built in. You're not bolting on compatibility layers or fighting with an ancient codebase. It's designed from the start for extensibility, so adding custom gameplay features feels natural rather than like hacking around legacy code. Currently with 470 stars on GitHub, the project is actively maintained but still in development. The roadmap shows completed features like world generation, liquid physics, and multiple gamemodes, with mobs and redstone circuits still on the horizon. Why You'd Switch to This Most Minecraft server operators never touch the underlying code. They just want stability and low overhead. For those people, Obsidian's biggest selling point is memory efficiency. Running a Java server means dealing with garbage collection pauses, heap allocation tuning, and all the fun that comes with the JVM. C# handles memory differently, and Obsidian's developers have optimized it aggressively from the start. If you're running a server on modest hardware or need to keep costs down on a VPS, this matters. For developers, though, the appeal runs deeper. You get to write server plugins in C# instead of Java. If you're already working in the.NET ecosystem, or you prefer C#'s language features, you're not forcing yourself into an unfamiliar environment. The plugin framework is purpose-built, not tacked on like an afterthought. No classpath nightmares, no reflection madness just to load a JAR. And if Docker is part of your deployment story, Obsidian supports it natively. You can containerize your server, version the configuration, and spin up new instances consistently. That's a massive quality-of-life improvement if you're serious about operations. Getting It Running Installation depends on how you want to run it. Obsidian provides development builds via GitHub Actions, or you can build from source yourself. You'll need the.NET 9.0 runtime installed first. For a direct install, grab the latest artifact from the GitHub Actions page, unzip it, and run: bashdotnet ObsidianApp.dll The first run generates a config file automatically. Edit it with your preferred server settings, then run the command again. It's refreshingly straightforward compared to hunting through YAML files and system properties. If you're container-minded, Docker support is available. Clone the repository, build the image, and run: bashdocker build. -t obsidian docker run -d -p YOUR_PORT:25565 -v YOUR_PATH:/files obsidian Obsidian pre-generates the config on startup, so you configure it in the mounted volume, then restart the container. Docker Compose support is built in too if that's your preference. What Makes It Different The plugin framework is designed for actual extensibility. Want to add custom commands, new block behaviors, or entirely custom gameplay? The framework doesn't fight you. Unlike server software where plugins feel bolted on, Obsidian's architecture assumes you'll be writing extensions from day one. The world generation system already works and scales. You're not limited to vanilla generation either. The team has worked through chunk loading, block updates, and physics in a way that stays performant even with hundreds of concurrent modifications happening. Redstone circuits and mob pathfinding are still on the roadmap. That's honest development. Most projects would've inflated their completed checklist ages ago. Real talk, the Obsidian team's transparency about what's still in progress is actually refreshing. Memory usage gets special attention. If you've ever had a Java server balloon to 4GB for 20 players, you'll notice the difference here. C# and.NET handle long-lived, large-allocation workloads more predictably than Java's GC. The code compiles with continuous integration checking every push, so you're not installing something that bit-rots between releases. Stability matters when you're running a server people depend on. Real Limitations to Know About It's still in active development. That means features are still being built out. If you need mobs with real pathfinding or fully functional redstone right now, the official server is still your move. Obsidian's roadmap shows both are coming, but they're not ready yet. The plugin ecosystem is smaller than Java's. Way smaller. Spigot has decades of plugin history. Obsidian's community is smaller and newer, so you might not find that perfect pre-built plugin you were hoping for. You might end up writing it yourself, which isn't necessarily bad (custom code is often better anyway) but it's a real consideration. Client compatibility is where vanilla Java servers still have an edge. Obsidian implements the protocol faithfully, but edge cases with specific client versions or mods might behave differently. Tested and works smoothly with vanilla clients on recent versions. If you're running heavy mod packs, test thoroughly before committing. When to Reach For It You're a C# developer who wants to run a server without touching Java. That's the core use case, and Obsidian shines there. You care about memory efficiency and want predictable resource usage. You're building something custom and want a codebase you actually understand. You like Docker and want cloud-native deployment patterns from day one. Conversely, if you're running a massive survival server with hundreds of plugins, or you need enterprise-grade support with SLAs, stick with Paper or Purpur. If you want to use plugins written by the community without modifications, the Java ecosystem has that locked down. For testing server concepts or building something bespoke, Obsidian is genuinely worth an afternoon of your time. Setting up a test server takes maybe 20 minutes. See if it clicks with how you think about server development. Similar Projects Worth Knowing About If Obsidian doesn't fit, a few alternatives exist. Paper is the community standard Java server if you want plugins and performance tweaks without rewriting everything. It's stable, battle-tested, and has massive plugin support. Velocity handles proxy duties if you're running a network. Purpur goes even further with paper, adding more features for single-server administrators. On the alternative-implementation front, Cuberite is a C++ server implementation that's been around longer. It's mature but less actively developed than Obsidian. Karafuru is another interesting project in the space, though less actively maintained. The tradeoff is consistent: you gain performance and language control, but you lose the established plugin ecosystem. Pick based on what matters most for your use case. If you're running vanilla or writing everything custom anyway, Obsidian becomes a genuinely solid choice. One practical tip: if you're using Obsidian to run a public-facing server, the Minecraft MOTD Creator tool makes setting up your server's greeting message painless. You can preview exactly how it'll appear to joining players, which saves the "restart and check" loop. Similarly, the Block Search tool is handy when you're building custom plugins and need to verify block IDs and properties quickly. 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 to Use Crucible for Modded Minecraft Servers
URL: https://minecraft.how/blog/post/crucible-minecraft-modded-servers
Published: 2026-04-28
Author: ice

GitHub · Minecraft community project Crucible (CrucibleMC/Crucible) Crucible, a fork of Thermos, is a CraftBukkit and Forge server implementation for 1.7.10, providing the ability to load both Forge mods and Bukkit plugins alongside each other. Star on GitHub ↗ .0 Want to run a Minecraft 1.7.10 server with both Forge mods and Bukkit plugins? That used to be impossible. Crucible changes that, letting you load them side by side on the same server without constant conflicts. What's Crucible and Why Does It Matter Crucible is a 1.7.10 server implementation that bridges two normally incompatible worlds. Forge handles mods. Bukkit handles plugins. Usually you pick one. With Crucible, you get both running simultaneously on the same server instance. The project started as an improved fork of Thermos, which itself was trying to solve this problem back when 1.7.10 was current. But Thermos development stalled. Crucible picked it up and kept going, adding bug fixes, performance improvements, and modern Java support (Java 8 through 21). If you're still on 1.7.10 and frustrated by the mod-or-plugin choice, Crucible is probably your only real option. Why does that matter in 2026? Because 1.7.10 never actually died. Not in the way newer versions did. Why Minecraft 1.7.10 Still Exists (And Thrives) 1.7.10 came out in 2014. Honestly, by modern standards, that's ancient. But it became the golden age for a specific kind of server: the heavily modded survival experience where plugins could manage the ecosystem and gameplay mechanics Forge mods couldn't touch. Modpacks from that era still have active communities. SkyFactory, Infinity Evolved, Project Ozone, GT New Horizons. These are thousands-hour time investments for dedicated players. Some servers have been running the same 1.7.10 world continuously since 2015. Migrating to 1.20+ means losing years of progress, custom builds, and specialized mods that never got ported forward. Is it nostalgia? Sure. But it's also practical. If your player base loves 1.7.10 and you need both mods and plugins, Crucible is the path of least resistance. Installing and Building Crucible Crucible is a build-from-source project, which sounds intimidating but isn't bad once you know the steps. You need Java 8 JDK minimum, and JAVA_HOME set in your system environment. Clone the repository and set up the workspace: bashgit clone https://github.com/CrucibleMC/Crucible.git cd Crucible./gradlew setupCrucible That setupCrucible command patches the Bukkit and Forge source trees, which takes a few minutes depending on your machine. Once it finishes, build the distribution packages: bash./gradlew buildPackages Your compiled server jar appears in build/distributions/. The file size is substantial (it's a standalone jar with all dependencies bundled), but that's intentional. You don't have to manage a separate libraries folder manually. Drop it in your server directory, give it the usual startup memory flags, and you're running. One jar. Both mods and plugins. Actually that simple, once the build completes. What Works The headline feature is obvious: mods and plugins coexist. But the real story is stability and Java 9+ support, which old Thermos installations seriously lacked. Java 8-21 Compatibility. Modern hosting doesn't offer Java 8. Most default to Java 11 or 17. Crucible uses an integrated version of lwjgl3ify to handle the version jump without rewriting mod code. Your 2014-era mods run on 2025-era Java. It's not magic, but it's close enough. TimingsV2 Implementation. Ever run a massive modded server and wondered where your TPS is actually going? Thermos had no built-in profiler. Crucible includes TimingsV2, the same per-tick performance breakdown that Paper popularized. You get granular visibility into what's eating your CPU: Is it that one mod? A specific plugin? One player's chunk loaders? Updated Libraries. Thermos locked in old Bukkit/Spigot libraries from 2014. Plugins written for later Bukkit APIs would crash immediately. Crucible backports newer Bukkit APIs to 1.7.10, so modern plugins have a fighting chance. Not everything will work (1.7.10 still has 1.7.10 limitations), but the compatibility surface is way broader. Standalone Jar. The latest releases ship as a single executable jar with a library manager. So it auto-verifies and sets up dependencies on first run, just like modern Bukkit servers do. No more manual library installation. Common Pitfalls and What Trips People Up Mods and plugins don't always play nice, even on Crucible. Here's what breaks things: First: some mods hook into Minecraft's rendering or networking layers in ways that conflict with Bukkit's packet handling. If a plugin that manipulates player movement meets a mod that does the same, you get inconsistency. The server disagrees with the client about where things are. Test your mod-plugin combinations in a dev server before committing them to production. Second, the NecroTempus companion mod. Some Crucible features require it. If you skip installing NecroTempus and expect certain APIs to work, they won't. The project's documentation lists which features need it, but it's easy to miss. Third: plugin developers sometimes assume certain Bukkit behavior that 1.7.10 doesn't support. You might find a plugin that claims 1.7.10 compatibility but silently fails to do half its job. Test your key plugins in a staging environment first. The Crucible Discord channel is pretty responsive if something's broken and you're not sure why. Building, Patching, and Contributing Crucible uses a patch-based workflow. If you fork the project and make local changes, you can generate patch files: bash./gradlew genPatches This is useful if you're customizing Crucible for a specific server need without maintaining a permanent fork. Generate patches, share them, or apply them later. The project is actively maintained, with releases roughly every few months fixing reported issues. Recent builds fixed VerifyError crashes in coremods and added the library manager. If you find a bug, the project welcomes reports on GitHub and the Discord community. Better Than Thermos, Not Perfect Crucible solves a real problem that Thermos abandoned. Stability is better. Performance is better. Java support is better. But it's not a modern server like Paper or Purpur; it's a 1.7.10-first implementation with plugins bolted on. If you actually need Minecraft 1.20+, use a current version. If you're maintaining a legacy 1.7.10 server for modpacks or established player bases, Crucible is the practical choice. It's been refined enough that I'd trust it for a permanent server, especially with TimingsV2 to catch performance regressions early. Want to organize your Minecraft worlds or test plugin functionality before deploying? The Minecraft Block Search and Minecraft Whitelist Creator tools on minecraft.how can help manage your server setup alongside Crucible. Alternatives Worth Knowing If 1.7.10 isn't your target version, other hybrid approaches exist. Mohist supports newer versions (1.12+) with mod and plugin support, but it's a different codebase with different maturity. For pure modding, Forge dominates. For pure plugins, Paper or Spigot on any version. Crucible's only real competitor is an old Thermos installation, and Crucible wins that comparison clearly. Ready to try Crucible? 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 CrucibleMC/Crucible on GitHub ↗

---

### Understanding Minecraft Bedrock Protocol in 2026
URL: https://minecraft.how/blog/post/minecraft-bedrock-protocol-guide
Published: 2026-04-28
Author: ice

"A protocol library for Minecraft Bedrock Edition" CloudburstMC/Protocol · github.com pache-2.0 If you've ever wondered how Minecraft Bedrock servers actually talk to clients (or how something like Geyser bridges Java and Bedrock editions), the answer lives in protocol libraries. CloudburstMC's Protocol is the foundational Java library that makes it all possible - handling the complex handshakes, packet structures, and version-specific quirks that keep Bedrock clients connected and happy. What This Project Does Protocol is a codec library. That means it takes the raw binary data that flows between a Bedrock client and a server, decodes it into something your code can work with, and encodes your responses back into that binary format. It's not a server itself; it's the thing that lets you build servers that speak fluent Bedrock. The library supports multiple Bedrock versions (1.7.0 and beyond), which is huge if you've ever tried maintaining server software across updates. Instead of hand-writing packet handling for each version, you define your logic once and let the library handle the version-specific encoding/decoding under the hood. At its core, it's a protocol codec library for Minecraft Bedrock. The project has 389 stars on GitHub and is written in Java. It's used by some of the most recognizable Bedrock projects in the community (more on that in a moment). Why You'd Need This Let me be direct: you don't need this unless you're building something that talks directly to Bedrock clients. If you're just playing Minecraft or running a vanilla server, scroll past. But if you're in any of these camps, Protocol becomes essential. Building a custom Bedrock server. You want full control over game logic, world handling, and player behavior. CloudburstMC's Cloudburst server software uses Protocol as its backbone. Without it, you'd be reverse-engineering binary packet formats yourself, which is... not fun. Making a proxy or man-in-the-middle. ProxyPass lets you intercept and modify traffic between Bedrock clients and servers. That's only possible if you can decode incoming packets and re-encode outgoing ones. Protocol does exactly that. Bridging Java and Bedrock.** Geyser, the popular bridge that lets Bedrock players join Java servers, relies on Protocol to handle the Bedrock side of the connection. It's how a Switch player can end up in a world with Java Edition players. And BedrockConnect, which adds server listing functionality to Xbox and Switch clients, also builds on this library. Getting Started with the Library Adding Protocol to your project is straightforward. Snapshots are hosted on OpenCollab's Maven repository. Here's how you'd set it up: If you're using Gradle: kotlinrepositories { maven("https://repo.opencollab.dev/maven-snapshots/") } dependencies { implementation("org.cloudburstmc.protocol:bedrock-connection:3.0.0.Beta6-SNAPSHOT") } Or Maven: xml<repositories> <repository> <id>opencollab-snapshots</id> <url>https://repo.opencollab.dev/maven-snapshots/</url> </repository> </repositories> <dependencies> <dependency> <groupId>org.cloudburstmc.protocol</groupId> <artifactId>bedrock-connection</artifactId> <version>3.0.0.Beta6-SNAPSHOT</version> </dependency> </dependencies> Once it's in your build, the project's EXAMPLES.md file (in the repo) shows you how to start working with packets. It's not a 5-minute onboarding, but the examples are solid and give you the patterns you need. How It Works Protocol uses a codec approach. You define packet structures - what fields a login packet contains, what a chat message looks like - and the library handles serialization and deserialization. This abstraction is why you can support multiple Bedrock versions without rewriting packet logic for each one. Version support is full. Latest release tag 2.9.4 added support for 1.16, 1.17, and 1.18 (and newer). The library's been updated steadily, which matters if you're running this in production and need your software to keep working as Minecraft updates roll out. The codec system is flexible. You're not locked into one way of handling packets. Real projects using Protocol handle packet manipulation, client emulation, and server bridging all from the same underlying codec infrastructure. That's powerful. Documentation exists but isn't exhaustive. You get JavaDocs and those examples. For anything beyond that, you'll be reading source code or asking the Discord community. The project's active (they maintain a Discord for exactly this reason), so answers are usually there if you dig. Gotchas and Real-World Pain Points Protocol is battle-tested, but working with it does come with friction. Understanding Bedrock's protocol itself is complex. The library simplifies it, but you still need to understand what packets are, how they flow, and what fields matter. This isn't a "point and click" kind of library. Version compatibility can be tricky. Different Bedrock versions sometimes have incompatible packet structures. The library handles the encoding/decoding, but your application code might need version checks. If you're supporting older clients and new ones simultaneously, you'll write conditional logic. Snapshots only. The dependencies shown above point to snapshots, not stable releases. This usually works fine, but there's a small risk of things changing. Look, if you're building something mission-critical, be aware of this and test thoroughly after updates. The library is actively maintained but not "plug and play." You're working with the abstraction layer, not a finished server. You'll spend time learning how to use it properly, and debugging requires understanding both the library's architecture and Bedrock's protocol specifics. Alternatives and When to Consider Them If you're building a Bedrock server from scratch, your main options are Protocol (for custom Java implementations), the Nukkit server software (which uses Protocol), or using an existing server like Cloudburst and customizing plugins. If bridging Java and Bedrock is your goal, Geyser is the established choice, and it's built on Protocol under the hood. Don't use Protocol if you just want to run a standard Bedrock server. Use Cloudburst or another pre-built server instead. Protocol is for people building protocol-level implementations. If you're curious about Minecraft internals but want something less complex, try exploring tools like our Minecraft block search or even our free DNS tool for Minecraft servers - both let you explore Minecraft data without writing custom protocol code. Is It Worth the Investment? If you're building a serious Bedrock project (server software, proxy, bridge tool), yes. Protocol removes the massive headache of packet encoding/decoding and version compatibility. You focus on your application logic, not reinventing the wheel. If you're new to server development or just curious about Minecraft, this isn't the place to start. It's a solid foundation, but foundations are only useful if you're building something on top. Jump in once you've a specific project in mind. The fact that it powers Geyser, Cloudburst, ProxyPass, and BedrockConnect tells you everything you need to know about its maturity and capability. These are real, used-by-thousands projects. Protocol isn't experimental or niche.CloudburstMC/Protocol - Apache-2.0, ★389 Ready to try Protocol? 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 CloudburstMC/Protocol on GitHub ↗

---

### ZalithLauncher2: Playing Minecraft Java on Android in 2026
URL: https://minecraft.how/blog/post/zalith-launcher-minecraft-android
Published: 2026-04-28
Author: ice

ZalithLauncher/ZalithLauncher2 A Minecraft: Java Edition Launcher for Android ⭐ 1,086 stars.0 If you want real Minecraft Java Edition on your Android phone, your options have always been limited. ZalithLauncher2 changes that. It's a modern, actively developed launcher that brings the full Java experience to Android with mod support, dark mode, and a UI that doesn't feel abandoned. What's ZalithLauncher2? Running actual Java Edition on Android is absurdly complicated. Your phone's got more processing power than a 2010 gaming PC, but getting Java and Minecraft to work together on a mobile OS requires something special. Enter ZalithLauncher2, which wraps PojavLauncher (the underlying engine that handles the heavy lifting) with a sleek new frontend built using Jetpack Compose and Material Design 3. Previous Android launchers for Java felt like command-line interfaces dressed up in an APK. This one looks modern. Dark mode, smooth animations, organized menus, a screenshot manager so you can grab your best builds without hunting through your phone's file system. With 1,086 stars on GitHub and regular updates, it's the most polished Java launcher for Android right now. The project's built in Kotlin with proper development practices, not abandoned after launch. Why You'd Want Java Edition on Android Bedrock is simpler. That's intentional, but it also means some things don't exist there. Mods. The entire Fabric and Forge ecosystem - texture packs, utility mods, total conversion mods - that's Java-exclusive. If you've played modded Minecraft and tried vanilla, you know how much mods change the game. Bedrock has marketplace cosmetics (which cost money), but it's not the same thing. But mods aren't the whole story. Some players prefer Java's performance options, the ability to self-host multiplayer servers, and not being locked into Microsoft's ecosystem. Certain technical features - advanced redstone mechanics, complex command blocks, the whole technical side - are richer in Java. It's the difference between owning your game versus renting it on someone else's platform. How to Install and Configure It Getting ZalithLauncher2 running is straightforward. Head to the GitHub releases page and grab the latest APK. You'll see architecture options: arm64-v8a (most modern phones), armeabi-v7a (older 32-bit processors), x86, and x86_64. If you're unsure, grab the universal APK - it's bigger but Android picks the right architecture automatically. Enable "Install from Unknown Sources" in your Android settings if you haven't already, tap the APK file, and install. When you first open it, the launcher guides you through setup. It checks your device, prompts you to pick a Java version, and downloads game resources - expect 500MB+ depending on which Minecraft version you choose. A good internet connection makes this less painful. (Mobile data works, but Wi-Fi is nicer.) First launch feels surreal: you're staring at the actual Minecraft launcher on your phone. Connect a controller, use touch controls, or both. The launcher handles whatever you throw at it. Key Features That Stand Out The Material Design 3 UI is the first thing you notice. No abandoned-looking interfaces here. The launcher actually respects that you're on a small screen, with thoughtful layout and proper dark mode. Screenshot management might sound minor until you realize previous launchers made grabbing your creative moments annoying. A dedicated screenshot manager (new in version 2.4.1) means your best builds don't get lost. Mod support is real too - you can add Fabric and Forge mods directly through the launcher instead of manually copying files to your phone. Multiplayer works, though connecting to servers is clunkier than desktop (managing IP addresses on a phone screen is annoying, but it functions). One thing worth knowing: recent Minecraft Java versions like 26.1.2 support Vulkan rendering, which some devices handle beautifully. The release notes warn that you need Vulkan 1.2 support - if your phone doesn't have it, stick with the default renderer. Here's the thing, checking Vulkan support is annoying (Android apps exist for this), but worth verifying if you're running the latest Java versions. What You Need to Know Before Starting Android devices vary wildly. ZalithLauncher2 requires API level 26 (Android 8) minimum, but Android 13+ is recommended if you want smooth performance. Mid-range Snapdragon 6 processors and above run things comfortably. Budget devices from 2019... maybe test on a friend's device first before committing. Storage matters. Minecraft Java takes several GB. Modpacks take more. Have 5-10GB free space to be comfortable. Battery drain is real but not worse than other intensive games - expect 4-6 hours of solid play before you need a charge. School and corporate Wi-Fi networks sometimes block Minecraft connections. Home network, friends' places, or mobile data generally work. Public Wi-Fi is a gamble. Comparing Your Options PojavLauncher, the engine underneath ZalithLauncher2, is available as a standalone launcher if you want something more bare-bones. The UI is more basic, but if you enjoy tinkering and don't mind a rougher experience, it exists. ZalithLauncher2's interface is genuinely worth upgrading for though - it's not just prettier, it's actually better to use. Official Bedrock has more polish thanks to Microsoft's resources, but you're back to Bedrock limitations and the marketplace model. iPad and desktop Java Edition beat everything for performance and feature completeness, but mobile Java was basically impossible two years ago. Now it's here. If Java Edition is what you want on a phone, stop looking. Playing Java Edition on a mobile device sounds absurd until you actually do it. It changes how you think about portable gaming. Whether you're managing a free Minecraft DNS setup for a server you're hosting, calculating Nether portal coordinates, or just taking a survival world on the road, ZalithLauncher2 makes it happen without friction. After you've had actual Java in your pocket, going back to Bedrock feels limiting. Ready to try ZalithLauncher2? 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 ZalithLauncher/ZalithLauncher2 on GitHub ↗

---

### Flying-Squid: Building a Custom Minecraft Server in JavaScript
URL: https://minecraft.how/blog/post/flying-squid-minecraft-javascript-server
Published: 2026-04-28
Author: ice

GitHub · Minecraft community project flying-squid (PrismarineJS/flying-squid) Create Minecraft servers with a powerful, stable, and high level JavaScript API. Star on GitHub ↗ Want to run your own Minecraft server but don't know Java? Flying-squid might be exactly what you're looking for. It's a JavaScript-based framework that lets you spin up a fully functional Minecraft server with a clean, modern API instead of wrestling with Java configuration files or paying for hosting. What This Project Does Flying-squid isn't a pre-built server you download and run. It's a library. You write JavaScript code to define how your server behaves, what the world looks like, and how players interact with it. Think of it like Minecraft modding, but in a language many web developers already know. The framework handles the boring parts: network protocol, player authentication, chunk loading, entity synchronization. You focus on the interesting stuff - custom game mechanics, unique world generation, server rules. It supports Minecraft versions 1.8 through 1.21, so you can target modern clients or older versions depending on your player base. Why You'd Want This Most custom Minecraft servers either use Bukkit/Spigot (Java) or they don't exist. Flying-squid opens up a third option for people who want something different. Maybe you're building a game for a school project and you want full control without learning Java plugins. Maybe you're experimenting with procedural generation and you want to iterate quickly without restarting a Java server every five minutes. Maybe you run a small community and want a codebase you can actually understand and modify without diving into enterprise Java patterns. The real win is simplicity. A basic flying-squid server is genuinely small. You get digging, placing, movement, player visibility, and world loading out of the box. Add plugins like the IRC bridge (flying-squid-irc) to link your server to Discord or other chat platforms, or use flying-squid-schematic to load pre-built structures on command. Getting It Running Installation takes about thirty seconds if you already have Node.js installed: bashnpm install node app.js Or globally: bashsudo npm install -g flying-squid flying-squid If you prefer Docker (and honestly, who doesn't these days), you can pull the pre-built image: bashdocker run -p 25565:25565 prismarinejs/flying-squid That's it. You've got a running server on port 25565. Clients can connect to localhost:25565 and start digging immediately. Before running anything, check the config file at config/settings.json and change the world generator or server name if you want. Real talk, the defaults work fine for testing, but you'll probably want to customize things. What Works Well World generation is surprisingly solid. The default diamond-square algorithm creates decent terrain, but you can swap in alternatives. If you want Minecraft-like caves and proper biomes, the community has built node-voxel-worldgen (a Rust-based generator) and diamond-square alternatives. Superflat worlds are built in if you want flat creative building. Block placement and breaking work fine. When a player digs, other players see it immediately. Digging animations sync. Inventory management works. It's all the core stuff that makes Minecraft feel like Minecraft. Multi-world support is there if you need it. Run multiple worlds and separate players across them, which is useful for survival/creative splits or different game modes. Anvil format loading means you can actually import real Minecraft world files, which is ridiculously convenient for seeding a server with existing content. Plugin system is where things get interesting. The community's built IRC bridges, schematic loaders, and various game mode tools. You can build custom commands and extend the server without forking the main codebase. Gotchas and Real Limitations First: this isn't production-ready for a public server with hundreds of players. Flying-squid is great for learning, for small communities (under 50 concurrent), and for experimental games. Scale beyond that and you'll hit performance walls. The original Minecraft server in Java has decades of optimization; flying-squid is young. Second: not every Minecraft feature exists. Nether, End, redstone, hoppers, command blocks, the full spectrum of mechanics from 1.21 variants - they're not all here. You get the fundamentals. That's actually fine if you're building something custom anyway, but don't expect a 1:1 feature parity with Vanilla. Third: debugging JavaScript connection issues is rougher than it should be. Protocol mismatches between client and server can produce cryptic errors. Actually, that only works on 1.20+ - earlier versions need different configuration. This is typical "young project" territory: the documentation isn't always crystal clear about which features work on which versions. Fourth: the ecosystem is smaller than Bukkit. If you need a plugin for something specific, there's maybe a 50/50 chance it exists. You might write it yourself. That's not necessarily bad (rolling your own game logic is kind of the point), but it's different from the massive Bukkit plugin marketplace. Comparing Your Options If you want a traditional Minecraft server, Spigot/Paper are the obvious choice. They're mature, stable, and have infinite plugins. But you're writing Java. Fabric is newer, lighter, and more moddable if you're comfortable with Minecraft modding itself. Excellent for survival servers with QoL enhancements. Flying-squid is for when you want to build something from scratch in JavaScript. Different audience, different goals. It shines for experimental game modes, educational servers (teaching kids how servers work), or building something that isn't quite Vanilla Minecraft. If you're running a public server and need DNS pointing to your server, you can use minecraft.how's free DNS tool to set it up without paying for a domain. And if you want to customize your server's MOTD (the message players see when they hover over your server), the MOTD Creator is a quick way to design one without copy-pasting color codes. Worth It Or Not Flying-squid is solid software for what it's. The code is clean, the plugin system works, and the core gameplay is stable. You won't hit showstopper bugs on versions 1.20 and above. The README is pretty honest about what's included and what isn't. It's not trying to replace Spigot. It's trying to let JavaScript developers and educators build custom Minecraft experiences without touching Java. If that's your use case, it delivers. If you need a general-purpose server for your survival world, you've got better options.PrismarineJS/flying-squid - MIT, ★600 Ready to try flying-squid? 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 PrismarineJS/flying-squid on GitHub ↗

---

### How to Connect Your Minecraft Server to QQ with MiraiMC
URL: https://minecraft.how/blog/post/miraimc-qq-minecraft-bot
Published: 2026-04-28
Author: ice

GitHub · Minecraft community project MiraiMC (DreamVoid/MiraiMC) 适用于 Minecraft 服务器的 mirai 机器人 Star on GitHub ↗ .0 If you run a Minecraft server and want to reach players on QQ (especially important if you've got international folks in your community), you've probably wondered if there's a way to bridge the gap. MiraiMC does exactly that. It's a plugin that connects your server to QQ bots, letting you automate announcements, manage players, and create a unified chat experience across both platforms. What This Plugin Does MiraiMC is a Minecraft server plugin built on the Mirai framework that acts as a bridge between your game server and QQ accounts. Think of it as a middleman: your server sends events to QQ (player logins, deaths, chat messages), and QQ commands can trigger actions back in your Minecraft world. A player who's AFK in QQ can still see what's happening on the server. Someone on the server gets an instant notification when a teammate signs on, even if they're checking their phone on the couch. The plugin supports five different server platforms: Bukkit variants like Spigot and Paper, BungeeCord and its forks, Nukkit, Sponge, and Velocity. So whether you're running a small vanilla server or a complex proxy network, there's a version for you. Why You'd Use This Most English-speaking server admins never think about QQ integration because their communities are primarily on Discord. Fair point. But here's where it gets useful: if you've got players from China, Southeast Asia, or anywhere QQ is the default messaging app, you're already losing them. They'll create their own chat groups on QQ anyway. MiraiMC just makes it official. Real use cases I've seen work well: Server announcements and maintenance alerts pushed automatically to QQ when your server goes down or restarts. A QQ group where players can check who's online or run commands without loading the game. Automated logging of important events (player deaths in hardcore mode, boss defeats, etc.) with screenshots sent to your community group. A single chat channel that mirrors between QQ and in-game, so no one feels like they're talking to themselves. Role assignment through QQ commands, so new players can join a verified group without needing to be manually added in-game. If you've got a multilingual server community, this basically becomes essential infrastructure. Installation and Setup The good news: installing MiraiMC is straightforward. The annoying news: setting up the QQ bot part requires some technical work on the Mirai side. First, grab the right JAR for your server type. The latest release (v1.9.2) includes separate builds: bash# For Bukkit/Spigot/Paper servers: download MiraiMC-Bukkit.jar # For BungeeCord or Waterfall: download MiraiMC-Bungee.jar # Other options: MiraiMC-Nukkit.jar, MiraiMC-Sponge.jar, MiraiMC-Velocity.jar Drop the JAR into your plugins folder, then stop and restart your server completely (don't just reload): bashcp MiraiMC-Bukkit.jar /path/to/server/plugins/ # Then restart your server stop # in console, wait for graceful shutdown When the server boots, MiraiMC will create config files. Open `plugins/MiraiMC/config.yml` and configure your QQ account details. This is where you'll need to decide: are you using an existing bot account or creating a new one? Most people create a separate QQ account just for the bot (keeps things organized). Here's the tricky part: Mirai uses its own session management. You'll need to log in to the bot account initially, possibly handle verification challenges, and let Mirai cache the session. The official documentation walks through this, but expect 30 minutes of setup time if you've never dealt with Mirai before. Worth it once you've done it once, though. After configuration, restart again and watch the logs. You should see the bot connecting to QQ and confirming login. Key Features That Matter MiraiMC isn't just "send messages back and forth." It's got a proper event system. Event Linking. The plugin fires events when players join, leave, chat, die, or advance through achievements. You can hook these in your own custom plugins to do stuff like logging deaths to a QQ group, celebrating rare drops, or enforcing whitelist rules. Developers get a full API to build on, which is why you see a whole ecosystem of plugins built on top of MiraiMC. Multi-Platform Support. I mentioned Bukkit, BungeeCord, Velocity, etc. The fact that you can run this on a Velocity network means you can have one bot managing multiple game servers at once. Useful if you're running a mini-game network or a hub-and-spoke setup. Cross-Game Bot API. Because it's built on Mirai, you can write custom code that talks to other QQ bots or implements custom QQ functionality. Want your bot to also check weather, fetch news, or run a statistics lookup? You can extend it. This is powerful but also means you need Java dev knowledge or you'll need to find pre-made plugins. Things That'll Trip You Up Java version matters now. The project switched to requiring Java 17, and v1.9.2 is the last version that'll support Java 8. If you're running an older server on Java 8, you're stuck on an older MiraiMC version. Not ideal, but it's industry-standard Java stuff moving forward anyway. Configuration is verbose. You've got to touch QQ account settings, Mirai session files, and MiraiMC config simultaneously. If something breaks (which it'll once), debugging involves checking three different log files. The good news: once it's working, it stays working. So this isn't flaky like some bot frameworks. QQ account credentials. You're storing login info somewhere (ideally encrypted). Treat this like you'd treat a database password. If someone compromises your bot account, they can impersonate your server and spam your QQ group. Use a dedicated bot account and don't share the credentials. Plugin conflicts. If you're running a bunch of chat-manipulation plugins (colored names, custom chat prefixes, translation mods), they might interfere with the QQ integration. Test in a staging environment first, especially if you're adding MiraiMC to an established server. Who Else Is Doing This MiraiMC isn't the only way to bridge Minecraft and QQ. You could build your own integration using the Mirai library directly, but that requires more coding work. Some servers use Discord bridges with QQ (basically Discord to game server to QQ), which adds latency but keeps everything in Discord. If you're only looking to mirror one specific chat channel or send simple notifications, there are lighter-weight notification services that'll work. The MiraiMC advantage is that it's purpose-built for this exact problem and the plugin ecosystem around it is pretty solid. The tradeoff is that you're committed to maintaining a Java plugin and a QQ bot session, which isn't everyone's cup of tea. Before you dive in, think about your actual community. If you've got genuine players who actively use QQ, this is a no-brainer. If you're just hoping it'll magically expand your player base into Asia, it won't. But if you're already running an international server with players across multiple continents and communication tools, connecting QQ makes total sense. You might also want to ensure your main server list is visible on minecraft.how's server list so new players can find you, regardless of region. The code quality is solid (CodeFactor gives it an A), and the project's actively maintained. 186 stars on GitHub isn't huge, but it's consistent with projects that solve a specific regional problem really well. The AGPL-3.0 license means if you modify the plugin code, you've got to open-source those changes. 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

---

### BungeeGuard: Securing Your Minecraft Proxy Network
URL: https://minecraft.how/blog/post/bungeeguard-minecraft-proxy-security
Published: 2026-04-28
Author: ice

"A plugin-based security/firewall solution for BungeeCord and Velocity proxies." lucko/BungeeGuard · github.com Running a multi-server Minecraft network with a proxy? Then you've probably already heard that BungeeCord installations are insecure out of the box. Malicious players can bypass your proxy entirely and connect directly to backend servers, joining as any username or UUID they want. It's a well-known vulnerability that's taken down more than a few large servers. Enter BungeeGuard. It's a straightforward Java plugin that adds token-based authentication between your proxy and backend servers. Instead of relying on complicated firewall rules (or shared hosting where you can't use them at all), BungeeGuard handles authentication for you. What This Project Does The idea behind BungeeGuard is almost laughably simple. Your proxy adds a secret authentication token to the login handshake when a player connects. Your backend servers check that the token is present and valid before allowing the player in. That's it. No firewall wizardry. No iptables nightmares. Just a plugin that works. When a legitimate player connects to your proxy (let's call it proxy.example.com), BungeeGuard on the proxy embeds a pre-shared secret token into the connection data. When the player's client tries to join a backend server (maybe 192.168.1.50:25565), the backend's copy of BungeeGuard checks that token. If it's missing or wrong, the connection gets rejected immediately. If some random person tries to connect directly to that backend server without going through the proxy, there's no token, and they're blocked. This works on both BungeeCord and Velocity proxies, which covers basically every large Minecraft network setup out there. When You Need This If you're running a small local network on your LAN, you probably don't need BungeeGuard. Your local network's probably not under attack. But if your servers are publicly accessible over the internet, or you've any servers exposed beyond your LAN, you're vulnerable. This becomes critical if you're running a network where player progression or economy matter. Account takeovers, item theft, even just troll accounts joining with fake credentials can ruin the experience for legitimate players. The bigger your network, the more attractive a target you become. You're also likely on shared hosting where you can't configure firewall rules yourself. BungeeGuard is your lifeline in that scenario. How to Install BungeeGuard Installation depends on whether you're using BungeeCord or Velocity. They're slightly different processes. BungeeCord Setup First, grab the latest BungeeGuard.jar from the releases page. The current version is v1.4.0, which includes an important security fix if you're upgrading from an older release. After updating, rotate your token in case anyone grabbed the old one. Drop the jar into your BungeeCord plugins folder: bashcp BungeeGuard.jar /path/to/bungeecord/plugins/ cd /path/to/bungeecord java -jar BungeeCord.jar Once BungeeCord starts, it'll create a `plugins/BungeeGuard/` directory with a `token.yml` file. Open that file and copy your token. You'll need it for your backend servers. One important thing: make sure `ip_forward` is set to `true` in your BungeeCord `config.yml`. If you forget this, BungeeGuard won't work right. Velocity Setup If you're using Velocity (and you should be if you're building a modern network), the process is even simpler. Velocity 1.1.0 and newer come with BungeeGuard built in. You don't need to install the plugin at all. Just edit your `velocity.toml` and set: tomlplayer-info-forwarding-mode = "bungeeguard" Your forwarding secret is in that same config file. That's your BungeeGuard token right there. Backend Servers Now install BungeeGuard.jar in the plugins folder of every backend Spigot/Paper server: bashcp BungeeGuard.jar /path/to/spigot/plugins/ cd /path/to/spigot java -jar spigot.jar nogui Restart your server. BungeeGuard will create its own config directory and generate a `token.yml` file. Open it and paste the token from your proxy server. Every backend server needs the same token. If you're using multiple proxies (a sensible setup for load balancing), they all share the same token. Key Features That Matter Token-based authentication is the core feature, but there's more going on under the hood. BungeeGuard verifies player information passed from the proxy to the backend. It's not just checking the token exists; it's validating that the token is correct and that the rest of the handshake data hasn't been tampered with. This prevents more sophisticated attacks where someone might try to forge the handshake data itself. The plugin also handles Velocity's modern player info forwarding mode, which is a cleaner way to pass player data in newer setups. If you're building a network from scratch, Velocity with BungeeGuard built in is the right call. One useful detail: BungeeGuard is incredibly lightweight. It doesn't add noticeable overhead, which matters when you're trying to support thousands of concurrent players across multiple servers. Security Considerations and Gotchas Your token is literally the security of your entire network. Treat it like a password. If someone gets your token, they can create legitimate-looking connections to your backend servers and impersonate anyone they want. Store your token.yml files securely. Don't commit them to version control. Don't paste them in Discord. Just don't. When you update to v1.4.0 (which you should do immediately), the maintainer recommends rotating your token after updating affected BungeeCord setups. This clears out any old tokens that might have been compromised. Velocity setups with the built-in BungeeGuard aren't affected by that vulnerability. You also want firewall rules in addition to BungeeGuard, not instead of. Configure your firewall to block direct connections to backend servers from the internet. BungeeGuard is a great second layer of defense, but it shouldn't be your only layer. If you can set up iptables rules, do it. Then add BungeeGuard on top. Test your setup before going live. Try connecting directly to a backend server without going through the proxy. You should get connection refused or a timeout. If you see a login screen, something's wrong with your BungeeGuard installation. Similar Projects and Alternatives Firewall rules (iptables, ufw) are technically an alternative, but they require system access and are error-prone. Most servers using BungeeGuard do both anyway. Some hosting providers offer managed proxy solutions that handle authentication for you. But if you're running your own infrastructure or on shared hosting without that feature, BungeeGuard is really your best option. It's been battle-tested on networks with thousands of players. The project itself is solid and actively maintained. It's MIT licensed (225 stars on GitHub, Java-based) and the maintainer takes security seriously, as evidenced by the recent vulnerability fix and responsible disclosure process. If you're managing player data with sophisticated whitelisting or custom authentication, tools like Minecraft's whitelist creator work well alongside BungeeGuard. And for server administration, block search tools help when you need to audit your world for suspicious structures. 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

---

### Building Custom Inventories: The inventory-framework Deep Dive
URL: https://minecraft.how/blog/post/inventory-framework-custom-minecraft-inventories
Published: 2026-04-28
Author: ice

devnatan/inventory-framework Minecraft Inventory API framework Spending hours wrestling with Minecraft's default inventory system just to add a simple menu to your server? inventory-framework is a Java library that strips away the boilerplate and gives you a high-level API for building custom inventory UIs across Bukkit, Paper, and Minestom without reinventing the wheel. What This Project Does inventory-framework is an open-source Inventory API (192 stars on GitHub) designed to solve a real problem: creating custom Minecraft inventory interfaces shouldn't require deep knowledge of Bukkit's event system, click handling, or cross-platform compatibility quirks. And this library abstracts those details away so you can focus on designing your game mechanics instead of debugging inventory click events. It supports three major server platforms out of the box: Bukkit servers (the foundation for Paper), Paper (the high-performance Bukkit fork), and Minestom (a lightweight, from-scratch server implementation). That multi-platform approach is genuinely useful if you're experimenting with different server software or maintaining plugins across multiple ecosystems. Why Customize Inventories at All? Custom inventories are the backbone of modern Minecraft servers. Think about it: game menus, admin panels, shop interfaces, quest logs, equipment managers, cosmetic selectors. If you run any kind of game server (not just vanilla survival), custom GUIs are essential. But writing them from scratch is painful. Each click needs event handling. Different Minecraft versions have different behavior. Some platforms don't support certain features at all. The bugs compound fast, and you're writing defensive code instead of creative code. How to Get Started First, you'll need a Minecraft server project using one of the supported platforms (Bukkit, Paper, or Minestom). If you're already running a plugin environment, you're probably ready to go. For a Maven-based project, add the dependency to your pom.xml: xml<dependency> <groupId>me.devnatan</groupId> <artifactId>inventory-framework-api</artifactId> <version>3.7.1</version> </dependency> For Gradle, add this to your build.gradle: gradledependencies { compileOnly 'me.devnatan:inventory-framework-api:3.7.1' } You'll also need the platform-specific implementation. For Paper servers: xml<dependency> <groupId>me.devnatan</groupId> <artifactId>inventory-framework-paper</artifactId> <version>3.7.1</version> <scope>runtime</scope> </dependency> Or if you're using Minestom: xml<dependency> <groupId>me.devnatan</groupId> <artifactId>inventory-framework-minestom</artifactId> <version>3.7.1</version> <scope>runtime</scope> </dependency> The recent v3.7.1 release included a completely rewritten configuration guide with clearer examples, so the documentation is actually solid right now if you hit any setup friction. Core Features That Matter Per-Player Configuration is the headliner here. You can modify inventory behavior on a per-player basis when they open it, which sounds basic until you realize how often you need it. Different players seeing different options? Different player ranks seeing different content? This framework handles that without forcing you to create separate inventory instances. Event Handling follows an intuitive pattern. Register listeners for clicks, configuration changes, and other interactions without wading through Bukkit's verbose event system. The framework passes the right context to your handlers automatically. Cross-Platform Abstraction means you write once and deploy to Bukkit, Paper, or Minestom without conditional code. That's legitimately rare for Minecraft libraries. Navigation Between Views lets you build multi-screen inventory interfaces. Switch between different menus without awkward state tracking. Want a main menu that opens a shop that opens a settings panel? The framework handles the navigation cleanly. Pagination and Dynamic Content handles large collections. Display 100 items across multiple pages without manually calculating slot positions and handling page logic. Scheduled updates mean your inventory can refresh live without the player closing and reopening it. Common Gotchas and Rough Edges The v3.7.1 release fixed a nasty bug where per-player configuration (using modifyConfig() in the onOpen event) wasn't actually working. If you're upgrading from earlier versions and relying on this feature, grab the latest release. Another subtle one: player context cleanup on quit. The framework now handles this internally, but if you're using an older version, make sure you're not leaking player data when they disconnect. Configuration syntax changed between versions. If you're migrating from an earlier release, the rewritten configuration guide in v3.7.1 is worth reading line by line. The changes are sensible, but they're real. What About Alternatives? There's not a massive ecosystem of direct competitors here. ChestUI and InventoryAPI exist, but they're either less actively maintained or cover narrower use cases. If you're looking at inventory frameworks, inventory-framework is the most complete option right now. That said, for very simple cases (a basic shop, single-menu panels), rolling your own might be faster. It's only worth pulling in a dependency if you're building something with multiple menus, complex state, or cross-platform needs. Integration With Your Server Ecosystem If you're building a game server (especially one you might list on the Minecraft Server List), inventory-framework makes it easy to create polished menus that match your server's quality. Players expect good UIs alongside a great server message (like what you'd create with the Minecraft MOTD Creator), and this framework handles the inventory side cleanly. You can integrate it with your permission system, build admin panels, sync menus with custom commands, and connect it to other plugins. For server networks, store menu state in a database and restore it when players hop between servers. The framework handles the UI complexity so you can focus on the mechanics underneath. One practical example: build an inventory-based shop that syncs with your economy plugin. Or create an admin menu tied into your moderation system. The 192-star community is small but engaged, so you'll find examples and get reasonable support if you hit problems. 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 Craft-Engine Lets You Add Custom Minecraft Content
URL: https://minecraft.how/blog/post/craft-engine-minecraft-custom-blocks
Published: 2026-04-28
Author: ice

"A Paper/Folia plugin that enables dynamic creation of custom blocks, items and recipes through configuration." Xiao-MoMi/craft-engine · github.com .0 Ever wanted to add custom blocks and items to your Minecraft server without diving into Java code? That's what Craft-Engine does - it's a configuration-based plugin for Paper and Folia servers that lets you create entirely custom content through YAML or JSON files. No programming knowledge required. What Craft-Engine Does Craft-Engine is a plugin that essentially extends Minecraft's configuration system in ways Paper alone doesn't. Instead of waiting for Mojang updates or writing custom plugin code, you define custom blocks, items, and recipes right in your server's config files. The plugin handles all the heavy lifting using bytecode manipulation and packet-level protocol tweaks. The core idea is elegant. If you can write a config file, you can add custom content to your server. Items get custom display names, textures, durability values, and special behaviors. Blocks get unique mining properties, light emissions, and animations. Recipes use any combination of items you've created. Version 0.0.67 arrived in early 2026 with full support for Minecraft 1.21.11. The changelog includes a new feature placer system for world generation, expanded block behaviors, new item behaviors for range mining, and more. A plugin stays reasonably current with game updates, which matters if you're running recent versions. The plugin specifically targets Paper and Folia - the high-performance server software millions of players use. If you're already running Paper, Craft-Engine drops right in. Why You'd Use This The appeal is flexibility without complexity. Running a custom progression server? A creative realm with themed architecture materials? A PvP server with balanced custom weapons? Craft-Engine provides tools that would normally require hiring a plugin developer or learning Java yourself. Picture a medieval fantasy server. You want iron pickaxes to work differently. Anyone want rare ores that only spawn in dungeons you've designed. Anyone want craftable furniture that players can place in builds. Configuration handles all of it. No Java. No plugin development. Structured YAML files with examples from the wiki. This matters because plugin development is a technical skill barrier most server admins don't have. Craft-Engine drops that barrier significantly. Getting It Running You'll need a Paper or Folia server running Minecraft 1.20 or newer (1.21.11 gets the latest features). Download the plugin JAR and drop it in your plugins folder: bashcd /path/to/your/server/plugins wget https://repo.momirealms.net/releases/net/momirealms/craft-engine-bukkit/0.0.67/craft-engine-bukkit-0.0.67.jar Restart your server. The plugin generates its configuration folder structure automatically on first run. Config syntax is straightforward YAML: yamlitems: ruby: displayName: "Ruby" material: "PAPER" maxStackSize: 64 customModelData: 1 The official wiki at https://xiao-momi.github.io/craft-engine-wiki/ is genuinely thorough - specific examples, complete syntax breakdowns, feature walkthroughs. It's documentation that actually helps. Before customizing items and blocks, optimize your server baseline. Grab minecraft.how's Server Properties Generator to tune your server.properties without guesswork. You'll want your server running smoothly before piling on plugin features. Features That Stand Out Furniture is genuinely useful. Define decorative objects that aren't full blocks - chairs, tables, lamps, wall hangings. These render client-side but behave like interactive objects. The latest version added hit-times settings, so you customize how long furniture takes to break. Block behaviors unlock interesting world-building possibilities. The feature placer generates trees, ores, and structures during world generation. Multi-high blocks let you create tall plants or crystal formations. Spreading blocks handle content that propagates like fire or vines. Item behaviors match that flexibility. Range-mining items break blocks in an area instead of one at a time. Combine that with custom durability values and you've got genuinely unique equipment that feels different from vanilla. Mining interruption under high latency got optimized recently - a detail suggesting the developer actually plays on public servers with international players. Glow colors are now fully packet-based, meaning no desync between players and smooth rendering even with severe ping variance. What Trips People Up The biggest gotcha is overthinking the config structure. It demands precision - missing colons, bad indentation, mismatched quotes break silently in tedious ways. Read the wiki examples carefully. Resource pack integration requires parallel work. Custom-modeled items need matching texture files packed in a resource pack that loads on the client side. Missing textures or mismatched custom model data values are the usual culprits. If custom item models aren't showing, check your resource pack first. The condition system is powerful but complex. It's easy to write logically incorrect conditions without realizing it until you test in-game. If you're customizing item text output, the Minecraft Text Generator is useful for testing formatting codes before adding them to config. Saves a lot of in-game trial-and-error. How It Stacks Against Alternatives ItemsAdder is probably the closest rival, more polished if you just want custom items. It's beginner-friendlier with a built-in editor, though premium features require payment. NexoBlocks is newer and designed specifically for blocks. It's arguably cleaner if you're purely focused on custom block content. Craft-Engine sits in the middle. Free, open-source (GPL-3.0), handles items and blocks equally well. 228 stars on GitHub suggests solid development without massive hype. Smaller communities often mean faster, more responsive development. The premium edition ($12 via Polymart) offers official support and early dev builds, but the community version is feature-complete for most servers. Ready to try craft-engine? 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 Xiao-MoMi/craft-engine on GitHub ↗

---

### Raknetify: Fixing Minecraft Lag on Unreliable Connections
URL: https://minecraft.how/blog/post/raknetify-minecraft-lag
Published: 2026-04-28
Author: ice

GitHub · Minecraft community project raknetify (RelativityMC/raknetify) A Fabric mod / Velocity plugin / BungeeCord plugin that uses RakNet to improve multiplayer experience significantly under unreliable and rate-limited connections. Star on GitHub ↗ Sitting in a Minecraft server with a ping that spikes between 150ms and 2000ms on your residential internet, or stuck on a throttled mobile hotspot? Raknetify tackles exactly this problem by replacing Minecraft's standard TCP connection with RakNet's multi-channel protocol, which prioritizes critical game packets and retries failures intelligently. If you're on a good connection, you won't notice much. If you're not, this can genuinely change whether the game feels playable. What This Project Does Raknetify isn't a magic wand that eliminates lag. What it does is reorganize how Minecraft sends and receives data so that your connection quality problems hurt you less. Minecraft normally sends everything over a single TCP stream. That means one lost packet can cause a cascade of delays as the client and server resync. RakNet, the networking library that powers Minecraft Bedrock and many other games, uses multiple priority channels instead. Critical packets like player position updates get their own lane, while less urgent stuff (like a distant player's animation) can wait. The result is lower perceived latency and fewer frame freezes, especially noticeable when you're on a residential connection that gets throttled, or anywhere with significant packet loss. You can also prefix your server address with `raknet;` (or `raknetl;` for a different MTU setting) and connect directly, which is refreshingly simple. The mod and plugin versions both exist, so whether you're running a vanilla-based proxy like Velocity or BungeeCord, or a Fabric server, you've options. When You'd Want This Honestly, most players on stable home internet with a decent ISP won't see dramatic improvements. You'd install Raknetify if you fall into one of these camps: You play over mobile hotspot. Cellular data is inherently flaky, with packet loss spiking during heavy use. Raknetify's retry logic handles this way better than standard TCP. Your ISP throttles you. Some residential networks have per-connection or per-IP rate limits that make multiplayer stutter. Multi-channel prioritization helps here. You're running a geographically distant server. High absolute ping sucks, but if it's stable, standard Minecraft handles it fine. But if that high-ping connection is also lossy (satellite, undersea cables, intercontinental hops), Raknetify reduces retransmit delays. You run a proxy like Velocity or BungeeCord and want to support players on poor connections. Installing it server-side means your entire playerbase benefits without having to mod their clients (though client-side installation is more effective). And if you're in a region with genuinely bad internet infrastructure, this is worth trying. The overhead is minimal, and since it's a drop-in replacement, worst case you just remove it if it doesn't help. Installation and Setup The install process is straightforward, but there are a few prerequisites you should know about upfront. Before you start: Raknetify requires Minecraft 1.17.1 or newer (so most modern versions, though older 1.16 servers are out of luck). And here's the non-obvious part: your server needs an open UDP port at the same port number as your normal server port. If your server runs on port 25565, you need UDP 25565 open too. Check your firewall and port forwarding rules before installing. For Fabric servers: Grab the latest release from Modrinth or GitHub. Drop it in your mods folder on both the server and client machine. Restart the server and client, then connect by prefixing your server address: `raknet;mc.example.com` instead of just `mc.example.com`. That's it. bash# Example: connecting to a Fabric server with Raknetify # In Minecraft multiplayer menu, add server: # Name: My Server # Address: raknet;mc.example.com # Port: (leave blank, defaults to 25565) For Velocity or BungeeCord proxies: Download the plugin version (available on SpigotMC for BungeeCord, Modrinth for Velocity). Install it in your plugins folder, restart the proxy, and you're done. Clients connecting through your proxy will automatically benefit. Install it client-side too for better results. If you want to try development builds before a stable release, the CodeMC CI server hosts them. That's useful if a bug's been reported and fixed but not officially released yet. How the Multi-Channel System Works The secret sauce is RakNet's prioritized channels. Instead of one TCP connection carrying all traffic, Raknetify creates multiple virtual channels with different priorities. Your player position, rotation, and block interactions get high priority. Particle effects, distant mob animations, and chat messages get lower priority. When packet loss happens on a lossy connection, the low-priority stuff gets dropped, not your movement updates. For example: you're on a spotty mobile hotspot and a chunk starts loading at the exact moment 20 other players teleport near you. Standard Minecraft might queue all those messages and freeze your view for half a second as TCP tries to resend lost packets in order. Raknetify would drop some of the particle effects and distant player animations, but keep your own movement smooth because that traffic is segregated into a higher-priority channel. There's also an MTU (maximum transmission unit) variant. If you're on a network with aggressive packet fragmentation, using `raknetl;` instead of `raknet;` sets a higher MTU, which can reduce overhead in some cases. The README doesn't go deep on when to use which, so it's mostly trial and error if you're having trouble. ViaVersion Support (Cross-Version Connections) Raknetify works alongside ViaVersion if you're running a proxy that supports older or newer client versions. If you're proxying a 1.20.1 server but want 1.21 clients to connect, ViaVersion translates the protocol. Raknetify plays nicely with this setup. Just install both and you're good. One caveat though: if you're running Raknetify on a proxy (Velocity/BungeeCord) and an unsupported client version connects (say, an ancient 1.8 client on a 1.21 server), Raknetify can fail to initialize multi-channel mode. You'd fall back to standard TCP, which defeats the purpose. This is noted in the README but easy to miss. If your proxy serves many legacy versions, test this scenario first. Gotchas and What Trips People Up Most Raknetify issues come from missing prerequisites, not the mod itself. UDP port not open. This is the most common one. If clients can't reach your UDP port, Raknetify falls back to TCP silently, and you won't know anything went wrong. Check your firewall and port forwarding. Use the Minecraft Server Status Checker to verify your server is reachable, then manually test UDP connectivity if possible. Version mismatches. Raknetify requires 1.17.1+. If you're on 1.16, it won't work. And both client and server should be on the same or similar Minecraft versions, or ViaVersion needs to be handling the translation. Proxy version confusion. The BungeeCord version and Velocity version are different builds. Download the right one for your proxy type. False hope on already-stable connections. If your connection is already good (low ping, no packet loss), Raknetify won't make things faster. You might even see a tiny overhead. Only install it if you actually have unreliable connections to test against. Performance-wise, the overhead is minimal. You're trading a tiny bit of CPU for better packet prioritization, which is almost always worth it. Similar Projects and Alternatives A few other projects address related problems, though none do exactly what Raknetify does: Geyser. Bridges Bedrock and Java Edition. It also uses RakNet for Bedrock clients, but it's solving a different problem (cross-platform play) rather than connection reliability per se. Proxy-side optimizations. Some proxy configs like Velocity's compression settings can help, but they don't reorganize how packets are prioritized the way Raknetify does. Custom server software. Some forks of Spigot claim to optimize networking, but most are unmaintained or outdated. Raknetify is actively developed and has a clean, modular approach. If you're running a large public server and want to squeeze every bit of performance out of unreliable connections, you could stack Raknetify with other optimizations. But for most people, Raknetify alone handles the job. So should you install it? If you're on stable internet, probably not. If you're stuck with a flaky connection and want to see if it helps, it takes five minutes and costs nothing. And if you run a proxy server that serves players globally or in areas with poor infrastructure, it's worth having in your toolkit. The code is clean, it's actively maintained, and the community around it seems responsive to issues. 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

---

### DivineMC: Building Parallel-Threaded Minecraft Servers That Scale
URL: https://minecraft.how/blog/post/divinemc-minecraft-server-parallel-ticking
Published: 2026-04-28
Author: ice

BX-Team/DivineMC DivineMC is a multi-functional fork of Purpur, which focuses on the flexibility of your server and its optimization. .0 Alright, so you're running a Minecraft server and you've hit that wall. Vanilla server jar can't use your extra CPU cores, chunk ticking happens on a single thread, and TPS drops the moment player count climbs. You've tried Paper. You've tuned configs. Now what? DivineMC is a fork of Purpur that takes Purpur's legendary flexibility and bolts on parallel chunk ticking, async operations, and a bunch of thoughtful optimizations. It's got 240 GitHub stars, active development, and it approaches scaling differently than the big names like Folia. What DivineMC Does This isn't a complete threading rewrite. DivineMC keeps Purpur's architecture - you've got granular control over mob spawning rates, entity tracking, and miscellaneous behavior tweaks. But it adds regionalized chunk ticking, which means chunks process in parallel using your available CPU cores instead of sequentially on a single thread. The project also includes async pathfinding, entity tracking, mob spawning, and chunk sending. All the operations that usually block the main tick thread happen off-thread. That means when 50 zombies pathfind toward a player at once, it doesn't tank your TPS. You also get enhanced security (1024-bit seeds instead of 64-bit), support for client mods like Syncmatica and Xaero's Map without server-side mod infrastructure, and somewhere around 10 bug fixes that address various Minecraft quirks. Why You'd Want This Picture this: you're running a 20-30 player survival server. Growth is happening. TPS starts tanking during peak hours. You check profiling and half your tick time is chunk loading and pathfinding calculations. You've already done the standard Paper config optimizations. At that point, parallel chunk ticking shifts from nice-to-have to actually useful. DivineMC lets chunks tick simultaneously, kind of like Folia does, but without requiring a total migration or heavy plugin compatibility testing. It's also solid if you've got multiple worlds, a dense plugin ecosystem, or player builders uploading massive schematics. The async operations and improved region file formats mean better stability when pushing the server hard. And this matters: DivineMC plugins are 100% compatible with Bukkit, Spigot, and Paper. You're not locked in. If you want to switch tomorrow, your entire plugin ecosystem moves with you. How to Get It Running First, grab a build from the BX-Team downloads page or MCJars. Pick the jar that matches your Minecraft version. Basic startup: bashjava -Xmx4G -Xms2G -jar DivineMC-[version].jar nogui Adjust the `-Xmx` (max RAM) and `-Xms` (initial RAM) numbers based on your hardware. Four gigs is reasonable for small-to-medium servers. First launch generates your world and config files. The server will ask you to accept the EULA. Edit `eula.txt` and change `false` to `true`, then restart. Here's the key part: DivineMC is all about configuration. The defaults are solid, but you'll want to tune `paper.yml` and DivineMC-specific configs for your setup. This documentation site walks you through what's actually configurable. If you're setting up for specific players, the Minecraft whitelist creator tool saves time. Paste your player names and it generates the whitelist format instantly. Features That Matter Parallel Chunk Ticking processes chunks simultaneously instead of one after another. More blocks updating at once without the main tick thread freezing. Not magic, but noticeable when you're under load. Async Operations move pathfinding, entity tracking, mob spawning, and chunk sending off the main thread. This prevents the classic lag spike when a horde of mobs pathfinds toward your player. Linear Region File Format is for world storage - old V1/V2 format or the new Buffered approach. Niche optimization for massive world migrations or schematic-heavy builds. Most servers won't notice, but it's there if you need it. Sentry Integration sends error reports to a Sentry instance if you set it up. Useful for public servers where structured error tracking beats digging through logs. Mod Protocol Support means Syncmatica, Xaero's Map, Jade, and Apple Skin clients work fine without getting kicked. Helpful if your community uses client-side mods. What'll Trip You Up Parallel chunk ticking isn't a magic button. You enable it, but you still monitor performance and tune it. There's no setting that just makes everything faster. If you want to build from source (the README includes gradle commands), you need a development environment set up. For just running a server, use the pre-built jars. Source builds are for contributors patching the codebase. Regional ticking means chunks in different regions process in parallel, but chunks within a region still tick sequentially. Dense redstone contraptions in a single chunk will still cap that chunk's TPS. The optimization helps when build activity spreads across the world, not concentrated in one spot. One quick thing: plugin compatibility is with Bukkit, Spigot, and Paper plugins. Not with Forge or Fabric server-side mods. You can run client-side mods all day, but vanilla-derived servers don't support server-side modding environments. (That's just how vanilla-derived server software works.) How It Stacks Up Folia (also Paper-based) throws full multithreading at the problem - each region gets its own thread and game loop. More aggressive parallelization but requires heavier plugin testing. DivineMC is less radical and keeps Purpur's flexibility intact. Pufferfish pioneered some of the async features DivineMC included, but maintenance has slowed. DivineMC feels like the natural evolution of that approach. Pure Paper is simpler and way more widely used. Small server with a few plugins? Paper probably gives you 90% of the benefit with zero config overhead. For server admins comfortable with tuning configs and wanting performance gains without ecosystem disruption, DivineMC slots in nicely between simplicity and raw ambition. Getting Help When You Need It The project lives on GitHub. There's a Discord server (discord.gg/qNyybSSPm5) where the community answers questions quickly. Docs are at bxteam.org/docs/divinemc. If you want to contribute, there's a contribution guide. Java, standard server software patterns, Gradle build system. The maintainers are responsive and the community is small enough that you'll get help fast. Ready to try DivineMC? 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 BX-Team/DivineMC on GitHub ↗

---

### Setting Up BedWars on Your Minecraft Server
URL: https://minecraft.how/blog/post/bedwars-minecraft-plugin-setup
Published: 2026-04-28
Author: ice

ScreamingSandals/BedWars Simple BedWars minigame plugin for Paper/Spigot version 1.8.8 - 26.1.2 .0 Want to run competitive team-based gameplay without the headache of building the game mode from scratch? BedWars is the plugin that handles it for you. Supports Minecraft 1.8.8 through 26.1.2, runs on Paper and Spigot, and it's genuinely flexible enough to customize for just about any server. What Exactly Is BedWars? If you've played Hypixel or any other major server in the last decade, you know the format already. Two or more teams spawn in separate islands with a bed at the center. Destroy the other team's bed and kill all their players to win. Sounds simple. It gets strategic fast. The plugin implements all the core mechanics: team spawning, bed destruction tracking, death messaging, and victory conditions. But here's where it gets interesting - it also handles variants like CakeWars (destroy a cake instead), EggWars (protect eggs), and AnchorWars. Everything runs inside a single arena system, which means you can host multiple arenas on one server and let players queue up. The codebase is Java (317 stars on GitHub) and licensed under LGPL-3.0, so it's genuinely open source. That matters if you want to fork it or understand what's happening under the hood. Why Run BedWars Instead of Building It Yourself Building a functional team-based minigame from scratch involves inventory management, state tracking, arena rebuilding, respawn timing, shop interfaces, and about a dozen other systems. This plugin handles all of it. The real wins are: spectator mode (players can watch instead of sitting in limbo), instant arena rebuilding after each match, built-in team selection GUI, and multi-shop support. You can also hook it into BungeeCord for network-wide gameplay, which is essential if you're running multiple servers. And it's genuinely stable. People have been running this for years on production servers. It's not latest experimental code. Getting It Running Grab the latest JAR from Spigot or build it yourself if you want. The project uses Gradle - if you want the bleeding-edge version: bashgit clone https://github.com/ScreamingSandals/BedWars.git cd BedWars./gradlew clean build Your compiled JAR lands in `plugin/bukkit/build/libs/`. Drop it in your `plugins/` folder and restart the server. After that, you'll get a config folder at `plugins/BedWars/`. The defaults are actually reasonable, but you'll need to create arenas. One plugin gives you commands to spawn areas, set team spawns, set the bed location, set shop locations. It's all in-game configuration, no hand-editing XML files. Start by creating a flat arena world if you don't have one already. A simple creative-mode build works fine - islands separated by void, each with a bed and resource spawners. Then use the arena setup commands to register everything. The wiki covers this, but honestly, most people figure it out by trial and error. Shops, Spawners, and Special Items Each arena can have multiple shops. Players earn currency from killing players and breaking blocks, then spend it at shops to buy tools, armor, building blocks. You customize the entire shop inventory and pricing. Resource spawners are configurable - you can have as many as you want, set spawn rates, and choose what they drop. Iron spawner in the base, diamond spawner in the middle, emeralds for late-game trades. You control the economy. Special items are a fun bit - RescuePlatform (spawns a bridge if you're falling into void), TNTSheep (launches explosives at enemies). These are configurable in the shop too. Here's a practical tip: when you're tuning shop prices, test it locally first. Run a game solo, feel the economy flow. If iron costs too much early, your team will fall behind. If diamonds cost too little, the game ends in three minutes. Performance and Common Gotchas This plugin is light on resources. I ran it on a 2k-block arena without issues on modest hardware. Arena rebuilding is incredibly fast - the plugin resets blocks instantly after each match instead of wiping and reloading the whole area. One thing that trips people up: permissions. Make sure your permission plugin is actually granting `/bw` commands to admins. If arena setup commands don't work, it's almost always a permission issue. Also, version compatibility matters. The plugin supports 1.8.8 through 26.1.2, but some specific features might not work on very old versions. Actually, on 1.8.8 you might have item display issues - newer Minecraft versions handle item metadata better. Unless you've a really specific reason to run 1.8.8, stick with 1.17+. If you want to advertise your server, you might want a custom MOTD. Check out the Minecraft MOTD Creator to make something eye-catching. And if you're tweaking server performance for the minigame load, the Server Properties Generator helps you find the right settings without guessing. What About Alternatives BedWarsRel is the spiritual ancestor of this plugin. Still maintained, simpler, but less feature-rich. If you want something more arcade-oriented, check out Dream BedWars or other variants on Spigot. Most of them are heavier on features, lighter on customization. My take: if you want a proven, lightweight plugin that runs on everything from 1.8.8 to 26.1.2 and lets you actually customize things, this one does the job. If you want bleeding-edge visual effects and complex progression systems, you might want to look elsewhere. But for a solid minigame foundation, this is it. Ready to try BedWars? 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 ScreamingSandals/BedWars on GitHub ↗

---

### How to Build a Minecraft Castle: Medieval Building Guide
URL: https://minecraft.how/blog/post/how-build-minecraft-castle
Published: 2026-04-28
Author: ice

Medieval castles are probably the most satisfying builds in vanilla Minecraft. You'll need patience, stone variants, and a solid plan, but the result is genuinely impressive. This guide walks you through foundation design, wall construction, tower placement, and roofing strategies to get your castle from concept to completion. Choosing Your Foundation and Block Palette Before you place a single block, grab a pencil and paper (or just stare at your screen for 20 minutes like the rest of us). What stone type matches your vision? Stone brick, deepslate, andesite, diorite, and regular stone all have different feels. Mix them together. That's the secret nobody talks about. Your castle needs space. Not just for the main structure, but for surrounding terrain that makes sense. A moat looks great but takes forever to dig. Terracing the ground around the base is faster and honestly looks better on most builds. You can still add water features later if you're not tired of moving blocks. Think about height and scale before you commit to a direction. Are you building a compact stronghold or a sprawling fortress that eats up half your render distance? For first-timers, a three-to-four-level castle keeps things manageable without looking wimpy. Tall doesn't always mean impressive. Location matters way more than most guides admit. Hilltops look dramatic. Valleys feel secure. Coastal castles can have water features that honestly save hours of detail work because you don't have to create them from scratch. Pick somewhere that speaks to you, because you're about to spend a lot of time there. Constructing Medieval Walls That Look Ancient Here's where walls need thickness. Make them at least three blocks wide at the base, tapering to two blocks at the top. Thin walls look flimsy and, while nobody's actually attacking your castle, they just feel wrong visually. The real skill is texture variation. Stick with three main blocks and one accent block. Stone brick as primary? Add some cracked stone brick, mossy stone brick, and regular stone sprinkled throughout. Vary the pattern every few blocks rather than going rigid and geometric. Mismatched stonework looks ancient and weathered. Perfection looks brand new, which isn't the vibe. Height-wise, twelve to fifteen blocks feels right for standard palace walls. Too short and it looks like a fancy fence. Too tall and you lose visual proportions. There's a sweet spot where castles look monumental without becoming absurd. Crenellations (those toothy bits on top of the walls) are essential. Space them two blocks apart, one block tall. They look incredible from a distance and give archers places to hide in your imagination. Adding little arrow slits actually works mechanically too if you're thinking about defense, not that you'll ever need it in survival. Corners are where castles earn their personality. Make corner towers jut out three to four blocks from the walls. This isn't just cosmetic. Medieval builders understood that defenders on corner towers could cover the walls on both sides. Your castle doesn't need functional defense, but it should look like it could work. Building Towers That Command Attention Towers are what transform a wall into a castle. Without them, you're just building a very elaborate fence. Corner towers should be the tallest structures you build. Make them four to five blocks in diameter, rising three to four blocks above the main walls. Entry towers can be slightly smaller and are usually the only major break in the wall perimeter. This creates visual contrast and gives visitors a clear sense of where the castle opens. Battlements on tower tops look fantastic, and they're dead simple to build. Run a crenellated line around the top edge using stairs and slabs. Done. Instant authority. Windows matter more than you'd think. Tiny openings for arrow slits along lower levels, larger windows at mid-levels. This creates a visual rhythm while maintaining that medieval fortress vibe. Scatter your windows irregularly though, not in perfect grids. Real castles weren't built by contractors with clipboards and spreadsheets. Spiral staircases inside towers are the ultimate detail. Wind stone block stairs with a center pillar, slowly rotating as they climb. It's tedious to build but worth every second when someone climbs up to the rooftop and actually notices what you created. Those small moments matter. Roofing That Doesn't Look Flat Flat roofs are the enemy of medieval buildings. You need slopes, angles, personality. Steep roofs use stairs and slabs to create that classic pitched profile. Start at the outer wall with full blocks, then stairs pointing inward, then slabs. Repeat this pattern along the entire perimeter. It's block-intensive but looks substantially better than anything else you could do. The effort returns itself in every screenshot. Roof material choices matter. Dark oak, spruce, and warped wood work great for traditional vibes. Blackstone and deepslate create darker, more ominous roofs. Try mixing wood and stone roofs across different sections. A tower might have wood while the main hall goes dark stone. Your castle, your rules. Consider adding small wooden overhangs at roof edges, supported by scaffolding or thin wooden pillars. Medieval builders knew about rain gutters and practical architecture. Your castle should hint at that knowledge, even if you're surrounded by desert and it never rains. Interiors and the Spaces Between Walls This is where most castle guides drop off and you're left wondering what goes inside all this stone. The reality is that interiors matter just as much as the shell. Start with a courtyard as your centerpiece. Pave the center with a different stone type than your walls, maybe with a circular well in the middle. A well gives you a focal point and honestly looks phenomenal. Surround the courtyard with single-story structures: barracks, storage, workshops, stables. Keep these lower than the main walls so the castle's profile stays impressive from the outside. The great hall needs a massive roof and enough ceiling height to feel special. Nothing kills the vibe like a normal-height room for your main gathering space. Build it at least twelve blocks tall with a soaring roof structure. Add a long table running down the center, a massive fireplace (stacked campfires with chimneys made from stairs work fire), torches, and banners hanging from the walls. This becomes your showpiece interior, the reason people stay longer than just admiring the exterior. Secret rooms are traditional medieval nonsense, but they're genuinely fun to build. Hide a small room behind a bookshelf or painting frame. Stock it with treasure, stolen goods, or just vibes. Nobody expects them. That's the entire point. Dungeons make thematic sense and give your castle actual purpose beyond looking impressive. A few dark stone rooms with chains, cages, and creepy lighting below ground level. Build them even if friends ignore them entirely. You're building for yourself first. Landscaping and Final Details That Bring Everything Together Landscaping transforms a castle from "neat structure" into "wow, that's genuinely incredible." Create elevated terrain around the castle using gravel, coarse dirt, and grass blocks. Slopes leading up to gates look more imposing than flat approaches. Add some guard stations at ground level with little lean-tos for torches and signage. These details make the space feel lived-in. Moats are optional but visually stunning. Dig out a perimeter of water several blocks wide. Add some lily pads, kelp, and the occasional stone path crossing it. A moat immediately reads as "medieval fortification" to anyone visiting. But it also gives you places to hide mobs if you're playing survival with friends. Gardens surrounding the castle give it context and life. Flower gardens in designated areas, some plots of crops, maybe a small orchard with oak logs and leaves scattered naturally. Living spaces support life, so surround your castle with evidence of it. Villagers wandering around adds atmosphere too. Lighting is criminally overlooked in castle builds. Place torches along the walls, lanterns hanging from chains between towers, soul lanterns in tower windows for an eerie glow. Light defines mood. A well-lit castle feels alive and active. A dark castle feels abandoned and haunted, which might be exactly what you want. If you're building on a server, verify your setup is stable before hosting visits. The Minecraft Server Status Checker helps ensure your server stays online when friends want to tour your creation. Crashes during grand tours are the worst. For servers with voting systems, the Votifier Tester ensures your voting mechanics work smoothly, letting your community easily support the server while you build. Working infrastructure means you can focus on creation instead of troubleshooting.

---

### Building Custom Minecraft Server HUDs with BetterHud
URL: https://minecraft.how/blog/post/betterhud-minecraft-server-plugin
Published: 2026-04-28
Author: ice

"A multiplatform server-side implementation of HUD in Minecraft, supporting Bukkit(with Folia), Velocity, and Fabric." toxicity188/BetterHud · github.com Ever tried adding a professional HUD to your Minecraft server without forcing players to install client mods? BetterHud does exactly that - it's a server-side plugin that auto-generates the resource pack and handles all the rendering. Works on Bukkit, Velocity, and Fabric, with animation and custom layouts built in from the start. What separates BetterHud from chat spam and action bar hacks is that it renders actual HUD elements directly onto the player's screen. No clutter. No mods required. The server generates the resource pack automatically, pushes it to joining players, and manages everything server-side. Text, images, player heads, animations - all defined in config files you control. Want to show a boss's health bar above the hotbar? Overlay a compass for your RPG server's custom locations? Display ability cooldowns with animated shrinking rings? BetterHud is built for exactly this. What This Project Solves The core problem: vanilla Minecraft's visual feedback is primitive. HUD space is limited. You either spam chat, waste the action bar, or resort to janky workarounds that feel unpolished. Custom HUDs fix that, but only if they're invisible to players (no installation friction) and work across multiple server platforms. BetterHud checks both boxes. Server admins get clean visual layering. Players get a polished experience. Developers get an API to hook into HUD events and display custom data. It's the rare tool that works for all three groups. Why Servers Use This Run a PvP network? Kill streaks, damage taken, remaining players - all visible at a glance without cluttering chat. RPG server? Mana bars, buff icons, cooldown rings, quest progress overlays. This stuff makes the game feel intentional instead of spreadsheet-driven. Parkour or game modes? Real-time leaderboards, checkpoint countdowns, stat overlays. The list goes on. The advantage over alternatives is enormous. Client mods require player installation. Custom clients need hosting and maintenance. Datapacks and custom resource packs are DIY nightmares for anything beyond trivial HUDs. BetterHud removes installation friction while providing a structured framework instead of pure chaos. Most server owners don't bother with custom HUDs at all, actually. They stick with vanilla feedback because the alternatives feel like too much work. BetterHud changes that calculation. Getting BetterHud Running Installation is straightforward, though the steps vary by platform. The one requirement across all platforms is Java 21 (Eclipse Adoptium) if you're building from source - pre-built jars are available, so most people skip that step entirely. Bukkit and Paper servers: Grab the latest release from the GitHub releases page. As of the 1.14.1 update, download the Bukkit jar and drop it into your plugins folder: bashcd /path/to/server wget https://github.com/toxicity188/BetterHud/releases/download/1.14.1/BetterHud-bukkit-1.14.1.jar mv BetterHud-bukkit-1.14.1.jar plugins/./start.sh (Or restart if the server's already running.) BetterHud auto-generates config files and the resource pack on first load. Velocity proxies: Same process, different jar: bashcd /path/to/velocity wget https://github.com/toxicity188/BetterHud/releases/download/1.14.1/BetterHud-velocity-1.14.1.jar mv BetterHud-velocity-1.14.1.jar plugins/ Restart Velocity. Now your entire proxy network has access to the same HUD system. Fabric servers: This one has a dependency: Fabric API. Install that first, then add BetterHud to your mods folder: bashcd /path/to/server/mods wget https://github.com/toxicity188/BetterHud/releases/download/1.14.1/BetterHud-fabric%2B1.21.11-1.14.1.jar Fabric will load both on next start. Config time is where the actual work begins. BetterHud generates template YAML files - these define your HUD layouts, which elements display when, and how they animate. Core Features Worth Understanding Mathematical expressions in text: BetterHud isn't limited to static text. You can embed expressions that evaluate at runtime: armor durability percentages, health bars that scale with max HP, formulas tied to custom plugin data. If your server has a leveling system that affects stats, you can display those dynamically without hard-coding values. Animated PNG sequences: Static images are fine, but animated PNGs let you add subtle motion - spinning cooldown indicators, pulsing health warnings, visual feedback for status effects. BetterHud handles the frame timing server-side, so the animation stays smooth even under server lag (within reason). Resource pack generation: Here's where BetterHud genuinely saves time. Instead of manually crafting pack.mcmeta files, creating texture atlases, and hand-writing json models, the plugin generates the pack from your config. Describe what you want; BetterHud builds the pack. This single feature is worth the installation. Multi-platform support: Bukkit, Velocity, and Fabric in one codebase. Most HUD solutions pick a lane and stay there. This flexibility is huge if you're running a hybrid setup or planning to scale infrastructure later. What Usually Trips People Up Server-side rendering means HUD updates are tied to server ticks. If your server is laggy, the HUD stutters. It's not BetterHud's fault - it's inherent to the architecture. Keep your server healthy, and the HUD will be smooth. Resource pack size matters more than you'd think. If you add hundreds of custom textures, the generated pack grows large, and players with poor bandwidth complain about download time. Start minimal. Add assets gradually as needed. The config format has a learning curve, actually. YAML is simple enough, but BetterHud's specific syntax for keyframes, expressions, and layer ordering takes reading the wiki and doing hands-on testing. Expect iteration. Testing HUDs on live servers can be risky if you misconfigure something. You might want to use a staging server first. If you don't have one, our Minecraft Server Status Checker is useful for quickly verifying that your server responds to connections correctly before deploying a new HUD to players. For infrastructure-heavy setups (multiple servers, load balancing), you might also want proper DNS management. Our Free Minecraft DNS tool can help simplify server addresses across multiple instances, so players connect to the right backend regardless of which proxy they hit first. Projects That Do Similar Things VisualsAPI is probably the closest alternative. Same server-side rendering philosophy, similar platform support. Less actively maintained than BetterHud, and smaller community, but the core concept is identical. Worth evaluating if you need something simpler or prefer a different licensing approach. Custom resource packs plus datapacks is the DIY route. You manually craft packs, write datapacks to drive behavior, and accept absolute control at the cost of enormous complexity. Fine for one-off projects. Painful for anything you want to iterate on. Client-side mods work if you control the joining clients (private server, whitelisted, etc.). Mod-based HUDs offer more freedom, but players must install them, and you're supporting multiple versions. BetterHud avoids all that friction. BetterHud sits comfortably in the middle: more accessible than pure datapacks, more flexible than most alternatives, and zero client burden. Where I Land On This If you're running a server beyond vanilla survival - a PvP network, an RPG, anything with custom mechanics - custom HUDs are the difference between "feeling like a real game" and "feeling like a spreadsheet with mobs." BetterHud makes adding them practical instead of a multi-week project. It's not perfect. Config syntax has a learning curve. Performance depends on server health. Resource pack size can be an issue if you get wild with custom textures. But for most server owners looking to polish the experience, it's the single best tool available. Try it on a staging server first. Read the wiki. Join the Discord if you get stuck. The community's helpful, and the maintainer actively develops new features. Ready to try BetterHud? 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 toxicity188/BetterHud on GitHub ↗

---

### ConfigLib: Handling Plugin Config Files the Right Way
URL: https://minecraft.how/blog/post/configlib-minecraft-plugin-config
Published: 2026-04-28
Author: ice

"A Minecraft library for saving, loading, updating, and commenting YAML configuration files" Exlll/ConfigLib · github.com Managing configuration files for Minecraft plugins is tedious. You create a YAML file, manually parse it, reload it when it changes, update it when you add new options. ConfigLib automates all of this. Your config classes become your single source of truth. What ConfigLib Does ConfigLib is a Java library that bridges a gap plugin developers face constantly: how do you actually manage YAML configuration files without writing boilerplate code? The traditional approach involves creating a YAML parser, handling updates manually, tracking which fields changed, and hoping you didn't miss any edge cases. Instead, ConfigLib lets you write a Java class (with fields and default values), annotate it, and the library handles everything else. Save? Done. Load? Done. Update when the file changes? Done. Add comments explaining each option? Also done. It's surprisingly elegant for something that sounds simple. The library supports Java records, POJOs, enums, and inheritance. You can nest configuration classes inside each other, which is huge if you're building anything with multiple configuration sections (and honestly, what plugin doesn't have those?). Why You'd Use This Look, you could manually parse YAML files. Lots of plugins do exactly that. And it works fine until it doesn't - someone upgrades their server, a field gets out of sync, or you need to add a new option and wonder if you broke existing configs. ConfigLib eliminates that friction. Type safety means you catch configuration errors at load time, not when a player tries to use a feature. Automatic comments mean your config file is self-documenting. Someone can read the YAML file and understand what each option does without digging through your source code. The update mechanism is the real win. If you add a new field to your config class, ConfigLib automatically adds it to existing config files with your specified default value. If you rename something, the old key stays in the YAML but the new one gets created. You're not breaking existing setups. Getting Started: Installation and Setup You'll need to add ConfigLib as a dependency. If you're using Maven, drop this in your pom.xml: xml<dependency> <groupId>de.exlll</groupId> <artifactId>configlib-paper</artifactId> <version>4.8.1</version> </dependency> If Gradle's your thing: gradledependencies { implementation 'de.exlll:configlib-paper:4.8.1' } ConfigLib also has variants for Velocity and Waterfall if you're running a network proxy. Just swap out "paper" for "velocity" or "waterfall" in the artifact ID. The basic workflow: create a class, annotate it with @Configuration, add fields with default values, and call ConfigLib to load or save it. That's genuinely all you need to start. Key Features That Matter in Practice ConfigLib handles way more than basic strings and numbers. So it supports collections (lists, sets, maps), Java time types (LocalDateTime, Instant), big numbers (BigInteger, BigDecimal), file paths, UUIDs, and even Bukkit-specific types like ItemStack. So if your config needs to store complex data structures, you're covered. Comments are first-class citizens here. Use the @Comment annotation and your configuration file gets human-readable documentation right there in the YAML. Want to add headers or footers to your generated config file? ConfigLib has that. Want to exclude certain fields or customize how they're named? Yep. Records are fully supported without needing the @Configuration annotation - just drop your record in and it works. Inheritance works too, so you can extend a base configuration class and add specialized options in subclasses. One clever feature: environment variable overrides. You can configure ConfigLib to let environment variables override values in your YAML file. Useful if you're running in containerized environments or want to keep secrets out of your config file. Gotchas and Common Pitfalls The biggest surprise for new users is that fields must have default values. ConfigLib uses reflection to instantiate your class, so if a field doesn't have a default, it'll fail. Make sense once you understand it, but catches people off guard. Static, final, and transient fields are ignored automatically. If you don't want a field in your config, make it one of those instead of adding an @Ignore annotation (though @Ignore works fine too). Watch out with null handling. ConfigLib has customizable null behavior, but the defaults are sensible - fields that are null won't be written to YAML, and when loading, missing fields keep their default values. The documentation on the GitHub wiki is solid, so start there if something behaves unexpectedly. Other Config Solutions Worth Mentioning ConfigLib isn't the only config library out there, though it's genuinely one of the better ones. Some plugins use Bukkit's native ConfigurationSection API, which is built-in but requires more manual work. OkaeriOka is another option if you need YAML with a slightly different approach. For most plugins, though, ConfigLib strikes the right balance between ease of use and powerful features. If you're managing server configs more broadly (and not just plugin configs), minecraft.how has useful tools like the Minecraft MOTD Creator for customizing your server's appearance in the client list. That's a different use case, but part of the bigger picture of server customization. Worth Your Time? If you're writing a Minecraft plugin that needs configuration, ConfigLib saves you time and eliminates whole categories of bugs. The type safety and automatic update handling alone justify pulling it in. A last release (v4.8.1) just landed with improvements to locale handling, and the library's well-maintained with a solid community behind it. Start with the wiki tutorial if you want a step-by-step walkthrough. The learning curve is gentle, and you'll probably find yourself wondering why you didn't use this sooner. Support the project ConfigLib 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.

---

### Minecraft Music and Soundtrack: A Deep Look at the Audio
URL: https://minecraft.how/blog/post/minecraft-soundtrack-music-guide
Published: 2026-04-28
Author: ice

Minecraft's music is one of the most underrated parts of the game. You might not think about it consciously while you're building, mining, or just wandering around. But the moment you disable the audio, the entire experience feels hollow and incomplete. The soundtrack doesn't just fill silence - it defines mood, shapes exploration, and turns a blocky sandbox into something genuinely atmospheric. Why Minecraft's Music Matters Most games throw music at you to avoid awkward quiet moments. Minecraft does something different. Its soundtrack is sparse, minimal, and intentional. Ambient piano melodies drift in and out. Forest biomes hum with gentle strings. Caves feel eerie and vulnerable. It's not trying to pump you up or make you feel powerful. Instead, it creates space for your own thoughts while still keeping you anchored in the world. That restraint is the entire point. When you're deep underground mining for diamonds, that creeping minor-key track makes every sound more ominous. A creeper could be around the next corner. The music doesn't tell you what to feel - it just gently suggests you might want to watch your back. Then you reach a lava lake, and the music drops away entirely, leaving just the crackling ambience. That moment hits different when you've been listening to the underscore the whole time. The music also preserves something essential about Minecraft that other games have lost: the permission to feel bored. Boring isn't bad in Minecraft. Staring at your build for five minutes while a simple piano motif loops is fine. The soundtrack enables that without making it feel empty. It's meditative. The Composers Behind the Game C418 - real name Daniel Rosenfeld - composed almost the entire Minecraft soundtrack over years of development. His work became so foundational to the game that it's impossible to separate his vision from Minecraft's identity. If you've ever heard that iconic piano motif that plays on the main menu, that's C418. If you've felt that unsettling unease creeping around in a deep dark cave, that's C418 too. What makes his work remarkable is its accessibility. These aren't complex orchestral pieces or technically showy compositions. Most tracks use simple piano, basic strings, and minimal percussion. A kid can hum them. But they're not simplistic. There's real emotional architecture underneath. C418 understood that Minecraft isn't about spectacle - it's about creating a mood that lets players feel like the landscape matters. Since the full release, Lena Raine has taken over as the primary composer for new Minecraft content. She brought a different flavor while respecting C418's foundation. Her work tends to be slightly more energetic, with bigger orchestration and more rhythmic drive. Caves and Cliffs introduced some of her best work, and her tracks have become just as iconic as the classics. Both composers understand something crucial: in Minecraft, music is a tool for world-building, not an ego display. Exploring the Soundtrack Albums The Minecraft soundtrack has been formally released across several albums, and if you've never actually sat down and listened to them start to finish, you're missing out. "Minecraft: Volume Alpha" and "Minecraft: Volume Beta" are the main collections, available on Spotify, Apple Music, and pretty much everywhere else. Volume Alpha is the C418 era - all the classics. "Sweden," "Far," "Floating Trees," "Aria Math." If you know these names, they probably hit different now. If you don't, play them while you're building something. You'll understand why Minecraft felt the way it did for so many people. Volume Beta leans a bit more experimental. C418 ventured into some weirder territory here - dissonant piano pieces, tracks that feel deliberately unsettling. It works perfectly for the Nether and End dimension music. Newer albums have added Lena Raine's contributions, and honestly, the shift in composition style is noticeable but not jarring. It feels like the game naturally evolved its soundtrack alongside its gameplay updates. You can listen to the evolution of Minecraft's audio by just chronologically going through the albums. Music Across Different Biomes One of the best parts of Minecraft is how the music changes depending on where you are. Plains biomes get gentle, almost lonely piano. There's nothing threatening about being out in the open grassland. The music reflects that calm openness. Forests are warmer, with softer string arrangements. Oceans have this floating, slightly disorienting feeling that makes water travel feel like genuine exploration rather than just moving to a new chunk. Underground is where things get interesting. Deep underground (which technically includes any cave), the music shifts to something more anxious and minor-key. It's still beautiful, but it has teeth. The Nether absolutely leans into the discomfort. Those tracks sound like something's watching you, and the game becomes tense in a way the overworld never quite is. The End is pure unease - sparse, echo-y, minimal. It's genuinely unsettling in the best way. If you've never really paid attention to how the music shifts as you explore different biomes, try this: go underground with your sound on and full attention for five minutes. Then go back to the surface. The contrast is jarring. That's intentional design. Building in different biomes hits different too. Creating a house in a dark forest where the music is just slightly ominous creates a totally different vibe than building a desert temple where the audio is sparse and open. Customizing Your Audio Experience If you want to completely change your Minecraft audio, resource packs let you swap the soundtrack entirely. Some packs create a dark fantasy atmosphere. Others add more energetic, modern music. You can even find packs that replicate music from other games or add entirely new compositions. The cool thing is that you don't have to commit to just one. If you're working on a project that needs specific energy, swap your music pack for a few hours. Building a spooky castle? There are packs for that. Making a peaceful farmstead? Those exist too. You can also customize individual sound files if you're comfortable with that level of modding. Some players replace specific tracks or add music to areas that didn't have any before. It's one of those quiet features that Minecraft's flexibility enables - you can shape almost every aspect of your experience, including the audio landscape. Just remember that the default soundtrack is there for a reason. If you're new to the game, stick with C418 and Lena Raine for a bit. Let the game teach you what its music is doing. You can always customize later, and you'll appreciate both the originals and your custom tracks more once you understand what made them work in the first place. If you're building elaborate structures and want to match your soundtrack to your build style, you might also want to organize your world using our Minecraft Block Search to find the right materials for your aesthetic. And if you're creating custom signage or decorative elements with text, the Minecraft Text Generator can help you maintain consistency across your builds while your custom soundtrack plays. How Music Shapes Your Minecraft Experience Here's the thing about Minecraft's soundtrack that separates it from basically every other game: it's not trying to manipulate your emotions or push you toward specific actions. It's not a score that emphasizes danger or achievement. It's ambient. It's atmospheric. It gets out of the way while still being present. That's why players who've been into Minecraft for years still feel something when they hear those piano melodies. The music didn't try to make the moment bigger than it was. It just acknowledged it. Now, years later, those tracks have become anchored to specific memories. Your first night in a survival world. That one build you spent weeks on. The friend group multiplayer server that you think about nostalgically even though you haven't played in a year. Good game music does that. It doesn't demand attention. The result earns emotional resonance through restraint and respect for the player's space. Minecraft's soundtrack understood that before most games even considered it. Whether you're playing version 26.1.2 (the latest Java release) or jumping between the latest snapshot and older versions, the music remains consistent in its philosophy. It evolves with new content, but the core principle stays the same: your experience matters more than the audio trying to be impressive.

---

### How to Build a Raid Farm in Minecraft 2026
URL: https://minecraft.how/blog/post/raid-farm-guide-minecraft
Published: 2026-04-27
Author: ice

Raid farms are one of the most efficient ways to get ominous bottles, totems of undying, and all those precious Raid drops without endlessly hunting Pillager Outposts. Building one right is where most people stumble. Let me walk you through the whole process, from scouting to spawning mechanics. What You'll Get From a Raid Farm Here's the thing: raid farms aren't just for the flex. These things pump out totems of undying on demand, which is genuinely life-saving in deep caves or during late-game PvP. You'll also get emeralds by the stack, enchanted books, iron, diamonds, and those ominous bottles everyone's been collecting for potions. If you're running a server with friends, having a communal raid farm changes the whole economy. Suddenly everyone's swimming in resources that would take months to gather normally. The problem is they're finicky to set up right. Finding and Preparing Your Location Scouting for the Right Outpost You need a Pillager Outpost, obviously. But not just any outpost. You want one in an area with plenty of flat ground nearby and ideally away from your main base (raids can get loud, literally and figuratively). Use a seed mapper or just fly around in creative mode first to get a feel for your world. Check our server list if you're playing multiplayer and need suggestions on where communities have been building. The outpost itself sits at a specific Y-coordinate. In Java Edition 26.1.2, make sure you're working with terrain that doesn't have massive height variations nearby, because water will be involved. Clearing and Leveling Clear everything in a massive radius around the outpost. I'm talking 200+ blocks. Remove trees, water, random blocks. Make it flat. Pillagers are picky about where they spawn, and having random terrain will mess with your farm's efficiency. You'll want a completely clear, flat plane for the spawning platform. Understanding Raid Spawn Mechanics This is where people go wrong. Raids don't spawn like regular Pillager patrols. When you trigger a raid with a Bad Omen effect, the game spawns raid waves in specific waves with specific mob types. The waves come in a set order: Pillagers and Vindicators first, then Witches, then ranged units, then melee units again, then some mixed waves. Entities can only spawn on solid blocks, not in water, not in air. This matters because your farm design needs to funnel mobs into a specific area while preventing natural spawning everywhere else. But actually, that's not quite right for what we're building here - you want mobs to spawn on a platform, then fall into a collection system. The key insight: mobs spawn in waves at increasing distances from the Raid Center (usually the Bad Omen player). Building your farm means creating a platform where they naturally want to spawn, then controlling the flow. Building the Farm Structure The Spawning Platform You'll need a flat platform made of spawning blocks (dirt, grass, stone, etc.) roughly 20-30 blocks away from your farm center. This platform should be about 50x50 blocks, but not too close to other surfaces where mobs might spawn instead. The player holding Bad Omen should be positioned so that mobs spawn on the platform and nowhere else. Cover the ground in slabs or glass beyond your spawning area. This prevents strays from spawning during nighttime raids, which they actually do. The Collection System Once mobs spawn on your platform, you need them to fall down into a funnel. A simple system is a 1x1 hole that drops straight down to a killing area. Use water streams to push mobs toward the hole. Flowing water moves entities, so a simple 2x2 channel with water running toward the hole works beautifully. Pro tip: the hole doesn't need to be deep. Witches are the problem mobs because they heal themselves. You want damage to be instant, so suffocation is your friend here. A 2-block suffocation box under the collection point kills everything except witches. For those, use fall damage or lava combined with suffocation. The Killing Chamber Below the collection hole, create a chamber that's roughly 3x3 blocks. This is where mobs land. Add suffocation blocks (use pistons or pushing water to crush mobs against the blocks above). Most mobs die to suffocation after a few seconds. Witches need special handling - use fall damage or lava, though lava burns their drops. For a cleaner system, use drowning with a 1x1 vertical water column. Mobs can't escape, and their drops float to the top where you collect them. Getting the Farm Running Triggering the First Raid Find a Pillager Outpost and kill the Pillagers until one drops a Bad Omen effect (they drop it when killed by a player). Then drink a bucket of milk to get the Bad Omen, head to your farm, and enter a village. Bad Omen + Village = Raid trigger. The first raid spawns 5 waves of increasingly dangerous mobs. Waves 3-5 are where the totems and ominous bottles really show up. Optimizing Spawn Rates Mobs spawn in waves only while you're within a certain distance of the Bad Omen player. If you run too far away, the raid pauses. Stay close, but also get to a safe spot where you can observe or AFK. Many people build an observation tower or afk platform at exactly the right distance. Wave timing matters too. Each wave takes about 20-40 seconds to spawn completely. You don't want to trigger the next raid before the first one finishes, or the waves merge and break your farm. Common Problems and Fixes Mobs spawning in random places? You've got other solid blocks or elevated terrain nearby. Flatten everything within 200 blocks. Witches healing faster than they're dying? Switch to drowning or fall damage only. Lava plus suffocation sometimes doesn't work fast enough. The raid not triggering? Make sure you've the Bad Omen effect (not a status effect potion, but the actual Bad Omen from a Pillager captain). And you need to enter a village with it - an actual village, not just a few houses. Drops disappearing? They despawn after 5 minutes in Java Edition. Make sure your collection system actually pushes items to a hopper or collection point. If you're running a server, use our server properties generator to adjust entity-tracking-range if you need more visibility. Performance Considerations Raid farms can tank server performance if you're not careful. Hundreds of mobs dying simultaneously = lots of particles, sounds, and entity updates. Build your killing chamber away from your main base. Most people put these farms at least 500 blocks away from spawn, sometimes in another dimension entirely if they're really paranoid. If you're playing single-player, just monitor your FPS. If you're on a server, talk to your admins. Some servers disable raids entirely or limit how many can run simultaneously. One more thing - make sure you're actually afk-able during raids. The last thing you need is aggressive mobs chasing you while you're trying to position yourself. Build defensive walls or stay in a 1-block-high tower where Endermen can't reach you. Advanced Optimizations Once you've got a working farm, you can optimize it for speed. Some builders use multiple spawning platforms to get waves starting before previous waves finish. Others use multiple killing chambers to distribute the load. The absolute best farms run multiple raids simultaneously by having several Bad Omen players spaced out, each triggering their own raid. Obviously this requires cooperation and setup, but it's the difference between hundreds of totems per hour versus dozens.

---

### Minecraft Modding Scene: Top Releases of 2026
URL: https://minecraft.how/blog/post/minecraft-mods-2026-biggest-releases
Published: 2026-04-27
Author: ice

2026 is shaping up to be one of the strongest years for Minecraft modding in ages. We're talking about quality-of-life overhauls that actually let you play the game instead of fighting menus, entirely new progression systems that make late-game actually mean something, and visual upgrades that make vanilla Minecraft look like it's from 2012 (which, let's be honest, it kind of is). The modding community is firing on all cylinders. The Big Category Shifts: What's Changed This Year Performance mods used to be niche. Now they're essential. With Minecraft 26.1.2 pushing more particles, more entities, and more everything onto older hardware, the optimization scene exploded. Mods that used to be "nice to have" are becoming "absolutely required if you want 60fps on a three-year-old GPU." What's interesting is how modders have stopped fighting against Mojang's design decisions and started building around them instead. The 1.20-1.21 era saw a shift toward quality-of-life mods that enhance gameplay rather than replace it. Early 2026 is doubling down on that approach. Quality-of-Life Mods: Playable Now Look, vanilla Minecraft is still great, but the tedium is real. You spend half your time managing inventory, navigating menus, or clicking the same rock fifty times. The best QoL mods in 2026 finally address this without breaking immersion. Building infrastructure got the attention it deserved this year. Mods that streamline chest sorting, tool durability tracking, and crafting recipes are now handling the day-to-day repetitive tasks that bog down survival mode. Some actually integrate with custom Minecraft servers for shared storage systems across multiplayer worlds. Storage and Organization Inventory management mods used to feel clunky. The new wave feels integrated into the UI naturally (most of the time). Better chest searching, auto-sorting systems, and refined storage interfaces are standard fare now. Not flashy, but genuinely useful when you're six hours into a survival world and your storage room looks like a tornado hit it. Navigation and Waypoints Minimap mods have evolved beyond just showing where you're. They're mapping your entire world, marking waypoints, tracking mobs, and integrating waypoint data with other mods. The quality jump between 2024 and 2026 is noticeable, especially on servers with dozens of players building simultaneously. Gameplay Overhauls: When Mods Become Core Experiences This is where things get genuinely interesting. The line between "mod" and "total conversion" has blurred significantly. New progression systems launched in early 2026 that completely reimagine how you advance through the game. We're talking about tiered equipment unlocks, boss fights that actually have mechanics, and loot tables that make exploration feel rewarding instead of random. Some of these feel like they should have been in vanilla since day one. Magic systems finally matured. Previous iterations felt tacked on, but this generation integrates spellcasting, mana systems, and magical progression into the core gameplay loop in ways that don't feel forced. Balance between magic and traditional combat isn't perfect yet (it never is), but it's close. Dungeon exploration got serious. Complex procedural dungeons with actual loot progression, environmental hazards, and boss encounters turned what was usually just "find a stronghold" into a genuine adventure. Visual Mods: Looking Good on Every GPU Here's something that surprises people: high-end visual mods actually got lighter this year. Shader packs optimized for modern rendering techniques look stunning without tanking frame rates on mid-range hardware. You've got options now. Ultra-detailed texture packs at 256x or 512x resolution that don't require you to turn off mob AI. Particle effect improvements that are visible but not laggy. The real win? Modders finally stopped making it an all-or-nothing choice. You don't need to go full cinematic mode or accept vanilla graphics anymore. There's a sweet spot where things look genuinely better without requiring a $2000 GPU. Multiplayer Mods: Servers Finally Have Better Tools Server owners have been asking for better admin tools and player management features for years. 2026 brought modular solutions that actually work. Claim systems that don't feel like bureaucracy. Economy mods that let servers run functioning markets without turning into an arcade game. Custom events and seasonal mechanics that keep players engaged across months, not just weeks. If you're running a survival server, the tooling available now is leagues ahead of what existed even twelve months ago. Check out our votifier tester to verify your server's voting is set up properly for plugins that reward votes. Teleportation and Fast Travel Multiplayer servers used to have a problem: the world gets huge, travel becomes a chore, and new players get stuck in spawn. Smart teleportation mods with waypoint systems, train networks, and portal systems solved this without turning servers into theme parks. You're still exploring, it's just not taking forty minutes to reach your friend's base anymore. The Modding Ecosystem Problem (That's Still Being Solved) Real talk: modding Minecraft is still fragmented. You've got Forge, Fabric, Quilt, and various other loaders that don't play nicely together. Q1 2026 saw some attempts to bridge these divides through compatibility layers and shared mod repositories, but we're not there yet. If you're building a modpack, you're still doing detective work to figure out which mods work with which loaders. Progress is happening, just slower than the community wants. That said, the Fabric ecosystem particularly exploded this year. Lightweight, fast, and with a growing library of quality mods, it's become the default choice for people who don't need the heavy Forge feature set. And honestly? Most people don't. What's Next: The Roadmap Looking ahead into mid and late 2026, there's serious work happening on mod compatibility tools, better documentation for modders, and standardized ways to distribute complex modpacks. The meta-game of modding is improving, not just the mods themselves. The biggest releases so far haven't just been about adding features. They've been about making modding less friction-filled, more accessible to casual players, and genuinely fun instead of feeling like you're juggling incompatible systems. If you've been out of Minecraft modding for a year or two, 2026 is absolutely worth jumping back in. The polish level is noticeably higher, the quality-of-life improvements are real, and the creative projects coming out of the community are genuinely ambitious.

---

### Minecraft Map Making Community: Best New Tools in 2026
URL: https://minecraft.how/blog/post/minecraft-map-tools-community
Published: 2026-04-27
Author: ice

Minecraft map making in 2026 is backed by a powerful set of tools that didn't exist a few years ago. Structure blocks, world editors, text generators, and community collaboration platforms have made custom map creation faster and more accessible than ever. Whether you're building a small adventure map or a massive survival world, there's a tool for nearly every part of the process.The Community Has Never Been More ResourcefulThe shift happened gradually. Map makers started sharing techniques on Reddit, Discord servers popped up dedicated to specific building styles, and suddenly people realized they weren't alone in wanting better tools. This collaborative energy pushed developers, both independent and official, to fill gaps. Over on Reddit, there's this beautiful example of the community coming together when a father posted asking for help finding his daughter's lost animal sanctuary map. Hundreds of players showed up with suggestions, techniques, and encouragement. That kind of energy is what drives the tools we've today.What's wild is how much momentum has built since 2025.Structure Blocks Got Serious UpgradesIf you haven't messed with structure blocks much, Minecraft 26.1.2 actually made them worth your time. The interface got cleaned up. They're no longer this cryptic menu that feels like you're piloting a submarine. Now they handle larger areas more smoothly, and the save/load system is less janky overall. But here's the real big deal for map makers: the undo system actually works. Before, if you loaded a structure and it placed wrong, you'd manually dismantle blocks. Now you can just hit undo and try again. Sounds small, but it saves hours when you're iterating on a design.Combining structure blocks with something like the Minecraft Text Generator opens up possibilities that used to require command block wizardry. You can generate custom text, place it as a structure, and use it to label sections of your map, create signage, or build visual narratives. The tool generates the exact coordinates and commands you need, so you're not guessing in-game.World Editors Have Matured FastThird-party world editors have evolved from clunky, crash-prone programs into surprisingly stable tools. WorldEdit (if you're working on a server) and MCEdit-style tools now handle massive terraforming operations without melting your CPU. Some can batch-process terrain, copy entire biomes, and apply filters that would take weeks to sculpt manually. MCEdit variants still dominate for pure map creation. They let you load a world, edit sections, and export cleanly.WorldEdit plugins are essential if you're building on a multiplayer server. The command syntax is intimidating at first, but once you learn brush commands and selection tools, you're unstoppable.Terrain generation tools now use noise algorithms that feel almost as good as Minecraft's native generation. Some builders use these to pre-sculpt terrain, then load it into Minecraft for finishing touches.The real shift is that these tools no longer feel hacky. They're stable. They're documented. Developers actually maintain them.Custom Skins and Visual IdentityIf your map has NPCs or custom characters, you probably care about how they look. This is where the Minecraft Skin Creator comes in handy. You can build custom character designs without needing to be an artist. The tool gives you templates and intuitive controls so you're not wrestling with sprite sheets. For map makers, this means you can quickly create distinct-looking characters for quests, bosses, or story sequences. Consistency matters, and having a straightforward way to generate skins that fit your map's visual style keeps everything cohesive.Building diverse NPCs takes seconds instead of hours.Collaboration Platforms Flipped the ScriptMap making used to be solitary. You'd spend weeks building, then dump your world file hoping people played it. Now there are platforms where map makers share works-in-progress, get feedback, and collaborate on massive projects in real time. Servers dedicated to building communities let multiple creators work on the same world. Git-style version control for Minecraft worlds exists (yes, really), so you can revert mistakes, branch off ideas, and merge contributions. A few community platforms have popped up that handle the technical side, so you don't have to manually manage file swaps on Discord.The collaborative aspect has genuinely changed how maps get made. What used to be one person's solo vision now often becomes a team effort.What's Worth Your Time Right NowIf you're just starting with map making, you don't need all of these. Start with structure blocks in vanilla Minecraft and the text generator to experiment with layouts. Learn how commands work. Build something small.If you're running a multiplayer server, WorldEdit is non-negotiable. It cuts build time by months. If you're making a narrative map with custom characters, the skin creator saves you from art tutorials and sprite editing.The best tool is the one you'll actually use. Pick something, dive in, and skip the analysis paralysis.

---

### Build Realistic Flying Machines with Create Aeronautics
URL: https://minecraft.how/blog/post/create-aeronautics-minecraft
Published: 2026-04-27
Author: ice

furukola/Create-Aeronautics-Minecraft-Mod-ALL-Versions Create Aeronautics is an advanced aviation expansion for the Create Mod. It introduces real-world physics and aerodynamics to Minecraft. Build functional airships and planes with realistic lift and mechanical integration. Experience the ultimate engineering challenge in the skies of 2026. Want to actually fly in Minecraft? Not with elytra or creative mode, but by engineering a proper aircraft with real physics underneath? Create Aeronautics lets you build functional airships and planes where lift, drag, and thrust actually matter. It's the mod you didn't know you needed if you've ever stared at the sky and thought, "I bet I could make that work." What Create Aeronautics Does This mod adds a physics engine on top of the Create Mod that handles real-world aerodynamics. Your planes don't magically hover (or they do, but only if you engineer them right). You're building vessels with actual weight, balance points, and lift calculations. Wings generate lift based on airspeed and angle of attack. Propellers create thrust. The center of mass matters because it actually affects whether your creation crashes immediately or soars gracefully. It's not just flying though. You're still working within Create's mechanical systems. You need to power your aircraft, route mechanical energy to your propellers, balance thrust across multiple engines. Your first successful flight will feel earned because, honestly, it's. When You'd Use This Mod Picture this: you've spent three months building a massive floating city. Now what? Teleport between platforms? Boring. With Create Aeronautics, you build an airship to navigate between districts. Real exploration. Real engineering problems to solve. Or maybe you want to create a functional airline system across your server. Different aircraft for cargo versus passengers. Designated flight lanes. Actual transportation instead of instant travel. One server I've seen built an airport with hangars, fuel stations, and a control tower (which... doesn't do anything mechanically, but looks incredible). You could also just go completely freeform and build things because they're cool. A biplane that actually flies. A massive cargo zeppelin. A fighter jet that turns faster than it should, technically, but who's checking? Installing Create Aeronautics First, you need the Create Mod itself. If you're running Minecraft 26.1.2 (the latest stable release), grab Create from CurseForge or Modrinth. You'll also need Architectury API and Flywheel - both are listed as dependencies. Download CreateAeronautics.zip from the releases page. Extract it into your mods folder. bash~/.minecraft/mods/CreateAeronautics.zip Launch the game and check your mods list to confirm it loaded. If your ship won't fly, the README's troubleshooting table points out the usual suspects: missing Create updates, center of mass issues, or insufficient thrust-to-weight ratio. That last one trips people up - your engines need to generate enough force to lift your design, which sounds obvious until you're standing on a 500-block airship with three tiny propellers wondering why nothing happens. One thing I'd add: if you see visual glitches with flying parts, check whether you've got conflicting shader packs. Iris and Oculus shaders work fine, but mixing certain mods can cause rendering issues. Key Features Worth Understanding Thrust and Propulsion - Create Aeronautics uses mechanical power to spin propellers. Your power source (rotational force from Create's systems) gets transmitted through bearings and shafts to propeller blocks. More speed equals more thrust, but there's diminishing returns. You're balancing fuel efficiency against climb rate. Aerodynamic Lift - Wings actually work. The faster your aircraft moves horizontally, the more upward force wings generate. This is why stubby, heavily-loaded aircraft need long runways, and sleek ones can climb steeply. It takes practice to internalize the relationship between wing size, speed, and how much weight you can carry. Control Systems - You steer using mechanical controls connected to control surfaces. Ailerons for roll, elevators for pitch, rudders for yaw. It's absolutely not intuitive if you've only flown with elytra (where you just... aim). You need to think like a pilot. Dive too steep and you can't pull up because you don't have enough speed for the wings to generate lift. Weight and Balance - Every single block has mass. Your cargo, your engines, your fuel tank - it all matters for whether this thing stays in the air. The center of mass needs to be roughly under your center of lift, or you'll spin uncontrollably. Yes, I learned this the hard way. Twice. Realistic Wind - If the mod has wind mechanics (some versions do, some don't depending on your installation), crosswinds will push your aircraft sideways. Fun if you're prepared for it. Disastrous if you're not. Common Gotchas and What Fixes Them Your ship crashes immediately. Check two things: is the center of mass actually below the center of lift? Most common failure. Second, do you've enough thrust? A 50-ton airship with 200 newtons of propulsive force isn't going anywhere. The mod won't load at all. Dependency issue. You're missing Architectury API, or you've Create version 0.5.0 when you need 0.5.1+. Version compatibility is the boring answer to 90% of mod problems. Everything renders as purple and black. Shader conflict. Disable resource packs or shader packs until you find which one breaks it. Flight controls feel sluggish. This is usually because you need to bind flight-specific controls in the Keybinds menu. Default controls might not be comfortable for flying. Similar Projects Worth Considering If Create Aeronautics feels too demanding or you want something more arcade-like, Immersive Aircraft is simpler - no physics simulation, just straightforward plane building. It's fun but less rewarding once you understand real aerodynamics. Alternatively, if you want to focus purely on aesthetic flying contraptions without worrying about whether they're aerodynamically plausible, Create's basic contraptions work fine. You can use Create alone to build moving structures that fly by pure mechanical creativity. For servers, you might also want to pair this with a custom spawn system or a server properties customization tool. If you're setting up a public server with flight zones, you'll need clear rules about where people can and can't fly. Check out the Server Properties Generator to set spawn points and flight restrictions, or use the Minecraft MOTD Creator to announce your flight server's rules to joining players. Is It Worth Your Time? If you enjoy solving engineering problems and don't mind a learning curve, absolutely. If you want instant gratification and pure flying freedom, maybe not. This mod rewards patience and experimentation. Your twentieth aircraft will fly beautifully because you finally understand the balance between weight, wing surface area, and thrust. The community around Create Aeronautics is small but active. You'll find people sharing designs, troubleshooting weird physics bugs, and sometimes just showing off absurdly over-engineered aircraft. That's where the real fun starts. 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

---

### Endstone: Paper Server Power Now for Bedrock
URL: https://minecraft.how/blog/post/endstone-bedrock-server-setup
Published: 2026-04-27
Author: ice

GitHub · Minecraft community project endstone (EndstoneMC/endstone) High-performance Minecraft Bedrock server software with native C++ and Python plugin API Star on GitHub ↗ pache-2.0 Ever wanted to run a Bedrock server with the customization power of Java Edition's Paper? Endstone fills that gap, giving you plugin support and deep server control while keeping vanilla compatibility intact. What Endstone Does Let's be honest: vanilla Bedrock servers are limited. You can't cancel events, control packets, or modify core gameplay the way you can with Paper or Spigot. Endstone changes that by sitting between you and Bedrock itself, intercept events, and offering a full plugin API. It's not an addon system or a script engine. It's a proper server wrapper with the architectural power Java players have had for years. The cool part? It's genuinely a drop-in replacement. Your world files, your configs, your existing Bedrock setup - they all work. You don't need to migrate anything. Just install Endstone, point it at your world, and start loading plugins. The underlying Bedrock server runs unchanged underneath, so vanilla features stay intact and reliable. Under the hood, this is C++ doing the heavy lifting. The project's got 623 GitHub stars and active development (latest version supports Bedrock 1.26.12). That plugin API itself leans on design patterns familiar to Bukkit developers - if you've written Paper plugins before, the mental model will click immediately. Why You'd Use This The obvious case: you're running a Bedrock server and want to add custom commands, permissions systems, or gameplay mechanics without coding your own addon from scratch. Endstone handles the infrastructure - events, scoreboards, forms, inventory access, player data - so you can focus on logic. Concrete examples. Say you want a leveling system where players gain XP and unlock commands. In vanilla Bedrock, you're fighting against addon limitations. In Endstone, you write an event handler that listens for player damage, calculates XP, updates a scoreboard, and grants permissions dynamically. A few dozen lines of Python and you're done. You could implement a full economy system, custom combat mechanics, dungeon events, or ranked PvP matchmaking. Another angle: cross-server connectivity. You're running Bedrock but you want players to join from Java Edition servers via proxy tools. Endstone's packet control lets you intercept and modify join sequences, cosmetics, and other cross-version friction. It's not smooth out of the box, but it's possible in ways pure vanilla Bedrock isn't. Windows or Linux. Docker support exists. Python 3.10+ on Windows 10+ or Ubuntu 22.04+ / Debian 12+. That's flexible enough for most hosting setups. And if you need C++ performance for a critical plugin, the API supports that too. Getting Started Installation is three commands: bashpip install endstone endstone That's it. Python package manager pulls the release binary (Windows or Linux depending on your platform), and running `endstone` starts the server in your current directory. It'll generate a server config and a `plugins` folder. For your first plugin, create a Python file in that folder. Here's the bare minimum: pythonfrom endstone.plugin import Plugin from endstone.event import event_handler, PlayerJoinEvent class MyPlugin(Plugin): api_version = "0.10" def on_enable(self): self.logger.info("MyPlugin enabled!") self.register_events(self) @event_handler def on_player_join(self, event: PlayerJoinEvent): event.player.send_message(f"Welcome, {event.player.name}!") Drop it in `plugins/`, restart the server, and you'll see "MyPlugin enabled!" in the logs. Players joining get a welcome message. That's the entire feedback loop. The project provides templates for both Python and C++ if you want a scaffolded structure. But honestly, the bare plugin example above is small enough that you can copy it and start experimenting. What Makes It Powerful The API surface is substantial. We're talking 60+ events covering players joining, breaking blocks, taking damage, opening inventories, chatting, and more. Commands work with Bedrock's built-in command parsing (no custom string parsing required). You get scoreboards, forms (the interactive UI system), permissions, inventories, and access to player metadata and world data. Packet control is where Endstone breaks away from other solutions. You can listen to low-level network packets before the server processes them. That opens doors to anti-cheat, cross-version compatibility hacks, and fine-grained event cancellation. Modify a packet mid-flight and the change propagates through normally. Stay compatible with the latest Bedrock automatically? Design philosophy favors keeping up with Minecraft's monthly releases instead of playing catch-up. The v0.11.3 release added BlockType registry support and fixed several packet serialization bugs that were causing disconnects. That's the pace you're looking at - quick iterations keeping the API current. Things That Catch People Python plugins are convenient but slower than C++. If you're building something that runs on every tick for thousands of players, C++ is your answer. But for events that fire occasionally (player join, chat, custom commands), Python is fast enough. Worlds created in pure Bedrock will work, but if you have existing realm backups or world-specific data outside the level folder (like realm backup metadata), you may need to migrate manually. Endstone handles the world format natively - it's just the surrounding infrastructure that sometimes needs adjustment. Also, know that you're running a Bedrock server, not Java. That matters for plugin availability. Many popular Java plugins (Essentials, Vault, fancy chat formatting libraries) have no Bedrock equivalents. You'll write more from scratch. The community is smaller but growing, and the official template repos give you starting points. How It Stacks Against Alternatives PocketMine and Nukkit are older Bedrock server implementations. They don't run vanilla Bedrock underneath - they reimplement the server from scratch. That's more control but more maintenance, slower updates, and sometimes subtle differences in behavior. Endstone wraps real Bedrock, so vanilla features are guaranteed. Addon scripting is official and limited on purpose. It's great for cosmetics and simple logic, but can't hook into server-level events or permissions. Endstone is the play if you need control. If you're on Java Edition, Paper (or Spigot/Bukkit) is still the gold standard and always will be. Endstone is specifically for Bedrock communities that need plugin infrastructure. Real-World Setup Notes Run it in Docker for cleaner isolation and easier updates. Run it behind a reverse proxy if you're exposing it publicly (Bedrock uses UDP, so your firewall config matters). And before deploying anything to production, test your plugins locally. Endstone's development setup is straightforward enough that you can iterate on a laptop. For hosting a public server, consider using the Free DNS tools we offer at Minecraft.How's free DNS service to manage your server domain reliably and cheaply. And if you're maintaining a whitelist, the Minecraft Whitelist Creator streamlines generating and managing your player list. Check the Discord community (linked on the GitHub repo) before you get stuck. The maintainers respond quickly, and you'll find plugin examples and deployment advice from people running live servers. Support the project endstone 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.

---

### OPanel: Minecraft Server Management in 2026
URL: https://minecraft.how/blog/post/opanel-minecraft-server-management
Published: 2026-04-27
Author: ice

opanel-mc/opanel A Minecraft server management panel for Bukkit / Spigot / Paper / Folia / Leaves / Fabric / Forge / NeoForge servers .0 If you've ever tried managing a Minecraft server from the console alone, you know the pain. Commands get buried in chat spam, player actions take forever to process, and a quick backup becomes a 10-minute console hunt. OPanel fixes that. It's a web-based admin panel that turns server management into something you can actually do from a browser, with real-time dashboards, one-click player management, and terminal access all in one place. What This Project Does OPanel is a lightweight Java plugin that sits on your Minecraft server and exposes a clean web interface for everything an admin needs to do. Run it on Bukkit, Spigot, Paper, Folia, Leaves, Fabric, Forge, or NeoForge servers, and you get instant access to a control panel right from any browser. No config wizards or overwhelming dashboards - just straightforward tools that do what you'd expect them to do. The plugin handles the backend heavy lifting while the web UI (built with React, if you're curious) stays lean and responsive. You can manage worlds, players, plugins, and logs without touching the server console ever again. Why You'd Use It There are a few different reasons this matters depending on what kind of server you're running. If you're running a vanilla or modded survival server with friends, OPanel saves you from constant server restarts just to tweak a gamerule or kick someone AFK. The gamerules editor alone is worth it - toggle difficulty, PvP, mob spawning, whatever, without a single slash command. And the saves manager means you can upload new world downloads or manage backups without FTP access or command-line file editing. For server networks or public servers, the player management suite becomes crucial. Ban someone, whitelist new players, change permissions, send kick messages - all from the browser. The built-in terminal lets you execute commands without giving people direct console access, which is a genuine security win. You can also view inventory contents for suspected rule-breakers, which is genuinely useful for catching contraband or stolen items in survival. And if you run a server farm or want to show real-time status on a website, there's an Open API feature that broadcasts your server's current player count, online status, and other stats. Small detail, but it's the difference between a professional server presence and a static webpage that hasn't been updated in three years. How to Install Installing OPanel is straightforward if you know where to drop a plugin jar. Head to the releases page and download the build that matches your server version. Recent versions support anything from 1.16.1 up to 1.21.9, with separate builds for each major release. Drop the jar into your server's plugins folder: bashcp opanel-bukkit-1.21-build-1.2.1.jar /path/to/server/plugins/ Restart the server, and OPanel will generate its config files and set up a default user. The default port is usually 8080, so you'd access it at http://your-server-ip:8080. Change the port or enable HTTPS in the config if you're exposing this to the internet (you should be). If you're on an older version like 1.19.4 or 1.20, there's a separate build for that too. Just match the jar filename to your server's version number and you're done. Key Features and How They Work Dashboard and Real-Time MonitoringThe first thing you see is a dashboard that pulls together your server's vital signs: TPS, player count, RAM usage, chunk loading, all live. It's genuinely useful for spotting when something's tanking performance before players start complaining about lag. The layout is clean enough that you're not squinting at a wall of numbers. Player Management SuiteThis is where OPanel shines for multiplayer. You get a full player list with the ability to kick, ban, or change permissions without typing. There's also a separate banned players list and whitelist manager, so you can control access without needing external plugins. The NBT viewer for inventories is particularly handy - catch someone with enchanted netherite they shouldn't have, and you can see exactly what they're carrying. Plugin and Mod ManagementEnable or disable plugins and mods without restarting. Well, some mods don't reload cleanly, so YMMV on the mod side, but the plugin system is solid. You get detailed info about each plugin too - version, author, description - all pulled from the jar metadata. Beats clicking through your mods folder wondering what everything does. Server TerminalExecute commands directly from the web panel. There's a reason this matters: you can give people dashboard access without giving them console access. A trusted moderator can kick players or restart the server without being able to type random commands into the console. The command history is logged too, which helps with accountability. Saves and BackupsUpload, download, or delete world saves through the browser. Useful for rotating between seasonal worlds or making manual backups before major updates. You can also enable/disable individual saves without moving files around, which is a small thing that saves actual time. Practical Setup Tips A couple things to know before you go live with this. Secure your panel. If you're accessing it from the internet, use a reverse proxy with SSL (Nginx, Cloudflare, whatever). The default setup is fine for local networks, but leaving an admin panel exposed over HTTP is asking for trouble. Also, change the default password in the config immediately after first startup. Be aware that OPanel runs on the same JVM as your server, so it uses some of your server's RAM. Nothing dramatic, but if you're on a tight memory budget, check your server startup logs to see what the impact is. The plugin system for command execution is solid, but understand that you're still limited by what the server actually supports. Some admins expect to do things through the panel that only work with specific third-party plugins or mods. OPanel itself won't add those capabilities - it just makes them easier to access. If you're running a network with multiple servers, you'd need to install OPanel on each one separately right now. There's no built-in multi-server dashboard, so keep that in mind when planning your setup. Alternatives and How OPanel Compares There are other server management panels out there. Pterodactyl is popular for hosting providers and large networks, but it's overkill for a single server and requires a separate host running the panel daemon. Crafty Controller is lighter and self-hosted, which is closer to OPanel's philosophy, but OPanel installs as a plugin, meaning zero extra infrastructure. For vanilla-only servers, some admins just use Fabric server-side mods or Bukkit plugins that handle specific tasks. You'll spend less time on setup, but you'll also spend more time at the console. OPanel's value proposition is that it pulls everything together in one place. If you need to check your server settings and build a custom server.properties file, the Server Properties Generator pairs well with OPanel's gamerules editor - one tool for static properties, OPanel for runtime changes. Similarly, if you're managing a Nether farm or planning cross-dimensional builds, having the Nether Portal Calculator open in a separate tab beats trying to do the math in your head while the server's running. Worth Your Time? OPanel is genuinely solid for anyone running a small to medium Minecraft server. The 243 GitHub stars suggest a stable project with actual adoption, and the recent 1.2.1 release shows active maintenance. MPL-2.0 licensed, so it's open-source and you can audit the code if you want. It's not flashy, and it won't solve every admin headache, but it takes the most repetitive parts of server management and makes them genuinely frictionless. If you're tired of typing commands into console, it's worth 10 minutes to set up. 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

---

### Making Mobs Matter: How LevelledMobs Transforms Your Minecraft Server
URL: https://minecraft.how/blog/post/levelledmobs-minecraft-plugin-guide
Published: 2026-04-27
Author: ice

"Level-up mobs on your Spigot/Paper server, RPG-style!" ArcanePlugins/LevelledMobs · github.com .0 Want mobs that actually pose a real threat at any point in your server's lifecycle? LevelledMobs scales mob difficulty based on location, time played, or custom rules, so your server never feels too easy or impossibly hard. It's the plugin that makes progression matter. What This Plugin Does LevelledMobs lets you scale mob difficulty across your Spigot or Paper server. Mobs gain levels, health, damage, and loot based on whatever rules you set. A zombie near a player with full diamond gear plays entirely different from one near a fresh spawn. The plugin isn't just slapping bigger numbers on mobs and calling it a day. It's genuinely configurable. You can tie mob levels to the player's progression, server playtime, world regions, custom tags, or even nearby structure types. Want skeletons harder in dungeons and easier on grasslands? Done. Need zombie difficulty to scale per-player based on their best armor? Also done. What makes LevelledMobs stand out is how much it respects server custom. Rather than forcing one difficulty curve, it lets you define the rules. Some servers want pure progression-based scaling. Others prefer location-based difficulty zones. A few want combination systems that blend multiple factors. Why Your Server Needs Mob Leveling Vanilla Minecraft has exactly one difficulty setting. It's global, binary, and doesn't care whether your player base is day-one fresh or built up with enchanted gear. This creates a weird progression arc. Early-game survival feels right - you're scared of creepers, caves are dangerous, night is genuinely threatening. But by week two, zombies are mosquitoes. By month two, you're speedrunning dungeons in full netherite with enchantments. Some servers just accept this and adjust via gameplay loops (farther out means harder terrain, more dangerous caves, custom mobs). Other servers crumble because new players can't survive and veteran players are bored. LevelledMobs fixes the fundamental problem: combat difficulty that matches your player base's actual power level. New players get reasonable early challenges. Veteran players get enemies worth their time. Everyone stays engaged longer. You'll notice players actually use armor and potions again instead of running at every mob with naked fists and no shield. Installation and Setup Setting up LevelledMobs is straightforward if you've worked with Spigot plugins before. Grab the latest JAR from the HangarMC repository or SpigotMC. Drop it into your plugins/ folder and restart your server. bash# Stop your server first./stop.sh # Copy the JAR to plugins folder cp LevelledMobs-4.5.2.b146.jar plugins/ # Start the server./start.sh On first launch, LevelledMobs generates its config folder at plugins/LevelledMobs/. The default settings are safe - mobs scale based on average player level, which works for most servers. If you want to customize (and you probably do), edit config.yml in that folder. YAML syntax matters, so indentation is critical. After making changes, reload without restarting: bash/lm reload The official wiki documentation is detailed. You'll want it handy for setting up custom rules beyond defaults. Key Features That Stand Out Per-Mob Customization Every mob type gets its own rules. Creepers can scale differently than endermen, which scale differently than custom variants. Define health scaling, damage multipliers, and loot tables per species. Location-Based Difficulty Zones Want a dangerous mining depth? Set harder scaling below Y-level 0. Custom dungeons? Tag chunks and apply different rules. Forest biome easier than a nether fortress? Absolutely. Custom Attribute Modifiers Version 4.5.2 and later add attribute modifiers beyond basic damage and health. Scale mob speed, knockback resistance, and attack cooldown. A boss-level creeper actually feels dangerous when scaled properly. Mob Groups for Complex Rules Group mobs by tag, biome, or custom criteria. Apply rules to "all flying mobs" or "all undead mobs" as a single set. Changes to the group apply instantly without restarting. Equipment and Loot Progression Scaled mobs wear progressively better gear as their level increases. A level-20 zombie shows up in iron armor with an iron sword. Loot scales too, so players get rewarded for fighting harder mobs. Common Mistakes and How to Avoid Them Scaling mob difficulty too aggressively kills new player retention. Jumping from level 1 to level 50 over two weeks feels unfair, not earned. Test with fresh players before going live on your public server. Some mobs need special treatment. A creeper's damage scaled 5x creates real problems - one explosion can destroy your storage room. Cap damage on certain mobs or use alternative scaling rules. Read the wiki recommendations before randomizing. Loot progression matters. A level-50 mob dropping level-1 items feels completely broken. Actually configure scaling loot tables so rewards match difficulty. Players notice immediately when this is wrong. Configuration conflicts happen when multiple rules trigger on the same mob in the same location. The last rule applied wins, creating confusing behavior. Document your rule order and test overlapping scenarios. Make backups before big config changes. One syntax error or typo can turn all mobs into level 1 (or level 999) on reload. Keep copies of working configs. Finding Your Server's Balance The Minecraft Server Status Checker helps you monitor how many players are online when testing difficulty spikes. You can also use the Minecraft MOTD Creator to advertise your progression-based difficulty in your server's MOTD. Your actual balance point depends on whether you're running PvP, survival, RPG, or creative-focused gameplay. Raid servers need harsher scaling. Casual survival benefits from gentler progression. Experiment and ask players for feedback - they'll tell you if mobs feel fair. Alternatives Worth Considering CustomBosses is simpler if you only need to customize specific mobs or boss encounters. It's less flexible but easier to learn for basic use cases. Mythic Mobs is more powerful overall with custom AI, animations, and skills. But it's overkill if you just want level scaling and heavier on server performance. MobStacker solves a different problem entirely (combining mobs into stacks for performance optimization), not really the same category - but worth knowing if you're optimizing mob spawning. Most servers using multiple systems combine LevelledMobs with one of those others, not one alone. LevelledMobs handles the difficulty scaling while the others handle specialized encounters or performance. Ready to try LevelledMobs? 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 ArcanePlugins/LevelledMobs on GitHub ↗

---

### bStats: Understanding Minecraft Plugin Data
URL: https://minecraft.how/blog/post/bstats-minecraft-plugin-analytics
Published: 2026-04-27
Author: ice

Bastian/bStats bStats collects data for plugin authors. It's free and easy to use! Ever wondered what Minecraft plugins are most popular? Or what Minecraft versions most servers actually run? bStats answers these questions automatically by collecting anonymized data from plugin installations across the entire Minecraft server ecosystem. It's free, open source, and already gathering statistics from millions of servers worldwide. What bStats Does At its core, bStats is a data collection platform designed specifically for Minecraft plugin developers. When you integrate a simple library into your plugin, it automatically starts reporting statistics back to bStats servers. And that data gets aggregated, visualized, and made available on public dashboards where anyone can see trends in the plugin ecosystem. The bStats project itself is open source (MIT licensed) and maintained on GitHub as a parent repository containing several submodules: the backend infrastructure that receives and stores data, the web frontend where you view charts and statistics, a data processor that transforms raw data into metrics, and libraries for both Java-based plugins and PocketMine-MP. The entire stack runs in Docker, making self-hosting possible if you need complete infrastructure control. Most plugin authors don't need to self-host anything. You simply integrate the bStats metrics library into your plugin, and your statistics automatically flow to bstats.org, where dashboards are free to view for anyone interested in ecosystem trends. What makes this interesting is that all the data is completely public. No private dashboards, no paywalls, no account gates. Why Plugin Developers Use This Plugin developers are flying blind without data. You release a plugin, people download it, and then what? Are servers actually installing it? Are they upgrading to new versions? What Minecraft versions do your actual users run? bStats answers these questions with hard numbers. You get metrics like total server count (how many servers have your plugin installed), player count (how many players interact with it), Minecraft version distribution, and server software breakdown. Over time, these metrics show growth patterns, adoption curves, and whether your user base is growing or declining. The version distribution data is particularly valuable. If you see that 85 percent of your user base runs Minecraft 1.20 or newer, you can confidently deprecate support for older versions. And that frees up development time for features your actual users care about. Custom metrics let you track data specific to your plugin's functionality. An economy plugin might track total currency in circulation. A dungeon plugin might track which dungeons are most visited. A minigames plugin might track which games are most popular. You control the metrics that matter to your plugin. And here's what many developers miss: bStats tracks plugin dependencies. You can see which libraries are genuinely critical to the Minecraft ecosystem and which are niche. This data informs decisions about which dependencies to take on. Privacy, Security, and Opting Out All data is aggregated and completely anonymous. You cannot identify individual servers. A plugin installed on just three servers shows aggregate trends, not raw server data. Server owners can disable bStats by setting a single config option in the plugin's configuration file. Collection stops immediately with no other impact on plugin functionality. Data transmission happens asynchronously in the background roughly once every 30 minutes using minimal bandwidth. Technically, bStats is open source with publicly visible source code on GitHub. You can inspect exactly what gets collected and how it's processed. No black boxes. Getting Started with bStats The experience depends entirely on what you're doing. If you're a server owner running plugins, you probably don't need to do anything. Modern plugins that support bStats handle integration automatically in the background. Zero configuration required. If you ever want to disable it, you can usually just add one line to a plugin's config file. You can browse public bStats dashboards right now without any account. Visit bstats.org, search for any popular plugin, and you'll see real-time statistics about adoption, Minecraft versions, and custom metrics. If you're a plugin developer, adding bStats is intentionally simple. For Java plugins, you add a Maven or Gradle dependency to your build configuration, then add a few lines of code to your plugin's startup method. bStats maintains separate libraries for different server platforms (Paper, Spigot, Bukkit, Bungeecord), so you pick the right one for your target. Here's what basic Java integration looks like: javapublic void onEnable() { //... other plugin initialization code... int pluginId = 12345; // Replace with your actual bStats ID new Metrics(this, pluginId); } Once deployed, bStats automatically starts collecting and reporting metrics. Advanced setups let you register custom charts, but the basic integration requires almost no code. PocketMine-MP developers have a separate PHP-based metrics library that works the same way. What Data Does bStats Track? Server count is the most basic metric: how many active servers have your plugin. Paired over time, you see whether your plugin is growing or declining. Players count tracks how many players across all servers interact with your plugin. A popular plugin on a 1,000-player server counts as 1,000 players, while the same plugin on a 10-player server counts as 10. Together with server count, this tells the full adoption story. Minecraft version tracking shows exactly which versions your user base runs. Over a few weeks you see distribution patterns: maybe 60 percent run 1.20.4, 30 percent run 1.21, and 10 percent run older versions. And this directly informs compatibility decisions. Server software tracking shows adoption of different platforms. Is your ecosystem mostly Paper, Spigot, or a mix? bStats shows you exactly what your user base uses. Custom metrics are completely up to the plugin author. A PvP plugin might track player kills and deaths. A survival game might track games played and average duration. You only report metrics relevant to your plugin's functionality. All of this data is aggregated and displayed publicly. Anyone curious about Minecraft plugin trends can browse and explore. Common Questions and Gotchas Does this slow down my server? No. bStats operates asynchronously on a separate thread. Data transmission happens roughly every 30 minutes and is just a few kilobytes. Completely unnoticeable on modern connections. Can server owners disable it? Yes, through the plugin's config file. So it stops immediately with zero other impact. What if the bStats service goes down? Your plugin continues running normally. bStats is optional infrastructure, not critical to functionality. One important caveat: bStats data represents a sample of the ecosystem, not the entire picture. Not every plugin integrates bStats, so version distribution data shows servers running bStats-enabled plugins, which might not be identical to all Minecraft servers. That said, for popular plugins the sample is pretty representative. There's usually a few hours lag between when servers report data and when it appears on dashboards. Alternatives and Where bStats Fits bStats has no real competitor in the Minecraft plugin analytics space. Some plugins maintain proprietary telemetry, but that requires significant infrastructure work. Other Minecraft tools track different data entirely (block changes, player actions, economy transactions). If you're trying to understand your server's performance generally, tools like the Minecraft Server Status Checker and the Minecraft Server List help you benchmark against other servers. But for genuine insights into plugin adoption and ecosystem-wide trends, bStats is the only real option. Could you run your own analytics? Sure. bStats is open source and can be self-hosted. But self-hosting adds complexity, and most developers find the public service meets their needs perfectly. bStats exists in that perfect sweet spot of being genuinely useful, completely free, and low-friction. Plugin developers get actionable data without maintaining infrastructure. The entire plugin ecosystem moves smarter and faster because developers make data-driven decisions. Server owners benefit from better-maintained plugins. It's infrastructure that's so well-designed it becomes invisible. Support the project bStats 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.

---

### Building Your Own Minecraft Adventure Map: A Complete Guide
URL: https://minecraft.how/blog/post/minecraft-adventure-map-complete-guide
Published: 2026-04-27
Author: ice

Adventure maps are custom Minecraft worlds designed to guide players through a curated experience, complete with quests, puzzles, and storytelling. Unlike survival mode where players make their own fun, adventure maps are your chance to craft a specific journey with challenges, rewards, and narrative structure. Making one requires planning, building skill, and understanding game mechanics - but the result is genuinely worth the effort. Understanding Adventure Map Basics An adventure map isn't just a pretty build. It's a complete experience you're designing for other players to enjoy. Think of it like directing a video game: you're setting up scenarios, managing pacing, and controlling what players encounter and when. The key difference between a good adventure map and a forgettable one? Intention. Every block placement, every redstone circuit, every item you place should serve the experience. Decorative buildings are fine, but they work best when they tell the story or hint at what comes next. Most adventure maps fall into these categories: parkour challenges, puzzle dungeons, quest narratives, survival challenges, or hybrid mixes of all four. Your first map doesn't need to be huge or overly complex. A small, well-executed puzzle dungeon beats a massive world with 50% empty space. What You'll Need Surprisingly little. Minecraft 26.1.2 (the current Java Edition release) has everything built in. You don't need mods, plugins, or external tools unless you want advanced features like custom NPCs or complex economy systems. But that said, a few things make the process smoother: WorldEdit for copy-pasting structures and clearing large areas A schematic tool like MCEdit or Litematica for saving and importing pre-built sections NBTExplorer if you need to edit map item data or hidden values Your own patience and a working understanding of redstone basics Honestly? You can build a solid adventure map with just vanilla creative mode and knowledge of command blocks. The extra tools just speed things up. Planning Your Adventure Map This step separates the "wow, that's cool" maps from the "wait, what am I supposed to do here?" maps. Spend actual time planning before you place a single block. How to Make a Portal in Minecraft: A Comprehensive Guide Start by defining the core experience. Is this a 15-minute puzzle, or a two-hour story-driven quest? Who's the intended player? (Speedrunners optimizing for time, families playing together, experienced builders looking for a challenge?) The answers shape every decision you make. Write down the progression flow. Level 1 teaches mechanics. Level 2 builds on them. Level 3 combines everything into a climactic challenge. This sounds basic, but you'd be surprised how many maps jump between difficulty levels randomly. Sketching Your World Layout Grab paper or a simple digital mockup tool and sketch the layout. Where does the player spawn? Where's the first puzzle? The final boss room? Mark safe zones, dangerous sections, treasure rooms, and spawn points. This doesn't need to be artistic - it's just a map for you. Think about pacing and visuals. If someone travels through the same dark corridor for five minutes, they'll get bored. Mix environments: dark underground, bright outdoor areas, cramped spaces, open vistas. Contrast keeps players engaged. Consider using a central hub area where players can rest, access hints, or choose between different challenge paths. This gives players agency (which they love) and lets you control difficulty progression. Building the World and Structures Now the fun part: actual construction. This is where most of the time goes, but it's also where the magic happens. how to make a chickney farm in minecraft Start with terrain. Flat maps are boring. Use World Painter or terrain generation tools to create interesting landscapes, or manually sculpt terrain using commands like WorldEdit's brush tools. Varied elevation makes exploration feel less linear. Build landmark structures that guide players without obvious signs. A distant tower hints at the next area. A broken bridge suggests the player needs to find an alternate route. These environmental clues are better than floating text. Decoration That Tells a Story Every structure should feel intentional. A ruined castle implies danger or a past civilization. A cozy village suggests safety, at least initially. Scattered bones hint at previous adventurers who didn't make it. If you're not confident in building aesthetically, study builds on the Minecraft Block Search tool to understand which blocks work well together. Mixing texture types (smooth, rough, wood, stone) creates visual interest. Avoid using only one block type - that's the quickest way to make something look amateurish. You can also use custom textures and resource packs (which players can download separately) to completely change the visual feel of your map. A moody adventure plays differently with dark, muted colors than bright, vibrant ones. Designing Quests and Gameplay Mechanics This is where adventure maps stop being just pretty builds and become actual games. Command blocks are your tool here. They're honestly not as scary as they look. A simple setup: player enters an area, pressure plate triggers, command block runs `/say "You need a key to open this door"`. More complex setups can track inventory, teleport players, spawn mobs, or modify the world dynamically. If writing command syntax feels daunting, there are generators online that create the commands for you. You describe what you want in plain language, and the tool spits out the command block setup. Quest Types That Work Well Fetch quests ("bring me three diamonds") are simple but feel boring fast. Combat challenges ("defeat the mobs in this arena") are straightforward to design. Puzzle rooms ("arrange the colored blocks in the correct pattern") let players feel clever. The best adventure maps mix all three. A player solves a puzzle to unlock a treasure room, fights a mini-boss to earn a key, then uses that key to progress. Each challenge type breaks up the pacing. Item-based progression is powerful. If players need a wrench to open a door, and that wrench only appears after defeating the engineer mob, suddenly the map has a clear story. Use custom items (same block, renamed and modified) to create keys, weapons, or story props. Consider how you'll handle respawns and checkpoints. Should players restart from the beginning if they die, or respawn at the latest checkpoint? Casual players prefer checkpoints. Speedrunners love the extra challenge of a single-life run. Adding Polish and Testing The difference between an okay map and a great one is polish. This is where patience pays off. Test relentlessly. Play through your own map multiple times. Invite friends to test it (without spoiling the solutions). Watch how they interact with it. Do they miss obvious paths? Do puzzles take way longer than you expected? Do command blocks occasionally fail mysteriously? Fix the little things. If a jump is one block too wide, most players will rage quit. If a mob spawner isn't damaging players fast enough, the difficulty feels off. If text is hard to read, players will get frustrated. These details matter more than you think. Create a clear spawn point with instructions. Even veteran players benefit from knowing roughly what the map is about. A sign saying "Solve five puzzles to unlock the final chamber" sets expectations. An elaborate tutorial level teaches controls without feeling like a tutorial. Optimization and File Management Adventure maps get large. Optimize performance so the game doesn't lag. Use structure blocks to save complete buildings, making it easier to regenerate sections if you mess up. Keep backup copies - I've lost hours of work to accidental deletions. Before publishing, run Minecraft in single-player on a decent computer to make sure performance holds. Test on lower-end hardware if possible. A map that's unplayable due to lag is worse than a map that's less visually impressive. Export your map as a properly formatted file that other players can load. This usually means creating a resource pack and data pack (if you used custom commands), then bundling everything into a downloadable ZIP. If you want to track player progress or have multiple players on a server, check the Minecraft Server Status Checker to confirm your server environment is stable before hosting. Nothing kills an adventure map faster than servers crashing mid-experience. Community and Iteration Share your map on communities like Reddit's r/Minecraft or map-specific forums. Get feedback and iterate. The first version probably won't be perfect (honestly, mine weren't). Version 1.1 with bug fixes and balance tweaks is totally normal. Pay attention to what players say. If multiple people got stuck in the same spot, that's a design problem worth fixing. If everyone loved a specific puzzle, that's your design strength - lean into it for future maps. Common Mistakes to Avoid Scope creep is real. You start wanting a 30-minute adventure map and end up spending three months building a 400-block-wide castle. Set a finish line and stick to it. Don't rely on obscure redstone tricks that only experts understand. Your map should be beatable by players with average Minecraft knowledge. Complexity is fine; obtuse isn't. Avoid invisible command block spam that players can't see. If something magical happens, give players a visual or audio cue so they understand the game reacted to their actions. Test on multiplayer if you're designing for servers. Command blocks behave differently with multiple players, and lag becomes a real issue. Where I Land On This Building an adventure map is genuinely satisfying. You're creating something that other players will spend hours in, remember fondly, and potentially share with their friends. That's powerful. Start small. Build one good puzzle room instead of trying to create the next massive adventure. Share it, get feedback, then build on that success. Your second map will be significantly better than your first, and your tenth will be incredible. The best adventure maps come from creators who actually cared about the player experience, not from whoever had the biggest budget or most free time. Put thought into pacing, progression, and storytelling. Make something you'd actually want to play.

---

### Valence: Building Minecraft Servers with Rust
URL: https://minecraft.how/blog/post/valence-rust-minecraft-servers
Published: 2026-04-26
Author: ice

GitHub · Minecraft community project valence (valence-rs/valence) A Rust framework for building Minecraft servers. Star on GitHub ↗ ⭐ 3,206 stars If you've ever wondered what it'd be like to build a Minecraft server from the ground up instead of modifying existing software, Valence gives you that chance. It's a Rust framework that treats a Minecraft server like a blank canvas, letting you write custom game logic without carrying around a ton of legacy code. What This Project Does Valence is a framework for creating Minecraft: Java Edition servers entirely in Rust. Instead of extending Bukkit, Spigot, or Fabric (the usual paths), you're working with a from-scratch implementation powered by Bevy ECS, an entity-component system game engine. Think of it like this: most Minecraft server software started by copying the original game and patching plugins on top. Valence starts with nothing and you add only what you need. The project handles the Minecraft protocol layer for you - networking, authentication, encryption, compression. It doesn't dictate gameplay. You could build a parkour minigame server, a creative-building sandbox, a role-playing world, or something that barely resembles vanilla Minecraft. The framework gets out of your way and lets you define the rules. Why You'd Want This Most Minecraft server creators reach for Spigot or Paper because they're familiar and have ten thousand plugins. That makes sense if you want vanilla gameplay with some tweaks. But if you're building something custom - especially minigame servers or highly unusual game modes - you're fighting an uphill battle. You're disabling vanilla mechanics, fighting with plugin conflicts, and dealing with performance compromises from features you'll never use. With Valence, you skip all that friction. Since you're writing Rust directly, you get: Explicit control over what runs on your server (no bloat) Strong type safety that catches bugs at compile time instead of runtime Access to Bevy's plugin ecosystem for extending functionality Potential for extremely efficient resource usage - Valence is designed to support thousands of players simultaneously on reasonable hardware This is also a smart choice if you're experimenting with novel server architectures or want to understand the Minecraft protocol deeply. You're not learning how to work around someone else's decisions; you're learning how the protocol actually works. Getting Started with Valence You'll need Rust installed. If you don't have it, grab it from rustup.rs. Valence Rust framework logo with Minecraft server interface in background bashcurl - proto '=https' - tlsv1.2 -sSf https://sh.rustup.rs | sh Next, create a new Cargo project: bashcargo new my_minecraft_server cd my_minecraft_server Add Valence to your Cargo.toml: toml[dependencies] valence = "0.1" bevy = { version = "0.14", default-features = false } The Valence GitHub repository includes examples that show off basic server setup. One learning curve is real though - you're not clicking toggles in a GUI. You're reading Rust and understanding how entities, chunks, and players interact in the ECS model. Plan on spending time with the documentation and examples before your first working server. Features That Matter Authentication and security are built in. Valence handles the Minecraft login sequence (including Mojang's session servers if you want online mode) and encryption automatically. You don't get to accidentally skip TLS or accept invalid logins. The framework makes it hard to do the wrong thing. Valence Rust framework logo with Minecraft server interface in background The protocol abstraction is full. Chunk rendering? Handled. Block states? Covered. Entity metadata, particles, inventories, dimensions, biomes - it's all there. The project includes a Fabric mod that extracts Minecraft's data (block properties, item types, etc.) and generates Rust code from it. You're not hardcoding Minecraft's rules; you're letting the framework generate them. There's built-in support for spatial queries. Want to find all entities within a 50-block radius? The framework uses a bounding volume hierarchy to do that efficiently, not a naive search. For servers with lots of entities this matters. Player skins render correctly. Whitelistings work. Multiple worlds and dimensions are supported. If you've ever run a server, you know these aren't small features - they're foundational pain points on every platform. What You Should Know Before Diving In Valence is early in development (version 0.1.0). Breaking changes happen. Features are incomplete. You might hit gaps where the framework doesn't quite do what you need yet, forcing you to work around something or contribute back. That's the tradeoff with fresh projects - less polish, but more flexibility to shape where it goes. Valence Rust framework logo with Minecraft server interface in background The Rust learning curve matters. If you've never written Rust, Valence is a steep entry point. The compiler is strict in ways that feel annoying until you realize it's catching entire classes of bugs. But the initial friction is real. Deployment is different from traditional Minecraft hosting. You're building a binary, not running a Java JAR on existing infrastructure. That actually simplifies things in some ways (no JVM tuning, lower memory overhead) but complicates things in others (you need to compile for your target architecture, manage Rust dependencies). Actually, here's something worth noting: if you're building a server for thousands of players, Valence's efficiency is a huge advantage. You won't necessarily need the same beefy hardware a Paper server would need. But if you're hosting 20 friends, this advantage doesn't matter. Pick the right tool for your scale. Integrating with Your Server Ecosystem If you're running a production Minecraft server, you probably use tools like server status checkers to monitor uptime and player counts. Valence can expose these metrics through standard monitoring APIs. There's also proxy support - you can sit Valence behind Velocity or Bungeecord, letting players connect through a proxy layer for smooth server-hopping. For administrative tasks like managing whitelists, you can integrate with standard tools. Many communities use whitelist creation utilities to streamline onboarding. Valence's modular design means you can build these admin features as plugins. How Valence Compares If you're debating between Valence and something like Paper, you're asking different questions. Paper is "how do I add features to vanilla Minecraft?" Valence is "what if I built a server from scratch?" They're not competitors; they're different choices for different goals. Against Velocity (a proxy), Valence isn't a replacement - it's a backend. Velocity handles routing players between servers; Valence handles individual servers. There are other Minecraft server frameworks in Rust (like Feather), but Valence's use of Bevy ECS and its focus on being a proper game engine framework (rather than just a protocol implementation) sets it apart. You're not just getting server code; you're getting a foundation for building complex game systems. Is This Worth Your Time? Valence makes sense if: You're building a custom minigame or novel game mode that fights vanilla server software You want to understand how Minecraft servers actually work You're comfortable with Rust and want to use its safety guarantees You need extreme efficiency for high player counts It doesn't make sense if you just want to run vanilla with a few plugin tweaks. Reach for Paper for that. The community around Valence is small but active. That maintainers are responsive. If you're considering this, join the Discord and see what others are building. Real projects are happening - people are shipping minigame servers on top of Valence and sharing what they learn.valence-rs/valence - MIT, ★3206 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

---

### Testing Minecraft Plugins Gets Easy With run-task
URL: https://minecraft.how/blog/post/run-task-minecraft-plugin-testing
Published: 2026-04-26
Author: ice

jpenilla/run-task Gradle plugins adding tasks to run Minecraft server and proxy software pache-2.0 If you've built a Minecraft plugin and tested it locally, you know the dance: download the server jar, set up directories, place your plugin in plugins/, hit start, wait for initialization. Every single time. run-task eliminates that repetitive setup with a single Gradle command that handles everything automatically. What run-task Does run-task is a suite of Gradle plugins that automate one of the most tedious parts of Minecraft plugin development: integration testing. Instead of manually downloading server software, configuring it, and placing your compiled plugin in the right folder, you define what version you want and run a command. The plugin handles the download, setup, and launch automatically. There are three main variants. run-paper handles Paper servers (the go-to choice for most devs), run-velocity covers Velocity proxy software, and run-waterfall covers Waterfall proxies. Each operates on the same principle: configure once in your build.gradle.kts, then use a simple task to spin up your testing environment. This might sound like a small convenience. When you're iterating on a plugin and testing dozens of times a day, the time savings compound fast. Why Plugin Developers Need This Testing a Minecraft plugin is fundamentally different from testing a regular Java library. You can't just run unit tests and move on. Your code runs inside the Minecraft server, interacts with game state, manages player events, and relies on APIs that change between versions. That's integration testing territory, and there's no way around it. Without run-task? The workflow is painful. Download Paper 1.21.8, extract it, create plugins folder, build your jar, copy it over, run the server script, wait for startup, connect with a client, test your feature, shut down, change code, repeat. Do this fifty times while developing a feature and you've lost hours to pure boilerplate. Speed matters here. run-task removes that friction completely. Modify your code, run gradle runServer, and your plugin is already loaded within seconds. This is especially valuable when testing multiple Minecraft versions - switch versions in your config and re-run without manual setup. Getting Started with run-task Installation is straightforward. Add the plugin to your build.gradle.kts and specify the version you want to run: kotlinplugins { id("xyz.jpenilla.run-paper") version "3.0.2" } tasks { runServer { minecraftVersion("1.21.8") } } That's all you need. run-task automatically detects your plugin's compiled jar and includes it. If you're using shadowJar to bundle dependencies, it'll use that instead - no manual configuration. To launch: bashgradle runServer Your Paper server starts with your plugin already loaded and ready for testing. The first run takes longer while downloading everything, but subsequent runs are much faster with cached server files. For Velocity proxy testing, setup is almost identical: kotlinplugins { id("xyz.jpenilla.run-velocity") version "3.0.2" } tasks { runVelocity { velocityVersion("3.4.0") } } The plugin handles version compatibility automatically, so you can test against snapshot releases or stable versions without worrying about compatibility layers. What Makes run-task Worth Using The best feature is brutal simplicity. run-task doesn't try to be clever - it downloads the specified server software, detects your plugin jar, and runs it. Fewer moving parts means fewer things break. Automatic shadowJar detection is genuinely useful if you're bundling dependencies. Many plugins need to shade libraries for custom data formats or newer APIs. run-task respects that without extra configuration. Version switching is dead simple. Want to test on 1.20.4, 1.21.1, and the latest snapshot? Change one line and re-run. Regression testing becomes way less painful. And if you're building tools for server admins (like testing Votifier voting systems or experimenting with custom server MOTDs), having quick access to a running server is invaluable. One detail worth noting: run-task respects Gradle subproject structure. If you're organizing plugin code across multiple modules, it figures out the correct jar automatically. That's less trivial than it sounds. Common Gotchas and Things to Know First gotcha: run-task downloads server software to your.gradle cache - usually ~/.gradle on Linux/Mac, %USERPROFILE%\.gradle on Windows. If you're short on disk space or dealing with a slow connection, the first run takes a minute or two. It's worth it, but expect that initial wait. Java version matters. Paper and Waterfall generally need Java 21 or higher, while older Velocity versions might work with Java 17. If you're using a version manager like sdkman, make sure the correct version is active before running. There's also a learning curve with Gradle syntax if you're new to it. run-task uses Kotlin DSL (build.gradle.kts), which is more type-safe than Groovy but steeper for beginners. If you're still on build.gradle syntax, converting is usually straightforward. Actually, here's something that trips people up: run-task assumes you're testing a single plugin in isolation. If you're building something that requires multiple servers running simultaneously (like a proxy setup with multiple backends), you'll need to orchestrate that separately. It's not a limitation of the tool, just its design philosophy. When run-task Isn't the Right Choice run-task is excellent for plugin development. It's not a one-size-fits-all solution. If you're building a full server distribution with custom configs, startup scripts, and multiple plugins, you probably want Docker or a manual setup instead. run-task assumes you're testing a single plugin in isolation. For integration testing across multiple server software types simultaneously, you'd want more sophisticated orchestration - maybe Docker Compose or a custom test harness built into your CI/CD pipeline. Heavy testing of server administration workflows (monitoring, backups, cluster management) might be better served by a full server environment with proper persistence rather than run-task's temporary setups. Most plugin developers will find run-task covers 90% of their testing needs.jpenilla/run-task - Apache-2.0, ★341 Support the project run-task 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.

---

### ChestShop-3: Build Minecraft Server Shops in Minutes
URL: https://minecraft.how/blog/post/chestshop-3-server-shops-minecraft
Published: 2026-04-26
Author: ice

GitHub · Minecraft community project ChestShop-3 (ChestShop-authors/ChestShop-3) ChestShop - the chest & sign shop plugin for Minecraft Servers running Bukkit/Spigot/Paper Star on GitHub ↗ .1 Sick of managing server economy by hand? ChestShop-3 lets players create shops from chests and signs, turning your server into a real marketplace. Install it once, configure Vault or Reserve, hook it to an economy plugin, and you've got a fully functional trading system that runs itself. What This Project Does At its core, ChestShop-3 is elegantly simple. A player places a chest, puts a sign above it with shop details (price, quantity, seller), and boom - instant transaction point. Other players click the sign and the trade happens automatically. The chest contents move to the buyer, the money goes to the seller. No NPCs, no command spam, no admin micromanagement. The plugin handles the boring stuff. It protects shops from theft, prevents lag explosions when shops get busy, enforces permissions, and logs transactions. It's been battle-tested across thousands of servers for years, so the architecture is genuinely solid. Version 3.12.2 (the latest release) runs on Minecraft 1.13 through recent versions, with development builds available for latest releases. The codebase is written in Java and maintained actively on GitHub by the ChestShop author community. Why You'd Use This Player-run economies are what separate vanilla servers from real communities. When players trade with each other instead of relying on admin shops, they get invested. They build farm bases to supply crops, establish price wars over diamonds, form merchant guilds. So this plugin is the scaffolding that makes that social layer possible. Small survival servers especially benefit. You want players to interact without plugins becoming overhead. ChestShop does one thing and does it right. If you're running a creative or competitive server where economy matters, this is how you let players own the marketplace. And if you're setting up a new server, you might want to use our Minecraft Whitelist Creator while you're building out your server config and Minecraft MOTD Creator to make your server discoverable. Getting It Running Installation is genuinely straightforward. You'll need three things: ChestShop itself, Vault or Reserve (a permission bridge plugin), and an economy plugin that provides the currency system. Grab the.jar from the GitHub releases page: bashcd ~/minecraft-server/plugins wget https://github.com/ChestShop-authors/ChestShop-3/releases/download/3.12.2/ChestShop.jar Then install Vault from SpigotMC if you don't already have it (most servers do). Then pick an economy plugin - the project maintains a list of compatible options on their SpigotMC wiki. Restart the server. ChestShop generates its config file automatically on first load. You'll want to tweak a few settings - transaction tax rate, whether to allow shops in protected areas, which blocks count as valid shop signs - but the defaults work fine for most servers. And that's it. Players can start building shops immediately. No admin setup beyond that. Features Worth Knowing About Shop Protection. Players own their shops. Someone else can't waltz up and crack open a shop chest or modify the sign. The system respects who created the shop and prevents griefing. This matters because on public servers, trust is fragile. Partial Transaction Support. If a player wants to buy 32 diamonds but the shop only has 20, they can still complete the trade for 20 at the proportional price. Recent versions fixed some quirks with this - the 3.12.2 release patched edge cases where transactions would fail. Real quality-of-life stuff. Admin Shop Control. You can create server-run shops that never run out of stock, selling items at fixed prices. Use this to seed the economy with basic materials or create currency sinks. It's how most servers bootstrap their trading system. Translation Support. The project has crowdsourced translations in a dozen languages, including Ukrainian, Italian, German, Spanish. If your international community needs localization, it's there. Multi-Plugin Compatibility. It integrates with land claim plugins, region protection systems, and other popular server tools. It's not trying to reinvent the wheel on everything - it plays nice with existing ecosystems. What'll Probably Trip You Up First thing: you absolutely need Vault or Reserve configured properly. I've seen servers install ChestShop, forget the permission bridge, and wonder why shops don't work. No Vault, no economy connection, no transactions. Check that dependency before you blame the plugin. Second, make sure your economy plugin actually works before you introduce shops. If money is broken, shops cascade that brokenness. Test your economy in isolation first. Third, shop sign placement is specific. The sign has to be directly above a chest (or double chest). Some players try to place signs next to chests and get frustrated when nothing happens. You might want to document this when you onboard new players. Also, item names matter. Minecraft updates occasionally change internal item IDs and data values. When you update the server, ChestShop tries to auto-convert items to the new format, but going backwards (downgrading server or plugin versions) can cause issues. Always back up before major updates. What Else Is Out There ShopGUIs and similar projects exist if you want a more menu-driven experience instead of chest-and-sign shops. Some admins prefer the aesthetics and simplicity of click-to-open GUIs. QuickShop is another player-shop plugin that's actively maintained and popular on modern 1.18+ servers. It's lighter weight than ChestShop and has a different feature set. But if you want the classic chest-shop experience that just works, ChestShop-3 is still the standard. 296 stars on GitHub, thousands of servers running it, years of real-world testing behind it. That's not nothing.ChestShop-authors/ChestShop-3 - LGPL-2.1, ★296 Ready to try ChestShop-3? 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 ChestShop-authors/ChestShop-3 on GitHub ↗

---

### Mcman: Manage Your Minecraft Server Like Code in 2026
URL: https://minecraft.how/blog/post/mcman-minecraft-server-manager
Published: 2026-04-26
Author: ice

" Powerful Minecraft Server Manager CLI. Easily install jars (server, plugins & mods) and write config files. Docker and git support included." deniz-blue/mcman · github.com .0 Tired of manually downloading plugins, hunting for the right server version, and crossing your fingers that your mod list doesn't break? Mcman treats your Minecraft server like a code repository - everything in one config file, automatic downloads, git-friendly, and surprisingly efficient. What This Project Does Mcman is a command-line tool written in Rust that handles the tedious parts of running a Minecraft server. Instead of hunting links, copy-pasting JAR files, and manually editing config files, you describe what you want in a single server.toml file - your server version, plugins, mods, configurations - and mcman handles the rest. It downloads everything, verifies file integrity, and keeps things organized. The magic part? You can version control this entire setup with git. Add a plugin, update your TOML, commit it, push it. Your teammates can pull the changes and mcman will fetch everything they need. No more "wait, what version of X are we using?" confusion. (Actually, this works for managing whole networks too with a network.toml if you're running multiple servers.) Why You'd Use This First, there's the obvious case: if you're running a custom server network, Mcman saves ridiculous amounts of time. I've seen server admins spend hours managing plugin versions across 5+ servers. Mcman cuts that down to a few commands. Update once, deploy everywhere. But there's a subtler reason. If you're testing different plugin combinations or experimenting with new modpack setups, Mcman lets you branch, experiment, and roll back cleanly - just like code development. Your main branch stays stable while you test features on a development branch before merging. You'll also appreciate this if you've ever wanted to share a server setup with a friend or colleague. Send them the repo, they run mcman run, and they've got your exact configuration. No more "wait, did you use CraftBukkit or Spigot?" arguments. Getting Started with Installation Getting mcman running is straightforward. On Linux and macOS, just grab the latest binary from releases: bashcurl -L https://github.com/deniz-blue/mcman/releases/download/0.4.5/mcman -o mcman chmod +x mcman./mcman - version Windows users can either grab the .exe from the releases page, or use Scoop if you've got it set up: powershellscoop bucket add minecraft https://github.com/The-Simples/scoop-minecraft scoop install mcman Linux users on Arch can install from AUR with yay -S mcman-bin or paru -S mcman-bin. Once installed, you initialize a new server: bashmcman init This walks you through creating your server.toml - pick your Minecraft version, server type (Paper, Spigot, Purpur, etc.), and you're rolling. Then mcman run starts your server, and mcman dev is the interesting one - it watches for changes and hot-reloads your server without full restarts. What Makes This Stand Out Actual config file support. Most server managers download the JAR and hope you figure out the rest. Mcman lets you manage server.properties, plugins' YAML files, and custom configs all in one place, with variable substitution. Change one setting across 10 files? You're not copy-pasting into each one. GitHub project card for deniz-blue/mcman Works with nearly every source. Modrinth, CurseForge, Hangar, Spigot, GitHub releases, Jenkins, Maven repositories - if a plugin or mod lives there, mcman can pull it. Need something custom? Just throw in a direct URL. Docker ready. Building a containerized Minecraft setup? Mcman plays nice with Docker containers. Generate a Dockerfile, use mcman inside it, ship it out. Git integration that actually works. This isn't just "oh you can version control your configs" - it's properly thought through. Worlds stay as zips in worlds/, plugins are locked to specific versions in the manifest, everything is reproducible. And if you need to fine-tune your server settings, our Server Properties Generator makes that process faster. The project sits at 304 stars on GitHub and is actively maintained. Rust performance means it's actually fast, which matters when you're managing multiple servers. Things to Watch Out For One thing that catches people: the rewrite happening on the v2 branch is substantial. If you're deploying something for a community, stick with the stable 0.4.5 release. Check the Discord (linked on the repo) for updates on v2 progress before committing to it. Config variables are powerful but require you to actually write them correctly. Typos won't always fail loudly - you'll just get weird behavior at runtime. Read the docs on variable syntax before you get frustrated. Also, if you're setting up shared servers, remember that Mcman's strength is in reproducibility - but that means everyone on the team needs to understand TOML syntax and git basics. It's not a GUI tool. One more caveat: I'd recommend using this for server management workflow, not as a complete hosting solution. Mcman handles the setup and deployment bits beautifully, but you still need your own server hardware, hosting, or custom Docker orchestration. For calculating how to properly organize your world coordinates (especially if you're working across dimensions), check our Nether Portal Calculator. Other Tools and Approaches There are other paths if Mcman doesn't fit your needs. Paper's plugin ecosystem handles some of these problems, but it's more limited in scope - no git workflow. Docker has its own learning curve but works well for container-first teams. Hosting platforms handle deployment for you, though you lose flexibility. Mcman sits in a nice middle ground: powerful enough for serious server operations, simple enough that one admin can handle it, and flexible enough to scale up. What's The Verdict Mcman isn't flashy. It's a command-line tool that makes running Minecraft servers boring in the best way possible - you spend your time building worlds and running your community, not wrestling with configuration files. If you're currently managing Minecraft servers and copying files around manually, this is worth thirty minutes of your time to evaluate. The project's on GitHub, the documentation is solid, and the Discord is active if you get stuck. 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

---