Fabric Wiki

User Tools

Site Tools

Trace:
tutorial:mixin_introduction

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
tutorial:mixin_introduction [2025/09/27 04:03] – Very minor phrasing addition gauntreclusetutorial:mixin_introduction [2025/12/23 00:49] (current) – Rephrase around JVM bytecode to make it sound a bit less imperative to be able to properly understand JVM bytecode for Mixins gauntrecluse
Line 1: Line 1:
-FIXME //The Mixin related pages of the Fabric Wiki are undergoing a more thorough review, and are subject to change, rewrites or being replaced. Many pages may be outdated, inaccurate, inactive or incomplete. It is strongly recommended to use the Fabric wiki and linked resources to get a rudimentary Mixin understanding, and then frequently ask questions in dedicated Mixin Support channels on the Fabric or SpongePowered Discord servers for any specific knowledge or specific issue-solving. Any help or feedback in amending pages on this topic is greatly appreciated.//\\ +FIXME //The Mixin related pages of the Fabric Wiki are undergoing a more thorough review, and are subject to change, rewrites or being replaced. Many pages may be outdated, inaccurate, inactive or incomplete. It is strongly recommended to use the Fabric wiki and linked resources to get a rudimentary Mixin understanding, and then frequently ask questions in dedicated Mixin Support channels on the Fabric or SpongePowered Discord servers for any specific knowledge or specific issue-solving. Any help or feedback in amending pages on this topic is greatly appreciated.//
-//This page specifically is under heavy revisions, and may change in large ways almost overnight as a result. Always prioritize learning from the dedicated external Wikis and asking questions in support channels when in doubt//+
  
 ====== Introduction to Mixins (WIP) ====== ====== Introduction to Mixins (WIP) ======
 Mixins are a powerful and important tool used in the Fabric ecosystem and other modding frameworks for Minecraft. Their primary use case is modifying existing code in the base game,  Mixins are a powerful and important tool used in the Fabric ecosystem and other modding frameworks for Minecraft. Their primary use case is modifying existing code in the base game, 
-whether it be through injecting custom logic, removing mechanics, or modifying values. Note that **only Mixins written in Java are directly supported**, even if you use Kotlin or another language running on the Java Virtual Machine for the rest of your mod. Whilst it may be technically possible to use other JVM languages apart from Kotlin which is explicitly unsupported, there are currently no plans to support it or document such a process.+whether it be through injecting custom logic, removing mechanics, or modifying values. Note that **only Mixins written in Java are directly supported**.((This applies even if you use Kotlin or another language running on the Java Virtual Machine for the rest of your mod. Whilst it may be technically possible to use other JVM languages, there are currently no plans to support it or document such a process. Note that Kotlin in particular is directly incompatible with Mixin without providing additional compatibility layers.))
  
-Mixin is a complex subsystem which merges a mod's Mixin "classes" +Mixin is a complex subsystem which uses a mod's Mixin classes 
-((Mixin classes are not classes in the same way as "standard" Java classes. See [[https://github.com/SpongePowered/Mixin/wiki/Introduction-to-Mixins---Understanding-Mixin-Architecture/|the relevant Wiki page]] for a stronger base of understanding of Mixin's architecture, and how they do not fit in the practical Java definition of classes. TL;DR, Mixin Classes are only classes for the sake of being merged into another class at runtime. They shouldn't be instantiated.)) +((Mixin classes are not classes in the same way as "standard" Java classes, see [[https://github.com/SpongePowered/Mixin/wiki/Introduction-to-Mixins---Understanding-Mixin-Architecture/|the relevant Mixin Wiki page]]. Mixin classes should not be instantiated as they no longer exist at runtime.)) 
-into the targeted classes' compiled Bytecode at runtime by parsing the mixin classes' compiled bytecode. It will merge both the annotated methods, and other members and interfaces added to the Mixin class. The specifics of how this is done is outside the scope of this introduction, refer to the relevant Mixin Wiki links on this page for details.+to transform the targeted classes' compiled Bytecode as the game runs("runtime"), but before the target class is loaded.
  
-It is not recommended to try and learn how Mixin works or how to use it without having some notion of what Bytecode is, as that may lead to unexpected behavior and misunderstandings. It is also recommended to know how to read Java Bytecode for your IDE of choice, as reading portions of the Bytecode may sometimes be necessary to use Mixin properly, notably when targeting anonymous classes, lambdas or code with a lot of ''if-else'' logic branching.\\ +It is not recommended to try and learn how Mixin works or how to use it without prior knowledge of what Java bytecode is itself, as Mixin applies to bytecode rather than "source" code. It is also recommended to know how to access a class's bytecode for your IDE of choice, as reading portions of the Bytecode may sometimes be necessary to apply modifications properly, such as when targeting anonymous classes, lambdas or code with a lot of "if-else" logic branching. See [[https://docs.fabricmc.net/develop/mixins/bytecode|the Java Bytecode Docs page]] for a more extensive introduction on how to read and understand bytecode.
-Similarly, Mixin and this documentation expects the user to already be familiar with [[tutorial:reading_mc_code|reading Minecraft and external source code]], and be able to set up an initial development environment, aswell as having a decent understanding of Java fundamentals. If, however, you specifically wish to skip to examples, be aware that it is expected for you to encounter difficulties and confusion in your learning process as you try to tackle more technical issues without learning some technical aspects, and you are likelier to need direct support.+
  
-Mixin can do its work throughout the game's lifecycle, however, a mixin must be applied before the targeted class has loaded. For the majority of mixins, this is very early in the overall Fabric launching process, but do mind that the game launching without Mixin crashing or logging warns doesn't mean all changes have applied as intended.+Similarly, Mixin and this documentation expects the user to already be familiar with [[tutorial:reading_mc_code|reading Minecraft and external source code]], and be able to set up an initial development environment, aswell as having an understanding of Java fundamentals. If, however, you specifically wish to skip to examples, be aware that it is expected for you to encounter difficulties and confusion in your learning process as you try to tackle more technical issues without learning some technical aspects, and you are likelier to need direct support or create Mixins that will be needlessly incompatible with other mods.\\ 
 +It is recommended to leverage the [[https://mcdev.io/|Minecraft Development plugin by demonwav on IntelliJ]] (AKA MCDev) for Mixin development to benefit from its autocompletion, error highlighting, and utilities such as the MixinExtras Flow Diagram.
  
-There are different kinds of tools Mixin and MixinExtras +Mixin can do its work throughout the game's lifecycle, however, a Mixin's transformations must be applied before the targeted class has loaded. For the majority of Mixins, this is very early in the overall Fabric launching process, but certain targets may only be loaded as the game loads a world.
-((Since Fabric Loader 0.15, MixinExtras is bundled with Fabric. Since Loader version 0.17.0, MixinExtras major version 0.5.0 is included, and allows access to [[https://github.com/LlamaLad7/MixinExtras/wiki/Expressions|Expressions]] for extremely precise and flexible targeting. MixinExtras is a companion library to Mixin and is extremely useful for precise and compatible manipulation of Mixins.))  +
-provide for modifying source code. Those tools come in the form of Java annotations, those annotations decorate((AKA annotate, are attached to)) members of the Mixin class and are passed arguments which are used to associate the necessary information so that Mixin knows how to process your class and then transform and merge them into the target class. Here is a basic overview of Mixin's important annotations:\\ +
-FIXME //There ought to be dedicated pages going more in depth about the different tools annotations later on. This segment as it is edited should be kept to an introductory level to Mixin annotations and features.//+
  
-  * The ''@Mixin'' annotation decorates every Mixin class. It mainly dictates the class to target and the priority of the decorated class relative to other mixin classes with the same target. +There are different tools Mixin and MixinExtras 
-  * Injector Mixin annotations decorate a handler method((In the context of Mixin, handler methods are the methods that are merged into the target class, and invoked at the relevant point the decorating annotation specifies as a target. For most cases, think of them as the methods decorated by injector or redirector annotations.)) and will inject it into the target class and then call it at the injection point. Injectors are distinguished by the fact they do not overwrite the targeted bytecode((As described on the [[https://github.com/SpongePowered/Mixin/wiki/Advanced-Mixin-Usage---Callback-Injectors#1-code-out-of-the-aether---discovering-injectors|Mixin Wiki page]] introducing injectors)), injectors include all method decorations from MixinExtras, and in base Mixin mainly ''@Inject'', ''@ModifyVariable'' or ''@ModifyArg''.((As per message from Llamalad7 currently pinned in the #mod-dev-mixin Fabric Discord channel: https://discord.com/channels/507304429255393322/807617700734042122/1234059373219811380)) Injectors should be treated your primary way to modify external code as they are more compatible (more than one mod can inject the same target), and MixinExtras provides injector alternatives that fulfill nearly all roles of non-injector tools such as redirectors/redirect injectors and overwriting. +((Since Fabric Loader 0.15, MixinExtras is bundled with Fabric. Since Loader version 0.17.0, MixinExtras major version 0.5.0 is included, and allows access to [[https://github.com/LlamaLad7/MixinExtras/wiki/Expressions|Expressions]] for extremely precise and flexible targeting. MixinExtras is a companion library to Mixin and is essential for precise and compatible manipulation of many Mixins.))  
-  * Redirector Mixin annotations refers to annotations that merge the handler method and replace the targeted injection point with a call to your handler method. Think of it as overwriting what you targeted and replacing it with a call to the decorated handler method. Whilst a name for them is also Redirect Injectors((As per [[https://github.com/SpongePowered/Mixin/wiki/Advanced-Mixin-Usage---Redirect-Injectors|this stub in the Mixin Wiki]])), you should generally treat them differently as they do not merely inject but also overwrite information and cannot chain. The main redirectors are ''@Redirect'' and ''@ModifyConstant''. +provide for modifying source code. Most of these tools are provided to the users in the form of Java annotations, those annotations are associated to members of the Mixin class, itself annotated with ''@Mixin'' and [[tutorial:mixin_registration|registered]]. These annotations are used to communicate to Mixin how to treat different elements of the Mixin class during the target's modification process.
-  * Overwriting, using the ''@Overwrite'' annotation simply replaces the targeted method with your own. There is practically never any reason to use this as a mod developer, and you should always prioritize other solutions like MixinExtras' ''@WrapMethod''. +
-  * One of Mixin's most fundamental features, upon which most of its tools are built upon, is merging a Mixin class into the target class. This includes interface implementations and non-shadow members. Annotations such as ''@Inject'' serve as a way to describe special behavior to be done on top or instead of merging the decorated member.+
  
-//For more complete and thorough information on Mixin functionality, usage, and mechanics, view the [[https://github.com/SpongePowered/Mixin/wiki|Mixin Official Wiki]]. Additional documentation can be found in the [[https://jenkins.liteloader.com/view/Other/job/Mixin/javadoc/index.html|Mixin Javadoc]]. MixinExtras features are documented on its [[https://github.com/LlamaLad7/MixinExtras/wiki|Official Wiki]]. JavaDoc documentation may be found in your local development environment with Mixin set up aswell.//+As to make reading more precise documentation easier, here is a basic overview of some of Mixin's most important features:\\ 
 +FIXME //There ought to be dedicated pages going more in depth about the different tools annotations later on. This segment as it is edited should be kept to a cursory overview of Mixin(Extras) features.//
  
-The Fabric Wiki offers several articles that provide practical examples and explanations of some areas of the Mixin and MixinExtras tools:+^ Feature ^ Overview ^ Notes ^ 
 +| ''@Mixin'' annotation | Decorates every Mixin class, specifying the target class and the priority of the Mixin class relative to other classes with the same target. | All Mixin classes must also be [[tutorial:mixin_registration|registered in the relevant Mixin config file]]. | 
 +| Merging | Mixin merges a Mixin class's members and interface implementations, apart from some outliers, into the target class. Annotations on members may dictate special merging behavior or prevent merging altogether.  | Understanding that Mixin classes are transformed into the target class which they are subsequently merged with, and that as a result the Mixin classes do not exist at runtime (with the exception of accessors) is fundamental to understanding many of Mixin's features. | 
 +| Injectors | An injector typically refers to an annotation and an associated "handler" method. When an injector's "handler" is merged, it will add new instructions at the specified point in the target method(s), without removing or overwriting any existing bytecode there. | Injectors include all of the modification tools from MixinExtras, along with mainly ''@Inject'', ''@ModifyVariable'' and ''@ModifyArg'' in "stock" Mixin. Injectors should be the primary way for a user to modify the target code, as multiple injectors may target the same element and chain with one another for compatibility. | 
 +| Redirectors(rarely called Redirect Injectors) | Similar to injectors as described above, with the important difference that redirectors replace the target instructions with the callback, rather than only injecting new instructions. This makes it impossible for more than on Redirector to apply to the same target, making them impractical unless a hard incompatibility is intended. | Redirectors include mainly ''@Redirect'' and ''@ModifyConstant''. Both of which can be replaced by MixinExtras' ''@WrapOperation'' or ''@ModifyExpressionValue'' injectors for use-cases not leveraging redirectors' incompatibility from the lack of chaining. | 
 +| Overwriting | Done explicitly via ''@Overwrite'', describes the process of a Mixin member replacing, overwriting, an existing member in the target class. | Overwriting is inherently incompatible, and unless the intent is to use that incompatibility, it should never be done. | 
 + 
 +//For more complete information on Mixin functionality and usage view the [[https://github.com/SpongePowered/Mixin/wiki|Mixin Official Wiki]]. Documentation specific to individual Mixin features can be found in the [[https://jenkins.liteloader.com/view/Other/job/Mixin/javadoc/index.html|Mixin Javadoc]]. MixinExtras features are well-documented on its [[https://github.com/LlamaLad7/MixinExtras/wiki|Official Wiki]]. JavaDoc documentation of both may also be found in the source code of both, viewable in your IDE.// 
 + 
 +The Fabric Wiki offers several articles that provide practical examples and explanations of some areas of Mixin and MixinExtras: 
 +  * [[tutorial:mixin_your_first_mixin|Tutorial: Making your first Mixin]] 
 +  * [[https://docs.fabricmc.net/develop/mixins/bytecode|Java Bytecode (Docs)]] 
   * [[tutorial:mixin_registration|Mixin registration]]   * [[tutorial:mixin_registration|Mixin registration]]
-  * [[tutorial:mixin_injects|Injects]]+  * [[tutorial:mixin_injects|@Inject]]
   * [[tutorial:mixin_accessors|Accessors and Invokers]]   * [[tutorial:mixin_accessors|Accessors and Invokers]]
 +  * [[tutorial:mixin_override|Overriding a Mixin Target's parent]]
   * [[tutorial:mixin_redirectors|Redirectors]]   * [[tutorial:mixin_redirectors|Redirectors]]
     * [[tutorial:mixin_redirectors_methods|Method redirectors]]     * [[tutorial:mixin_redirectors_methods|Method redirectors]]
Line 37: Line 44:
   * [[tutorial:mixin_examples|Examples]]   * [[tutorial:mixin_examples|Examples]]
   * [[tutorial:mixin_hotswaps|Hotswapping Mixins]]   * [[tutorial:mixin_hotswaps|Hotswapping Mixins]]
-  * [[tutorial:mixin_export|Exporting Mixin Classes]] +  * [[tutorial:mixin_export|Exporting and Dumping Mixin Targets]] 
-  * [[tutorial:accesswideners |Access Wideners]]+  * [[tutorial:accesswidening|Access Widening]]
   * [[tutorial:reflection|Reflection]]   * [[tutorial:reflection|Reflection]]
   * [[tutorial:interface_injection|Interface Injection]]    * [[tutorial:interface_injection|Interface Injection]] 
   * [[tutorial:modding_tips|Modding Tips]]   * [[tutorial:modding_tips|Modding Tips]]
tutorial/mixin_introduction.1758945804.txt.gz · Last modified: 2025/09/27 04:03 by gauntrecluse