MixinTale

A bytecode patching framework for Hytale mods. Mod authors write a plain static Java method, annotate it, and MixinTale runs it inside the game class they targeted — before the JVM has even defined that class

If you are here because a mod told you to be: download this, drop it in EarlyPlugins, done. The rest of this page is for mod authors

For players and server owners

MixinTale is a core framework, not a gameplay mod. On its own it changes nothing. Mods that patch the game list it as a requirement

Install


Singleplayer	put `MixinTale-Bootstrap-3.0.0.jar` in `[GameFolder]/UserData/EarlyPlugins/`
Dedicated server	put it in `[ServerFolder]/earlyplugins/`

Then install the mod that needs it in UserData/Mods/ (singleplayer) or Mods/ (server), as usual

Dedicated servers must also start with --accept-early-plugins. Class transformers are opt-in since 0.6.3, and a server with no console attached will refuse to start rather than load them silently. Singleplayer accepts them automatically

Check that it worked

Early in the log:

[EarlyPlugin] Loading transformer: com.traktool.mixintale.bootstrap.MixinTaleTransformer (priority=1000)
[MixinTale/INFO] MixinTale 3.0.0 ready - 1 patch(es) across 1 class(es) from 1 archive(s).

If it says 0 patch(es), MixinTale started but found nothing to do. Almost always one of:

the mod jar is not in a folder the server scans, or
the mod is switched off in that world's config.json. Each save has a Mods block; a mod listed with "Enabled": false is skipped at boot and the log says so. Set it to true

Requirements

Hytale 0.6.3 or later. No Java install of your own is needed — the game ships its own runtime

Uninstalling

Delete the jar. Mods that depended on it load normally and log that their patch did not apply

Is this safe?

It rewrites the game's own bytecode before the JVM sees it, and Hytale shows a warning banner about exactly that. That warning is correct and you should read it. What MixinTale does is inspectable: starting with -Dmixintale.report=mixintale-report.txt writes out precisely which method of which class every installed mod changed. Nothing is sent anywhere, nothing is downloaded at runtime, and there is no telemetry

For mod authors

@Patch(RepairItemInteraction.class)
public final class RepairPenaltyPatch {

    @RedirectCall(value = "run", target = Item.class, name = "getMaxDurability")
    public static double noPenaltyBase(@This Item item) {
        return 0.0D;
    }
}

That is a complete, shipping mod — it is the whole of NoRepairDurabilityPenalty 2.0.0. No JVM descriptors, no refmap, no configuration file, no runtime library on your class path

What you get


`@Prefix`	runs first; returning `false` skips the original body, with an optional supplied result
`@Postfix`	runs at every `return`; can rewrite the value
`@Replace`	substitutes the body
`@RedirectCall`	intercepts one specific invocation inside a method, by ordinal
`@Accessor`	reads and writes private fields of the target
`@Invoker`	calls private methods of the target

Parameters are bound with @This, @Arg(n) and @Result. You almost never write a descriptor: the annotation processor infers the target's signature from your handler's parameter types, and tells you at compile time when it cannot — a wrong method name is a build error, not a silent no-op at runtime

How it stays out of trouble

MixinTale never emits bytecode that references your mod. Your handler is moved into the target class: every reference to your patch class is rewritten to the target, and each member is renamed under a per-patch prefix such as mixintale$3f9c1a2b$noPenaltyBase

That buys three things at once — handlers can touch private state, nothing crosses a class loader boundary (so no NoClassDefFoundError), and two mods patching the same class cannot collide. It costs one rule: a handler may only mention JDK types, com.hypixel.hytale.* types, and members of its own patch class. The processor enforces it while you compile

Getting started

Install MixinTale — Developer Tools (the API jar and the annotation processor) and read the manual:

https://github.com/Traktool/MixinTale

The manual covers every primitive with a worked example, signature inference, gating a patch so it does not change the game for everyone, priority when two mods meet the same method, the runtime switches, and what to do when a game update breaks a patch

Before you reach for it

The official 0.6.x API is large — 133 event types, ECS system registration, asset packs, commands, registries. If your mod fits an event or a registry, use that instead. A patch is a maintenance liability; an event subscription is not. MixinTale is for what the official API does not reach: damage, death, loot, durability, specific interactions, and anything that has to replace vanilla logic rather than run beside it