Skytils: Advanced Runtime Patching for Minecraft

Role: Founder & Core Maintainer
Tech Stack: Kotlin, Java, ObjectWeb ASM, Mixin, Cloud Command Framework
Impact: 1.5k+ GitHub Stars • 470+ Forks • Adopted by the Hypixel Skyblock community

View on GitHub →

The Problem

The default Minecraft client, when used with Hypixel Skyblock’s dungeon system, suffered from critical limitations:

  • Lack of actionable HUD data: Players had no way to track real-time dungeon score, a metric essential for achieving S+ ratings and maximizing loot drops.
  • Tedious manual puzzles: Certain dungeon puzzles (Blaze ordering, Terminal sequences) required repetitive, error-prone manual solving that broke gameplay flow.
  • Performance bottlenecks: The vanilla rendering pipeline and event handling introduced latency, especially in high-entity dungeon rooms where frame drops could mean the difference between clearing and failing a run.
  • No extensibility: Without access to the game’s source code, adding features required reverse engineering obfuscated bytecode—a significant barrier to entry.

The community needed a solution that could surgically modify the game’s runtime behavior without compromising stability or performance.

The Solution

I designed and built Skytils, a modular modification suite written primarily in Kotlin that hooks into the Minecraft client at runtime. Rather than forking the game or relying on fragile reflection hacks, Skytils leverages bytecode manipulation to inject functionality directly into the game’s compiled code.

Architecture Highlights

  • Modular Feature System: Each feature (HUD elements, puzzle solvers, waypoints) is encapsulated in its own module with clean interfaces, allowing contributors to add functionality without understanding the entire codebase.
  • Cloud Command Framework Integration: Built a robust, type-safe command system supporting autocompletion, argument validation, and user-friendly error messages.
  • Custom Waypoint Engine: Implemented a 3D waypoint system supporting user-defined markers, route visualization, and sharing via exportable JSON configurations.

Technical Deep Dive: Bytecode Manipulation with ASM

The core of Skytils’ power lies in its use of ObjectWeb ASM and the Mixin framework to perform runtime bytecode transformation—injecting custom logic into compiled .class files as the JVM loads them. This is the same technique used by production-grade tools like profilers and APM agents.

How It Works

  1. ClassLoader Interception: When the JVM loads a class, Skytils’ transformer agent intercepts the bytecode before it’s defined. Using ASM’s visitor pattern, I traverse the class structure to locate injection points.

  2. Render Pipeline Hooks: To add custom HUD elements, I wrote Mixins that @Inject at the HEAD and TAIL of the GuiIngame.renderGameOverlay method. This allows Skytils to draw score calculations, timers, and alerts after the vanilla HUD renders, ensuring correct Z-ordering without z-fighting.

  3. Event Synthesis: Rather than polling game state, I patched event dispatch methods to fire custom events (e.g., DungeonRoomEnterEvent) that feature modules can subscribe to. This event-driven architecture minimizes performance overhead and decouples feature logic from bytecode specifics.

  4. Obfuscation Handling: Minecraft’s production builds use obfuscated names. I integrated SRG/MCP mappings to translate human-readable method names to their obfuscated counterparts at compile time, ensuring patches apply correctly across different game versions.

Example: Blaze Puzzle Solver

The Blaze puzzle requires hitting enemies in health-order. My solver:

  1. Hooks RenderLivingEvent to capture entity render calls
  2. Extracts health values via reflected field access (cached for performance)
  3. Sorts entities and renders numbered overlays indicating attack order
  4. Achieves this with <1ms overhead per frame by batching draw calls and using object pooling to avoid GC pressure

This approach—bytecode injection for interception, Kotlin for logic, and careful memory management—enabled features that would be impossible with conventional modding APIs.

The Result

Skytils grew from a personal utility into a community-driven open source project with significant impact:

  • 1,500+ GitHub stars and 470+ forks, with active contributions from dozens of developers
  • Standardized features that were later adopted (and sometimes directly copied) by competing mods, validating the design decisions
  • Educational impact: The codebase became a reference implementation for other developers learning ASM and Mixin techniques
  • Community tooling: Spawned auxiliary projects for config management, overlay customization, and cross-mod interoperability

Beyond metrics, Skytils taught me how to lead an open source community—managing issues, reviewing PRs, writing documentation, and making architectural decisions that balance contributor accessibility with codebase integrity.

Key Takeaways

  • Bytecode manipulation is a superpower when source access isn’t available. Understanding the JVM at this level opens doors to instrumentation, profiling, and hot-patching.
  • Kotlin’s expressiveness significantly reduced boilerplate compared to Java, accelerating development without sacrificing JVM interoperability.
  • Event-driven architecture scales better than polling, both in performance and code maintainability.
  • Open source leadership is its own skill set—technical excellence is necessary but not sufficient for building a thriving community.

View Project on GitHub →