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)

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.

Mixin is a complex subsystem which merges a mod's Mixin “classes” ¹⁾ into the targeted classes' compiled Bytecode at runtime by parsing the Mixin classes' Bytecode. This is done by merging the Mixin class's members, with some exceptions, and new interface implementations into the target 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.

It is not recommended to try and learn how Mixin works or how to use it without having some notion of what Java bytecode is, as that may lead to unexpected behavior and misunderstandings. It is also recommended to know how to read 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.
Similarly, Mixin and this documentation expects the user to already be familiar with 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.
It is recommended to leverage the Minecraft Development plugin by demonwav on IntelliJ (AKA MCDev) for Mixin development to benefit from its autocompletion and utilities such as the MixinExtras Flow Diagram.

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.

There are different tools Mixin and MixinExtras ²⁾ provide for modifying source code. Most of these tools are provided to the users in the form of Java annotations, those annotations decorate(annotate, are attached to) members of the Mixin class, itself decorated and registered. These annotations serve as a way to make Mixin merge the annotated members in a specific way.

Here is a cursory overview of some of Mixin's key features:
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.

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 registered in the relevant Mixin config file, see Mixin registration
Merging	Mixin merges a Mixin class's members and interface implementations, with some exceptions, into the target class. Annotations on members may dictate special merging behavior or prevent merging.	Understanding that Mixins merge with their target and do not exist at runtime (with the exception of accessors) is fundamental to understanding the rest of the subsystem's features.
Injectors	Methods and a decorating annotation which creates a set of instructions that call back (called a “callback”) to the injector's “handler” method at the specified injection point when merging the method. This does not overwrite or remove any of the target class's bytecode, as such more than one injector may target a singular injection point.	Injectors include all of the method annotations from MixinExtras, and in “base” Mixin, mainly `@Inject`, `@ModifyVariable` and `@ModifyArg`. Injectors should be the primary way for a user to modify the target code.
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 to chain more than one redirector, making them a less practical options unless a hard incompatibility is specifically the intent.	Redirectors include mainly `@Redirect` and `@ModifyConstant`. Both of which can be replaced by MixinExtras' `@WrapOperation` or `@ModifyExpressionValue` injectors due to their ability to chain with other mods. Redirectors should only be used when a good reason necessitates them, such as an intended incompatibility.
Overwrites	Done via `@Overwrite`, this is used to outright replace a target method with the annotated method. It is an impractical tool for nearly all situations compared to MixinExtras' `@WrapMethod` or more specific modifications of the method body.	There is practically almost never a situation where overwriting a method is the correct choice, as overwriting is an incredibly intrusive and incompatible tool. As such, one should always gather second opinions, or ask for help if the issue is the inability to figure out more precise tools, before committing to an overwrite; and only then, if it is absolutely necessary, create an overwrite.

For more complete and thorough information on Mixin functionality, usage, and mechanics, view the Mixin Official Wiki. Documentation specific to individual Mixin features can be found in the Mixin Javadoc. MixinExtras features are well-documented on its Official Wiki. JavaDoc documentation of both may be found in your local development environment with Mixin set up aswell.

The Fabric Wiki offers several articles that provide practical examples and explanations of some areas of Mixin and MixinExtras:

¹⁾

Mixin classes are not classes in the same way as “standard” Java classes. See the relevant Mixin Wiki page for a stronger base of understanding of Mixin's architecture, and how Mixin classes 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.

²⁾

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 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.