Compatibility

Poly Mod Loader handles mods from other loaders diagnostics-first. A loader bridge reports each feature Poly Mod Loader cannot provide as one finding. If even one finding blocks, the mod is not loaded.

Support status

Loader	Status	Details
Poly Mod Loader Native	Verified	poly.mod.json mods. 52 Native API game tests; the client, the server, and world saving are checked
Fabric (entry points, the Fabric Loader API, language adapters, nested jars)	Verified	preLaunch, main, client, and server entry points, including :: values, run at the same points as in Fabric Loader. Mods may depend on other Poly Mods and Fabric mods
Fabric (Mixin and MixinExtras, class tweaker accessible, extendable, mutable, inject-interface, and extend-enum lines, @Environment)	Verified	Applied in Fabric Loader's order. With the real popular mods on 26.2, 140 mods (138 real Fabric mods plus 2 test mods) play a saved world on the client, save it and quit, 100 pass the real dedicated server start, and 98 create, tick, and save a world on the game test server; 26.1 passes the same checks (below)
Fabric (Fabric Loader internal classes)	Partial	What real mods use is provided: FabricLauncherBase.getLauncher() (addToClassPath and more) and FabricLoaderImpl.getGameProvider(). Other internal classes and members are blocked by the link check (111)
Quilt (quilt.mod.json)	Verified	On 26.1, 26.1.2 and 26.2 (2026-10-24). quilt.mod.json is read with Quilt Loader's meaning, the Quilt Loader 0.31.0-beta.4 public API is provided, and Quilt mods' nested jars, entry points, Mixin, and access wideners work. Every Quilt-only build on Modrinth for each version was run on the client, the game test server and the dedicated server, also next to Forge mods, and compared with real Quilt Loader; the installed server and launcher profile run a Quilt mod too. Mods that need QSL are left out (POLY-COMPAT-114 with 308), and a jar with both fabric.mod.json and quilt.mod.json runs as a Fabric mod (310). Details below
NeoForge (META-INF/neoforge.mods.toml)	Verified	On 26.1, 26.1.2 and 26.2 (2026-10-24). Poly Mod Loader runs NeoForge's own FML 11 by default (NeoForge 26.1.0.19-beta on 26.1, 26.1.1.15-beta on 26.1.1, 26.1.2.122 on 26.1.2, 26.2.0.93 on 26.2). Popular NeoForge mods enter a saved world on the client, tick, save and quit (54 on 26.2), create, tick and save a world on the game test server (38 on 26.2) and start a real dedicated server (37 on 26.2); the installed launcher profile and server run them too. The only mods left out are ones NeoForge's own server stops on or refuses too; a mod FML would refuse is left out first (POLY-COMPAT-217). Not in the same game as Fabric or Quilt mods yet (POLY-COMPAT-216). Details below
Forge (META-INF/mods.toml)	Verified	Poly Mod Loader runs Forge and FML themselves (Forge 62.0.9 on 26.1, 64.1.5 on 26.1.2, 65.1.5 on 26.2). On all three, popular Forge mods enter a saved world on the client, tick, save and quit (40 on 26.2), create, tick and save a world on the game test server (32 of 38 on 26.2) and start a real dedicated server (35 of 41 on 26.2), also next to Fabric mods; the installed launcher profile and server run them too. Mods Forge would refuse or stop on are left out first, with the reason (POLY-COMPAT-209): client-only mods on a server, mods built for another Forge version, and Mixin configurations Forge's Mixin cannot read. Details below; next to Fabric mods: Run Fabric and Forge mods together

Status definitions: Verified / Partial / Experimental / Blocked / Untested. A jar that merely loaded is never labeled Verified.

Decide before startup, not crash

Before any game code runs, Poly Mod Loader decides for every mod: "load", or "leave out, with the reason". This keeps a mod that cannot run from causing a NoClassDefFoundError or NoSuchMethodError in the middle of the game.

• Dependencies across loaders: A Poly Mod can depend on a Fabric mod, and a Fabric mod can depend on a Native or Fabric mod. Fabric provides aliases are honored. Version conditions follow each loader's own rules. Fabric conditions use Fabric Loader's own version resolver.
• Left out in a chain: If a required mod is missing, blocked, or has the wrong version, the mod that needs it is left out (POLY-COMPAT-114), and so are the mods that need that one. Each mod gets all its reasons, for example "requires 'fabric-api' …, which is installed but not loaded: Fabric mod fabric-api … is BLOCKED: [POLY-COMPAT-103]".
• minecraft and java conditions: Fabric mods built for another Minecraft version are left out.
• breaks, conflicts, and duplicate IDs: breaks leaves the mod out (115), and conflicts gives a warning (116). If another mod uses the same ID, the external mod is left out (117).
• Link checks: Poly Mod Loader checks that the Minecraft classes, methods, and fields referenced by the classes of an external mod about to be loaded exist in this game version (112), and whether class tweaker targets exist. A target this game does not have is left out, as in Fabric Loader (137, warning); a class outside the game jar blocks the mod (128). It also checks whether the mod uses a Fabric Loader runtime that Poly Mod Loader does not provide (111). Interfaces that a mod injects or that its mixins add count as supertypes. Optional integration with a mod that is not installed, client classes referenced on a server, and classes of client-only mods referenced on a server only produce a warning (113). Only references are checked; real execution paths are not analyzed.
• Broken files: Malformed metadata (100, 200), a corrupt jar (POLY-DISCOVERY-003), and a NeoForge library jar (205) leave out only that file, and Poly Mod Loader keeps judging the rest.
• Entrypoint order: Within a loader, dependencies run first. Poly Mods initialise before the game starts. Fabric mods initialise where Fabric Loader initialises them, after Minecraft's bootstrap: preLaunch right after Mixin is ready, then main, then client or server. So a Poly Mod that depends on a Fabric mod gets load order and classes, but the Fabric mod's initialisation has not run yet when the Poly Mod initialises.
• If a Poly Mod requires a blocked external mod, startup stops before any game code runs and Poly Mod Loader explains why (POLY-DEPENDENCY-009).

Fabric bridge

• It does not start Fabric Loader itself. Instead, Poly Mod Loader provides the Fabric Loader public API (FabricLoader.getInstance()) directly. This covers the mod list and lookup (Poly Mods are visible too), metadata and custom values, entry points for every key (getEntrypoints), shared objects, the config folder, the runtime environment, and language adapters. getMappingResolver returns the official namespace and maps names to themselves, as Fabric Loader does without mappings. getGameInstance returns the client's Minecraft object, or the dedicated server once it starts running (null before then, as in Fabric Loader). Fabric Loader's internal classes (net.fabricmc.loader.impl) are not provided; mods that use them are excluded before startup (111).
• A language adapter (such as fabric-language-kotlin) is used when the mod that declares it in languageAdapters is loaded. Without that mod, the mods that use the adapter are left out with a reason (114).
• Mod classes are defined by Poly Mod Loader's game class loader. When a mod from another loader is loaded, that class loader also takes Minecraft's library jars, so Mixin can change them too, as in Fabric Loader.
• The fabricloader dependency is judged by the Fabric Loader API version on the class path. mixinextras is built in (0.5.5). A mod's nested copy of it is not used (122).
• Mixin: Poly Mod Loader starts Mixin 0.8.7 (FabricMC's build 0.17.4, the one Fabric Loader 0.19.5 ships) and MixinExtras 0.5.5 when a loaded Fabric mod has a Mixin configuration. Configurations are added mod by mod with each mod's compatibility level, as in Fabric Loader. A class is changed in Fabric Loader's order: environment stripping (@Environment) and interface injection first, then Mixin.
  • A configuration that is missing, unreadable, or not a JSON object is skipped with an error, as Mixin does under Fabric Loader (136, warning). A required configuration that needs a newer Mixin blocks the mod, because Mixin would stop the game (132).
  • A mixin that fails to apply fails when its target class loads, as in Fabric Loader. The error names the transformer, the class, the mixin, and its mod (133).
  • Poly Mod Loader's own transformations keep the vanilla calls that mixins target. If a mixin @Redirect or @WrapOperation already took a call that a Poly Mod Loader rule redirects, Poly Mod Loader leaves its rule out of that class and warns (POLY-TRANSFORM-011).
• Class tweakers (access wideners): A Fabric mod that names a class tweaker with accessWidener in fabric.mod.json is no longer blocked for that alone. The bridge reads the file with the same grammar as Fabric Loader 0.19.5 (accessWidener v1/v2, classTweaker v1/v2, transitive- lines) and turns its accessible, extendable, and mutable lines into Poly Mod Loader access widenings, including the class access that Fabric implies for a widened member.
  • Before the mod loads, the link check verifies every target against the game jar. A class or member this game does not have is left out, as Fabric Loader applies such a line to nothing (137, warning). A class outside the game jar blocks the mod and its dependents (128). On a dedicated server, lines for client classes are left out (130, warning).
  • The file must exist and be valid (125, every bad line with its line number) and use the official namespace (126).
  • inject-interface lines add the interface to the Minecraft class, as Fabric Loader does (generic and nested interfaces included). An interface that no installed jar has blocks the mod (135). extend-enum lines add a stub constant to the Minecraft enum, as Fabric Loader does; the mod's own mixin gives it a value.
  • Fabric mods have no permission model, so the class tweaker itself is their declaration. They do not need the internal.member.access permission that Poly Mods need.
• Nested jars (jar-in-jar): Poly Mod Loader unpacks the jars listed in jars and judges each as a mod. It follows several levels of nesting. As in Fabric Loader, an inner mod loads only when its outer mod loads (121). If a mod has several copies, Poly Mod Loader uses the directly installed one, or else the highest version (122). An outer mod with some inner mods blocked gets a warning that it works only in part (124). Example: fabric-api on a dedicated server, where its 7 client-only submodules are left out (108).

Fabric diagnostic items

Code	Item
POLY-COMPAT-100	Metadata (format error, unreadable version condition)
POLY-COMPAT-107	Other entrypoints (warning)
POLY-COMPAT-108	Runtime environment
POLY-COMPAT-110	An entrypoint threw an exception (stops startup)
POLY-COMPAT-111–119	Link checks, dependencies, duplicate IDs (error codes)
POLY-COMPAT-120–124	Nested jars
POLY-COMPAT-125, 126	Class tweaker: unreadable or malformed file, namespace other than official
POLY-COMPAT-128, 130, 135, 137	Class tweaker link check: target outside the game jar (blocks), client targets left out on a dedicated server (warning), injected interface missing (blocks), target missing in this game version (left out, warning)
POLY-COMPAT-129	What a class tweaker widens (informational)
POLY-COMPAT-131–134, 136	Mixin: configurations for this side (informational), required configuration needs a newer Mixin (blocks), a mixin failed on a class, Mixin could not start, configuration skipped (warning)

POLY-COMPAT-104 (blocking a dependency on another mod outright), 103 (blocking a nested jar outright), and 102 (blocking any class tweaker outright) were retired on 2026-10-21. 101 (Mixin), 105 (preLaunch), 106 (:: entry points), and 127 (inject-interface, then extend-enum) were retired on 2026-10-22.

Forge

Poly Mod Loader runs Forge and FML themselves and hands FML the Forge mods it found. The first start with Forge mods downloads Forge's files. Forge versions: 62.0.9 on 26.1, 63.0.2 on 26.1.1, 64.1.5 on 26.1.2, 65.1.5 on 26.2.

Forge full support check (2026-10-23), on the three versions that have a mod set of their own (26.1.1 runs Forge 63.0.2 but has no set):

	26.2 (Forge 65.1.5)	26.1 (Forge 62.0.9)	26.1.2 (Forge 64.1.5)
Client (corpusForgeClient, opens a window): join a saved world, 200 ticks, save and quit	40 Forge mods, passed	26 (10 of 36 are left out with 209, for example because they need Forge 64 or newer), passed	36, passed
Game test server (corpusForge): create a world, GameTest, save	32 of 38	18 of 36	28 of 34
Dedicated server (corpusForgeServer): through Forge's launch handler up to the EULA check	35 of 41	19 of 37	31 of 37
Next to Fabric mods (corpusFabricForge)	33 of 39	21 of 37	30 of 35
Installed launcher profile (launcherProfileForgeTest, opens a window)	3 Forge test mods	-	The set's 36 Forge mods
Installed server (serverInstallTest)	forge_hello on the game test server and the dedicated server	-	Forge alone (forge_hello needs Forge 65 or newer)
Forge runtime features	Access transformers, Mixin, transformation services, mod locators. Forge 26.x has no JS coremods	Same	Same
Performance	Measurement 6	Same code path, not measured separately	Same

Forge mods are left out (POLY-COMPAT-209) only where real Forge also leaves them out or does not run them. Each reason was checked against Forge's bytecode and real Forge.

• Client-only mods on a server (about 6 on each version). They run on the client.
• Forge, Minecraft, or language loader version ranges (9 on 26.1, all builds for 26.1.2). FML stops all mod loading when even one such mod is present; Poly Mod Loader leaves out only that mod.
• Mixin configurations that stop Mixin 0.8.7 (a missing configuration file, JAVA_25): Balm, Boatiview, No Chat Reports.

Builds that fail under real Forge too are left out of the set runs.

Next to Fabric mods (26.2, corpusFabricForge), 90 Fabric mods create a world, pass GameTest, and save it with the Forge mods. The mod lists see each other: FML's ModList.getModFileById and isLoaded see Fabric mods and Poly Mods, Fabric's isModLoaded sees Forge mods, and a Poly Mod's ModContext.mods() sees every loader's mods. getModContainerById returns Forge mods only. Fabric mixins aimed at code that Forge's patch moved or removed are reported with POLY-COMPAT-138 (25 injection points do not run, 2026-10-23); the list is in Run Fabric and Forge mods together. A jar with both a Fabric and a Forge build of one mod runs as its Forge build (139).

Good to know:

• If any mod gives Forge a loading warning, Forge turns off its main event bus before the warning screen and does not turn it back on. After that, game events reach no mod. Real Forge behaves the same, but a mod with a warning can make other mods silently stop working.
• Each mod's features were not checked one by one. The checks cover loading, initialization, joining a world, ticking, saving, and quitting.
• There is no record of a run with the real Minecraft Launcher. The launcher profile runs reproduce how the launcher starts the game.

Forge diagnostics: POLY-COMPAT-200–205 (metadata, FML language provider, Mixin, Access Transformer, dependencies, library jars), 206 (Forge's files could not be prepared), 208 (FML failed while starting), 209 (left out before FML starts), 211, and 212–214 for Fabric mixins next to Forge. See Error codes.

NeoForge

Poly Mod Loader runs NeoForge and its own loader, FML 11, and hands FML the NeoForge mods it found. This is the default; the first start with NeoForge mods downloads NeoForge's files. NeoForge versions: 26.1.0.19-beta on 26.1, 26.1.1.15-beta on 26.1.1, 26.1.2.122 on 26.1.2, 26.2.0.93 on 26.2. NeoForge has only beta builds for 26.1 and 26.1.1; Poly Mod Loader uses the last one.

The option -Dpoly.neoforge=off restores the old behaviour: NeoForge mods get diagnostics only and are left out (metadata, FML language provider, Mixin, Access Transformer, dependencies as a warning, and library jars, POLY-COMPAT-200..205). Poly Mod Loader reports the IDs of all [[mods]] in one jar, so a mod from another loader that needs one of them gets the precise reason "installed but blocked".

NeoForge full support check (2026-10-24), on the three versions that have a mod set of their own (26.1.1 runs NeoForge 26.1.1.15-beta and is checked with a world test and the installed server, but has no set):

	26.2 (NeoForge 26.2.0.93)	26.1 (26.1.0.19-beta)	26.1.2 (26.1.2.122)
Client (corpusNeoForgeClient, opens a window): join a saved world, 200 ticks, save and quit	54 NeoForge mods (44 jars, FancyMenu, Sodium and Iris included), passed	36 (37 jars), passed	55 (45 jars), passed
Game test server (corpusNeoForge): create a world, GameTest, save	38 (the set's 36, a test harness mod and a probe mod), passed	31 of 35 (4 left out with 217), passed	40 (the set's 38, the harness and the probe), passed
Dedicated server (corpusNeoForgeServer): NeoForge starts the game up to the EULA check	37, passed	30 of 34, passed	39, passed
Installed launcher profile (launcherProfileNeoForgeTest, opens a window)	neoforge_hello and a session test mod	-	The set's 54 NeoForge mods (44 jars)
Installed server (serverInstallTest)	neoforge_hello and the harness on the game test server and the dedicated server	The harness, same	The harness, same
NeoForge runtime features	FML's processors (access transformers, enum extensions, Mixin, ServiceLoader processors), JarJar, language providers (Kotlin), FML plugin libraries, and early services work with real mods (server)	Same	Same
Performance	Measurement 8	Same code path, not measured separately	Same

Without the probe mod, the game layer has as many modules as NeoForge's own installation builds from the same jars (56 on 26.2, 45 on 26.1, 58 on 26.1.2). The NeoForge mods left out are only ones that also stop or are refused on NeoForge's own server; each was checked against NeoForge's own installed server with the same jars and harness.

• Client mods that stop a server: Sodium (its FML early service looks for LWJGL), Sodium Extra, Reese's Sodium Options and Iris (their Mixin plugins look for Sodium's classes), ImmediatelyFast 1.16.5 on 26.2, and Zoomify. They are left out of the server runs only and run on the client. NeoForge's metadata has no client-only marker, so, as in NeoForge, Poly Mod Loader does not leave them out by itself.
• NeoForge version ranges on 26.1 (POLY-COMPAT-217): Forge Config API Port, JEI and Puzzles Lib need 26.1.2's NeoForge. NeoForge stops all mod loading when even one such mod is present; Poly Mod Loader leaves out only that mod and the mods that need it.
• On 26.1, Architectury 20.0.4, Veinminer 2.10.4 and Jade 26.1.12 match their neoforge.mods.toml but stop NeoForge's own server too, so they are left out of the set runs.
• On the 26.1 client only, Lambda Dynamic Lights 4.11.2+26.1.2 needs a NeoForge class that 26.1.0.19-beta does not have (real NeoForge stops there too). It runs on the 26.1 server.

Good to know:

• NeoForge mods do not run in the same game as Fabric or Quilt mods yet: the NeoForge mods are left out with the reason (POLY-COMPAT-216). With Forge mods in the same game, Forge runs and the NeoForge mods are only diagnosed. Fabric, Forge and Quilt mods can be mixed.
• A mod that FML would refuse is left out before FML starts, so the other mods still run (POLY-COMPAT-217).
• FML's ModList.getModFileById and isLoaded answer for Poly Mods too (POLY-COMPAT-218 if NeoForge's ModList is not the code Poly Mod Loader checked). The log and the title screen count NeoForge mods on their own line.
• NeoForge does not run Mojang's game tests in production, also in its own installation, so the game test server checks use a test harness mod.
• With NeoForge, Poly Mod Loader's own rules for the brand, the title screen and the creative tabs are off, because NeoForge does those itself, and so is its payload codec rule: Poly Mods' network channels next to NeoForge have not been checked and may not work.
• Each mod's features were not checked one by one. There is no record of a run with the real Minecraft Launcher; the launcher profile runs reproduce how the launcher starts the game.

NeoForge diagnostics: POLY-COMPAT-200–205 (when NeoForge does not run), 215–218. See Error codes.

Quilt

Poly Mod Loader runs Quilt mods on Minecraft 26.1, 26.1.2 and 26.2. Quilt Loader itself is not needed: Poly Mod Loader reads quilt.mod.json and provides the Quilt Loader API.

What runs:

• quilt.mod.json, read with Quilt Loader's meaning: a bare version means ^, optional, any/all groups and unless in dependencies, and provides.
• Nested mods in quilt_loader.jars. A nested mod that loads only when required, and that no loaded mod requires, is not loaded, as under Quilt Loader (POLY-COMPAT-307).
• The public API of Quilt Loader 0.31.0-beta.4 (org.quiltmc.loader.api). Internal classes that are not provided are blocked by the link check (111).
• The entry points main, client, server, and pre_launch.
• Quilt mods' Mixin, access wideners, and environment-based class stripping.
• Fabric jars built for Quilt that require quilt_loader (Better Shulker Boxes, F34, InvSearch Storage Indexer, MTA NYC Subway Signs), as under Quilt Loader. FabricLoader.isModLoaded("quilt_loader") is false, as under Fabric Loader.

What does not run:

• QSL entry points (init, client_init, server_init) are not run (POLY-COMPAT-303). Quilt Standard Libraries (QSL) has no release for 26.x, so Quilt Loader does not run them either.
• A mod that depends on QSL or Quilted Fabric API is left out (POLY-COMPAT-114, with 308 giving the reason).
• Quilt Loader plugins (301), Quilt language adapters (302), and the modifiable file system overlay (306) are not provided; mods that need them are blocked.

Where Poly Mod Loader deliberately differs from Quilt Loader:

• A jar with both fabric.mod.json and quilt.mod.json runs as a Fabric mod (310), so jars that already run as Fabric mods keep doing so. Quilt Loader would read quilt.mod.json.
• A Maven group:id dependency is matched by its ID only.

Quilt full support check (2026-10-24), on 26.2, 26.1 and 26.1.2. The test set is every project on Modrinth that has a Quilt build and no Fabric build for that Minecraft version, plus the mods those builds require: 114 and 3 required mods (Fabric API, Cloth Config, Fusion) on 26.2, 97 and 1 (Fabric API) on 26.1, 50 and 1 on 26.1.2. Most of them (65 on 26.2) are data packs packaged as mods; about 30 have classes.

	26.2	26.1	26.1.2
Game test server (corpusQuilt): create a world, GameTest, save, with the Quilt mods' data packs in the saved world	135 external mods (80 Quilt), nested and required mods included; Simple Voice Chat's voice server starts	118 (69 Quilt)	73 (25 Quilt)
Dedicated server (corpusQuiltServer): up to the EULA check	133	116	71
Quilt-only builds loaded on the server	93 of 114	79 of 97	34 of 50
Quilt-only builds loadable on the client (corpusAssessmentQuilt, without the game)	103 of 114	81 of 97	38 of 50
Client (corpusQuiltClient, opens a window): join a saved world, 200 ticks, save and quit	Passed: 155 external mods (88 Quilt, 67 Fabric)	Passed: 131 (73 Quilt)	Passed: 88 (30 Quilt)
Every client-side mixin applies (mixinAuditQuiltClient, without the game)	Passed (461 target classes)	Passed (408)	Passed (411)
Next to Forge mods (corpusQuiltForge, the Forge set in the same game)	Passed: 123 external mods, 41 of 47 Forge mod files	Passed (Forge 62.0.9): 113, 24 of 40	Passed (Forge 64.1.5): 68, 33 of 38
Installed server (serverInstallTest, quilt_hello on the game test server and the dedicated server)	Passed	Passed	Passed
Installed launcher profile (launcherProfileTest with quilt_hello, opens a window)	Passed	-	-
Test mod scenarios (quiltOnly, quiltFabricPoly, quiltBlocked: Quilt, Fabric and Poly Mods together)	Passed	Passed	Same as the 26.1 modules
Compared with real Quilt Loader 0.31.0-beta.4 (quiltLoaderReference, dedicated server)	113 of 114 the same	96 of 97	48 of 50
Performance	Measurement 7	Same code path, not measured separately	Same

Quilt mods are left out only where real Quilt Loader also leaves them out or cannot run them. On 26.2, the 21 left out on the server are:

• 7 with metadata Quilt Loader refuses too (300): no intermediate_mappings (3), the experimental Mojang mappings feature (1), a license string that is not SPDX (2), and a quilt.mod.json that is not JSON (1).
• 2 with a version range written like ">=26.2 <26.3". By Quilt's rules that is one comparison, which does not accept 26.2 (114); Quilt Loader stops on them too.
• 11 client-only mods on a server (305, 108). One of them, Armor Visibility, is loaded by Quilt Loader there, but it only has client code, so none of it runs on a server under Quilt Loader either.
• 1 jar that is not a mod (a Paper plugin, POLY-DISCOVERY-002).

26.1 and 26.1.2 have one more: Yeth's TPA is compiled against Minecraft 1.21's intermediary names, so Poly Mod Loader leaves it out (112). Quilt Loader loads it but does not remap mods on 26.x, so it fails as soon as it runs.

Good to know:

• Resource mods and QSL. The 65 resource mods on 26.2 depend on quilt_resource_loader unless fabric-resource-loader-v0 is present. With Fabric API installed, neither Quilt Loader nor Poly Mod Loader checks that dependency, and Fabric API's resource loader builds their data packs. Without Fabric API they are left out (114 with 308), as under Quilt Loader.
• Next to Forge mods, the rules are the same as for Fabric mods: a jar with both Quilt and Forge metadata runs as its Forge build, and the Quilt build of Simple Voice Chat is left out when Forge loads its own build (139).
• Mixins that Mixin itself refuses. Even Better Moon and Sun on 26.1 and 26.1.2 has an injection point Mixin 0.8.7 refuses, so it is left out before the game starts (140). NeoFullbright 1.0+mc26.2 has a mixin Mixin refuses on the client under every loader, so it is left out of the client runs. Fabric Loader and Quilt Loader use the same Mixin.
• Mods that load but have defects of their own. Omni stops a server with NoClassDefFoundError as soon as a mob jumps, and Craftable Bucket of Sulfur Cube names a missing function in minecraft:tick, so the game rejects that tag and no data pack's tick function runs. Real Quilt Loader behaves the same.
• Real Quilt Loader was not run on the client for comparison. Each mod's features were not checked one by one.

Quilt diagnostics are POLY-COMPAT-300–310; see Error codes.

Fabric results with real popular mods (2026-10-21, updated 2026-10-22)

The test set is the 40 most downloaded Fabric, NeoForge, and Forge mods each for 26.2 on Modrinth, plus the mods they require. That is 125 jars, 123 of them external mods. Each mod was judged alone and with all the others, on both client and server, and the set also ran on the game test server.

• Exceptions during judging and game crashes: 0. Every jar ended as loaded, or left out with a reason.
• Loadable mods: 0 (before nested jar support). The reasons that blocked mods were, in order, Mixin (Fabric 45, FML 34), FML runtime (71), nested jars (26), and class tweakers (26).
• After nested jar support: 142 nested mods are now judged. Among directly installed mods, fabric-api loads, but only 1 of its 44 submodules loads (works in part, 124).
• After the Fabric Loader API was provided: 17 external mods are loadable (placeholder-api, fabric-language-kotlin with 13 Kotlin libraries, and fabric-api, which works in part). The game starts normally in this state.
• After class tweaker support:
  • Mods blocked by a class tweaker (102): 26 directly installed and 54 nested before, 0 now (102 is retired).
  • All 80 class tweakers of the corpus mods are read. Format errors (125), other namespaces (126), and targets missing in 26.2 (128): 0.
  • Blocked by interface injection (127): 2 directly installed, 40 nested. All of them also use Mixin (101).
  • What still blocks the mods with class tweakers: Mixin for 74. The others: cloth-config (a :: entrypoint, 106), veinminer (a Fabric API class that is not loaded, 111), pridelib (nested, outer jar and dependency blocked, 121 and 114; 108 on the server), and one copy (122).
  • Loadable external mods together: 17 → 18 (3 of them directly installed). The new one is fabric-transitive-access-wideners-v1 inside fabric-api.
  • Game test server: corpusFabric 18 loaded / 156 not, corpusAll 19 / 247 (before: 17 / 157 and 18 / 248). It applies 433 access widenings (0 rejected) and starts normally.
  • Exceptions during judging and game crashes: 0.
  • Most mods that use class tweakers also use Mixin, so only one more mod loads. What this shows is that Poly Mod Loader reads all 80 real files with Fabric's grammar without errors, checks them against the 26.2 jar, and the server starts normally with 433 widenings applied. It does not mean those mods' features work.
• After Mixin support (2026-10-22):
  • Directly installed Fabric mods that load together: 3 → 42 of 52 on the client, 3 → 28 on the dedicated server. All external mods that load together, nested ones included: 18 → 127 on the client, 100 on the server.
  • Fabric API submodules: all 44 on the client, 37 on the server (the other 7 are client-only, 108).
  • The real dedicated server start (net.minecraft.server.Main) with every Fabric mod: 99 mods load, mixins apply, mods initialise, and Fabric API freezes its registries, up to the EULA check.
  • Game test server: 97 mods (without the two Xaero mods) create a world, pass GameTest, tick, and save.
  • Still blocked on the client: 4 mods (collective, iris, lambdynlights, zoomify) whose jars are in the test set more than once, for several loaders (same ID, 117; this does not happen in a real install) and customskinloader-bootstrap (Fabric Loader internals, 111). On the server, mostly client-only mods (108).
  • Exceptions during judging and game crashes: 0.
  • Client (corpusFabricClient, opens a window): 137 mods load and initialise, Sodium and Iris start, and the player joins a saved world. Getting there needed one fix: mod code that runs before the game (Fabric's preLaunch, Mixin config plugins) now sees the game class loader as the thread context class loader, as under Fabric Loader.
  • This shows that the mods load, start, tick, save, and join a world on the client. It does not mean every feature of every mod was checked; nobody looked at the rendered result yet.
• Fabric full support check (2026-10-22), on 26.1 and 26.2:
  • Client (corpusFabricClient, opens a window): the player joins a saved world with every Fabric mod, plays 200 ticks, uses "Save and Quit to Title", and the client stops. On 26.2, 140 mods (138 real mods plus 2 test mods); on 26.1, 128 (126 real mods plus the same 2).
  • Real dedicated server start: 100 on 26.2, 93 on 26.1. Game test server: 98 and 91.
  • The installer's launcher profile starts the game with a Fabric mod.
  • Directly installed Fabric mods still left out: several loaders' copies of one mod in the test set (117), client-only mods on a server (108) and, on 26.1, mods that need Minecraft 26.1.2 or a newer Sodium (114).
  • Fixed along the way: CustomSkinLoader (Fabric Loader's launcher, and reading version.json to pick its rules), and collective, which was blocked by a Minecraft method only its NeoForge code uses.
  • With CustomSkinLoader installed, a "Client shutdown from post-main" crash report is left after the client stops: the mod keeps its threads for a minute and Minecraft's shutdown watchdog reports after 15 seconds. The world is already saved; Fabric Loader behaves the same.
• This record is about Fabric mods. Forge's results are in Forge, and NeoForge's in NeoForge.

How to check

• A mod that was not loaded has its reason in blockedFiles and foreignMods of .poly/startup-report.json: in the launcher folder for an installed game, in the server folder for a server, and in run/<side>/ for a mod project's development runs.
• A jar from a loader with no bridge is blocked with POLY-COMPAT-001.
• Poly Mod Loader automatically verifies mixed runs, dependencies across loaders, blocking cascades, nested jars, the Fabric Loader API, class tweakers, and the real popular mod set on every release.

Why mixed runs are hard

Risk	Reason
Game class ownership	Several loaders all try to define net.minecraft themselves. Only one loader can own it
Duplicate Mixin services	Each loader registers a Mixin service, but Mixin state is global
Module layer vs flat class path	FML assumes a module layer, Fabric mods assume a flat class path
Transform order	Each loader has a different transform order model
Registry timing	The time at which you can register differs by loader
Network negotiation	The way required channels and registries are synced differs

Minecraft 26.x is not obfuscated, so mods from all three loaders use the same namespace (Mojang's original names). The risk of mapping conflicts is much smaller.