Retromod

Fourth 1.4.0 snapshot. Shows Retromod's screens on more clients, gives Forge 26.x the shared repairs, bridges more renamed and removed APIs, and brings the CLI in line with the game.

Added

• Carries the fuel and compost data maps of translated NeoForge mods into the item components NeoForge 26.3 uses, so their fuels burn and their items compost again.
• Rebuilds DistExecutor on Forge 26.2 and newer, which removed it, so mods that pick a client or server proxy with it, often while their main class loads, construct again. Only the running side's code is called.
• Gives Forge 1.20.1 mods translated in game on Forge 1.21.11 and newer the CraftingHelper and IConditionSerializer replacements the CLI already embedded, so mods that register recipe conditions, such as Sophisticated Core, construct again.
• Repairs the replacement for BlockEntityType.Builder on Forge 26.2 and newer. It called a constructor only NeoForge has, so block entities from mods such as Lootr failed to register on Forge.
• Rebuilds Forge 1.20.1's event base on Forge 26.2 and 26.3, so events an old mod defines load again and keep their cancel flag, result, and phase. Old Event.Result values map onto Forge 26.2's own result type, and instanceof Event and Event.class checks work for Forge's events and old mods' events alike.
• Delivers an old mod's own events on Forge 26.2 and 26.3 the way Forge 1.20.1 did: listeners run by priority and class depth, a canceled event skips the listeners that do not receive canceled events, generic events filter by type, and the game bus stays quiet until loading completes. Events posted by one translated mod reach listeners in another.
• Subscribes an old mod's @Mod.EventBusSubscriber classes that listen to its own events when the mod's constructor finishes on Forge 26.2 and newer, and registers a class that mixes its own and Forge's events only once.
• Subscribes old Forge mod-bus subscriber classes from the mod's constructor when Forge 26.2 or 26.3 moved one of their events, such as key mappings, creative tab contents, or entity renderers, to a bus of its own. These mods no longer stop at loading with an error that the event must inherit from IModBusEvent.
• Registers each static handler once and only the public static handlers of a class an old mod passes to the event bus on Forge 26.2 and newer, as Forge 1.20.1 did, so handlers no longer run twice.
• Keeps old Forge mods that call ModLoader.get() working on Forge 26.2 and 26.3. Their posts to every mod's bus, loading-state checks, and warning lookups reach Forge's static ModLoader, and a check for the removed OBJECT_HOLDERS state is answered by the state just before it.
• Logs an old Forge mod's loading warning once instead of passing it to Forge on 26.2 and 26.3, where a shown warning stops every game event after loading.
• Lets old Forge mods cancel Forge events on Forge 26.2 and 26.3 from listeners added with addListener, so a cancel stops lower-priority listeners and post() returns true, as on Forge 1.20.1. setCanceled, isCanceled, isCancelable, and cancel() work on Forge events again, and a cancel of ProjectileImpactEvent skips the hit entity.
• Lets old Forge @SubscribeEvent handlers cancel events on Forge 26.2 and 26.3, so lower-priority listeners stop as they did on Forge 1.20.1. A handler that does not cancel leaves later listeners running, even on a block break Forge already refused, and a handler marked receiveCanceled runs once per event.
• Lets a handler on PlayerInteractEvent and the other parent events cancel RightClickBlock and the other cancellable child events, and reaches old handlers and addListener lambdas on parent events Forge no longer posts, such as ScreenEvent.Init (both Init.Pre and Init.Post), MobSpawnEvent, and on Forge 26.3 the key mapping event, whose isAttack, isUseItem, and isPickBlock keep working.
• Hooks the one static handler of a subscriber class even when its event is one Retromod added to the jar.
• Keeps a result on Forge 26.2 and 26.3 events that no longer have one, such as RightClickBlock, EntityMountEvent, and FinalizeSpawn, so old mods read back what they or another mod set, and answers hasResult() the way Forge 1.20.1 did.
• Stops a block break when an old mod cancels BreakEvent, which Forge 26.2 and 26.3 refuse only through a deny result, so claim and protection mods keep protecting blocks.
• Hides a name tag when an old mod denies RenderNameTagEvent, and ends a left click on the server when an old mod denies LeftClickBlock for a player outside creative, as Forge 1.20.1 did.
• Runs Forge 1.20.1 listeners on the base TickEvent on Forge 26.2 and 26.3, where they hear all five tick events as before, and answers their TickEvent.Type reads.
• Makes IEventBus.unregister work on Forge 26.2 and 26.3, so mods such as spark, JEI, and DynamicTrees can stop listening while the game runs. Every handler an object registered leaves together, registering it again brings them back once, and an equal object unregisters it as on Forge 1.20.1.
• Delivers old Forge event handlers that listen to a parent event, such as AdvancementEvent, PlayerEvent, BlockEvent, or ScreenEvent.Render, to every event below it on Forge 26.2 and 26.3, as Forge 1.20.1 did, and keeps them on the game bus so a mod's own bus no longer refuses them.
• Keeps each such handler's priority and cancel behavior on every event it now receives, and runs a handler that asks for cancelled events exactly once per event.
• Leaves out events an old listener never heard because Forge 1.20.1 posted them on the other bus, such as the sound engine's load event under SoundEvent.
• Rebuilds Forge 1.20.1's HUD overlay API on Forge 26.2 and 26.3 inside each old mod: RegisterGuiOverlaysEvent, VanillaGuiOverlay, NamedGuiOverlay, GuiOverlayManager, ForgeGui, and the RenderGuiOverlayEvent and RenderGuiEvent events. Mods such as Jade, AppleSkin, and Patchouli load past these classes again.
• Lets old code cast Minecraft.gui to ForgeGui on Forge 26.2 and 26.3 and read its left and right heights.
• Drops old mixins on Forge's removed ForgeGui and VanillaGuiOverlay, so the rest of mods such as Embeddium, Oculus, ImmediatelyFast, Quark, and BetterF3 still loads.
• Turns Forge 1.21 LayeredDraw layers into Forge 26.2 layers, so overlays added through AddGuiOverlayLayersEvent link again.
• Draws old Forge 1.20.1 HUD overlays on Forge 26.2 and 26.3, placed after the vanilla overlay they were registered next to, and posts the old whole-HUD and per-overlay render events around them.
• Keeps the old left and right status bar heights, so mods that draw beside the hearts, armor, food, and air bars line up.
• Passes a cancelled HUD event from one mod's listeners to the next mod's, so a listener that takes cancelled events can still see or undo the cancel.
• Turns off only an overlay that needs a missing class or member, and keeps drawing the HUD when an old listener throws.
• Keeps posting the old HUD events and drawing the old overlays when another mod replaces one of the HUD layers they belong to.
• Registers Forge 1.20.1 ingredient serializers on Forge 26.2 and 26.3, so CraftingHelper.register and getID work again and recipes read custom ingredients through the old JSON read.
• Keeps custom ingredients that extend Forge 1.20.1's AbstractIngredient loading on Forge 26.2 and 26.3, and writes them back through their old toJson.
• Skips a recipe on Forge 26.2 whose old ingredient read fails, with one log line, instead of stopping the data load.
• Rebuilds Forge 1.20.1's RenderLevelStageEvent on Forge 26.2 and 26.3, so mods that listen to it, such as Carry On and Sophisticated Core, get past construction. Their listeners hear every stage each frame, in the old stage order and in mod order.
• Fires the old render stages from one shared frame pass, with the camera rotation in the event's PoseStack and the hurt tilt and view bobbing in its projection, as on Forge 1.20.1.
• Keeps Forge 1.21's getPoseStack() that returned a matrix working on Forge 26.2 and 26.3.
• Posts RegisterStageEvent when the world renderer is built, as Forge 1.20.1 did. Stages it adds fire right after AFTER_LEVEL.
• Registers old Forge 1.20.1 and 1.21.1 block colors as Minecraft's tint sources on Forge 26.2 and 26.3, so tinted leaves, grass, and other mod blocks keep their colors.
• Rebuilds the old item color event on Forge 26.2 and 26.3 and posts it after every block color handler, as Forge did before, so an item handler can read the block colors other mods registered.
• Writes item tints into the item definitions Retromod generates for an old Forge mod whose constructor sets up item colors, so its items show the colors its code returns.
• Lets an addon pass color handlers and other Retromod stand-ins through its library's generic events, by reusing the library's copies of the types those events name.
• Draws a color untinted, and logs it once, when an old color handler fails on an API a newer Minecraft removed, instead of stopping the game.
• Rebuilds Forge 1.20.1's ChunkRenderTypeSet inside each old mod on Forge 26.2 and 26.3, as a set of the three block layers Minecraft 26.2 keeps, and maps old RenderTypeGroup constructors onto Forge 26.2's chunk layer groups.
• Records old ItemBlockRenderTypes.setRenderLayer calls so getRenderLayers reads them back.
• Rebuilds Forge 1.20.1's int[] quad API on Forge 26.2 and 26.3, so old BakedQuad constructors and getters, IQuadTransformer, and QuadTransformers work with Minecraft 26.2 and 26.3 quads.
• Rebuilds Forge 1.20.1's BakedModel, IDynamicBakedModel, BakedModelWrapper, and ItemOverrides inside each old Forge mod on Forge 26.2 and newer, so old custom block and item models draw through Minecraft's new block and item models.
• Keeps ModelEvent.ModifyBakingResult.getModels() as a live map keyed the 1.20.1 way, such as mod:block#facing=north, including the missing model's key, so mods that read and replace models by key keep working. A replacement Minecraft cannot take is skipped and noted in the log.
• Gives ModelEvent.BakingCompleted.getModels() a read-only view of the finished bake, and answers ModelManager.getModel and getMissingModel for old block, item, and extra-model keys.
• Posts the old ModelEvent.RegisterAdditional each time Minecraft lists its resource packs, and bakes each requested model into a generated client pack so getModel finds it. Inventory locations read the item model folder, as before.
• Keeps old ModelResourceLocation values as identifiers that carry their variant. Calls made on the old type, such as getPath() or an instanceof check, answer as they did in 1.20.1.
• Draws old item models with Forge 1.20.1's display transforms, and gives each stack its own cached inventory picture when its overrides pick another model.
• Rebuilds Forge 1.20.1's geometry loader API on Forge 26.2 and 26.3, so an old mod's custom model loader registers under its mod's name at each resource reload and bakes its models, including loaders a library such as Moonlight registers for an addon.
• Draws an old custom model that changes with block data or the item stack through the old model again, for single-model block states and items, including models that draw nothing until a block entity gives them data.
• Bakes the models an old loader nests or builds on a parent file, as Lootr's barrels and the backpack mods do, by reading those parents from the resource packs.
• Adds Retromod's own forge:composite, forge:item_layers, forge:elements, and forge:separate_transforms model loaders, which Forge 26.2 removed, and turns a separate_transforms item model into an item definition that picks its model by display context.
• Lets old code look up and bake models through ModelBaker, ModelBakery, and UnbakedModel, and build Minecraft 1.20.1's JSON BlockModel, on Forge 26.2 and 26.3.
• Keeps Retromod's own classes inside a translated mod on the names the host has, so a version-limited rename meant for the old mod no longer reaches them.
• Lets you drop old mod jars onto the Retromod screen. Retromod handles them like jars chosen with Choose Mods…, through Minecraft's own file drop on every supported version.
• Uses the SDL file picker on 26.3 and tinyfd on 1.20 to 26.2, and starts it in the folder you last chose mods from. Retromod keeps that folder in retromod-cache/file-picker.properties instead of Java preferences, so the path stays out of config/ and modpack exports.

Fixed

• Gives Forge 26.x mods the same shared 26.1 repairs that Fabric, NeoForge, and the CLI already apply, so a Forge mod that translates correctly on the command line also loads in game.

• Bridges the old NBT getters such as getInt, getString, and getBoolean on Forge and NeoForge 1.21.5 and newer, returning the old default for a missing key. CompoundTag.remove is adapted only from 1.21.11, where it started returning the removed tag.

• Renames old PathType fields such as DANGER_FIRE on 26.1 and newer for every loader, and leaves them alone on 1.21.x hosts that still have them.

• Translates registryOrThrow and getHolderOrThrow to their 1.21.2 names on Forge and NeoForge 1.21.2 and newer, including calls through a server's registry access.

• Rebuilds Forge keybinds that name a conflict context on Forge 1.21.9 and newer, and String-category keybinds on Forge and NeoForge 1.21.9 to 1.21.11.

• Bridges NeoForge data attachments that serialize with a Codec from NeoForge 1.21.6, where serialize started taking a MapCodec, not only on 26.x.

• Answers the removed no-argument Item.getName() and getDescription() on every 26.x host, and maps getDescription() to getName() on Forge and Fabric 1.21.2 to 1.21.11.

• Keeps blocks built with lootFrom loading on NeoForge 1.21.2 and newer and on Forge 26.x.

• Keeps old biome spawn code working on 1.21.5 and newer. new SpawnerData(type, weight, min, max), addSpawn, and the list from getSpawner(category) write to the host's weighted spawn list.

• Translates addRegionTicket and removeRegionTicket to the 1.21.5 radius tickets on every loader from 1.21.5, including the Forge and NeoForge overloads with a forceTicks flag.

• Registers the food, MobType, synched entity data, tree grower, worldgen codec, and particle type bridges for 1.20.1 Fabric mods on Fabric 26.x, as Forge and NeoForge already did.

• Keeps old dispense behaviors that call getLevel(), getPos(), or getBlockState() working on 26.1 to 26.3 for every loader.

• Leaves SandBlock alone for mods built for 1.21.5 or newer, so their mixins and type checks name the host class again. Older mods still get the generated replacement.

• Bridges DyeColor.getTextureDiffuseColors() for Fabric mods on 1.21 and newer, and keeps Fabric 26.x mods that copy the barrier or light block from failing while block states are built.

• Answers 1.21.1 recipe lookups by type, getAllRecipesFor and getRecipesFor, on Forge 1.21.2 and newer and on Fabric and Quilt 26.x.

• Rebuilds the FriendlyByteBuf helpers 26.3 removed, such as writeCollection, readMap, readList, writeIntIdList, and writeBlockHitResult, for every loader. Packets from older mods keep the bytes they wrote before.

• Follows the furnace timers 1.21.4 renamed, so reads and accessors of cookingProgress, litTime, and litDuration in older mods reach cookingTimer, litTimeRemaining, and litTotalTime on every loader.

• Moves old RenderType factories such as entitySolid, eyes, and the block layers to RenderTypes on 1.21.11 and newer, for Forge and NeoForge mods. NeoForge 1.21.11 pointed the block layers at a class that no version has.

• Maps RenderType.translucent() to translucentMovingBlock() on 1.21.6 to 1.21.10, for every loader.

• Drops calls to the RenderSystem state setters, such as enableBlend() and setShaderColor(), on each 1.21.x host that removed them, not only on 26.x. Mods load there, minus their manual blend, depth, and tint state.

• Carries the GUI drawing repairs down to NeoForge and Forge 1.21.2 to 1.21.11: the 2D pose stack and drawString from 1.21.6, and blit, blitSprite, setColor, and bufferSource from 1.21.2. Old blit texture calls now draw on Fabric 26.x as well.

• Carries the 1.21.9 key and mouse event changes down to NeoForge and Forge 1.21.9 to 1.21.11. Screens that call or override keyPressed and mouseClicked, check hasShiftDown(), or poll InputConstants.isKeyDown work there, and key presses in old screens work again on 26.3.

• Repairs old JOML calls such as PoseStack.mulPose and addVertex from 1.21.5 on every loader, and the same widening on 26.x for rotateAround, transformNormal, Transformation, and ItemTransform.

• Repairs old SoundManager.play, GameNarrator.sayNow, Mth.sin and cos, ClickEvent and HoverEvent constructors, CompoundTag.getAllKeys, and Util executor calls on the Forge and NeoForge 1.21.x hosts that changed them.

• Repairs old RenderSystem.applyModelViewMatrix(), main render target binds, DynamicTexture constructors, InventoryMenu.BLOCK_ATLAS, Font.drawInBatch, and EntityRenderDispatcher.cameraOrientation() calls on the 1.21.x hosts that removed or changed them.

• Translates SignText.setColor to withColor on 26.3, and Particle.getLightColor to getLightCoords on 26.1 and newer, including calls made through particle subclasses.

• Translates BoatModel.createBodyModel() to createBoatModel() for Forge and NeoForge mods on 1.21.2 and newer, so mods that register boat model layers keep starting.

• Bridges MapColor.calculateRGBColor for Forge and NeoForge mods on 1.21.2 and newer, so colors keep the channel order those mods expect.

• Plays the right eat, drink, and item sounds for Forge and NeoForge 1.21.1 mods on 1.21.2 and newer, where those sounds became holders.

• Stops the fuzzy resolver from swapping unrelated short names, such as chains turning into air or kill() calling tick(). A name that does not look like a rename stays unresolved and is listed in config/retromod/fuzzy-report.tsv, and near misses no longer fill the log at WARN.

• Reads a Fabric mod's Minecraft dependency the way Fabric does, including arrays such as ["1.21", "1.21.1"] and escaped ranges. Mods built for 1.21 and newer no longer receive rewrites meant only for older mods.

• Copies a Fabric or Quilt mod unchanged when it declares a prerelease-marked range that starts at the host, such as >=26.1- on 26.1.

• Reads a Forge or NeoForge mod's Minecraft version the same way on every path when it declares no minecraft dependency, instead of taking it from another dependency's range.

• Reads a jar built for several loaders through the metadata of the loader that runs it, in game and in the CLI.

• Keeps Forge mods built for 1.20.2 and newer on Forge's own networking classes on every path. The step that adds compatibility classes to a translated jar sent them back to the 1.20.1 networking bridge, so their packets called a method no host has.

• Keeps mods built for 1.21.5 and newer on the host's SandBlock when their jar also needs a compatibility class.

• Reads each mod's Minecraft version in the CLI batch command, as transform does, so version-limited fixes and SRG names follow the mod.

• Repairs translation of Forge mods that create their own loot condition or loot function types on Minecraft 26.1 and newer, such as Lootr and Farmer's Delight, in game and in the CLI transform, batch, and aot commands. The translated jar now carries every compatibility class those types use, so Retromod no longer refuses it and leaves the untranslated original to the loader.

• Removes a stale module descriptor that a mod left at its jar root, such as the Lucene one in JEI, when it names packages the jar does not contain. Forge 26.2 refused such a jar with "Invalid module-info", and it now loads as an automatic module.

• Reads the Minecraft version of Forge and NeoForge mods that declare no minecraft dependency from their file name, or from the Forge version they require. About one in eight Forge mods, such as Clumps, Jade, and AppleSkin, used to be left untranslated, and on Forge 26.x their old names stopped the game.

• Relaxes Forge and NeoForge dependency ranges written before the block's modId, and ignores commented-out modId lines. In-place translations of such mods no longer stop at the loading error screen.

• Ships the promoted Forge metadata on NeoForge 1.21 and newer when a mod also carries a stale neoforge.mods.toml.

• Refuses a Forge or NeoForge translation whose generated stand-in classes cannot be placed, instead of serving a jar that fails later with NoClassDefFoundError.

• Records why an in-place translation failed, and retries one that failed on a disk error instead of marking it failed for good.

• Translates a Forge or NeoForge jar chosen in the file picker the same way startup does, so it gets a safe file name and the toml its host reads.

• Keeps registering the remaining version shims when one shim fails, and names the shim or polyfill that failed.

• Logs the stack trace of a failed mod translation at the default log level on every loader, and warns with the cause when write_translated_jars mode cannot rewrite a jar in mods/.

• Reports a class in a bundled library that could not be translated, on Fabric and Quilt before 26.1 and in the CLI and aot.

• Logs bridge notices once per launch on NeoForge instead of twice.

• Shows the Retromod title screen button on Forge and NeoForge clients again, including Forge 26.x, with the in-place status, the write_translated_jars switch, and the restart prompt. The log no longer calls a client a server.

• Opens Retromod's screens and restart prompt on Minecraft 26.2 and newer, and on Fabric and Quilt 1.20 to 1.21.11.

• Repairs the Choose Mods button so it opens your system file picker. When no picker is available, Retromod opens retromod-input/ and shows where to put the jars.

• Lists the reason under each failed or skipped mod on the results screen, and asks before it closes Minecraft.

• Renames the folder button to Open retromod-input/, the folder it opens, and makes it work on 26.x.

• Makes Escape leave Retromod's screens, and keeps the Retromod screen's buttons after a resize or a return from settings.

• Shows each setting the way Retromod reads it and saves only the setting you change. Closing the settings screen no longer turns verification on or switches Forge and NeoForge back to in-place loading.

• Hides Cache transformed mods on Forge and NeoForge, which never read that setting.

• Translates the restart prompt and the settings status line into every language Retromod ships, and updates the screen text in nine languages.

• Opens folders and links through Minecraft's own link opener on every supported version, so launchers that sandbox the game can route them. Retromod no longer uses Java's desktop API.

• Repairs Open retromod-input/ on 26.3 and on Fabric and Quilt 1.20 to 1.21.11, and always shows the folder's path, since Minecraft does not report whether a window opened.

• Names a picked or dropped jar Retromod cannot read, such as one a launcher sandbox keeps from the game, and shows retromod-input/ instead of updating anything from that choice.

• Stages translation work in retromod-cache/work/ inside the game folder instead of the system temp folder. Each launch locks its own folder there, and the next start removes the folders no running launch holds.

• Removes the Forge and NeoForge setup window, which could not open on any supported Minecraft version because the game turns off Java's desktop windows before mods load.

• Changes the CLI's default target to 26.3, the newest version this release builds for, and prints it in --help.

• Honors --target-loader forge, fabric, and quilt, which the CLI used to ignore.

• Names the error when the CLI fails on a mod, instead of printing failed: null.

• Applies vanilla class moves to Forge and NeoForge mods in the CLI and aot, read from the game jar given with --mc-jar, and applies the 26.3 moves when no shim chain reaches the target.

• Makes prepare install each translated old mod in mods/ as <name>-retromod.jar and move its original to retromod-input/processed/. A failure on a current mod or on Retromod's own jar no longer stops it.

• Adds the replacement classes a translated jar uses in batch, prepare, and aot on every target, and refuses a jar that still names one Retromod could not add.

• Brings aot output in line with transform. It keeps the mod's manifest attributes, renames META-INF/mods.toml for NeoForge 1.20.2 and newer, relaxes dependencies by the same rules, applies the old enchantment repairs, honors --verify, and no longer writes retromod-backups/ beside each input.

• Marks Forge and NeoForge jars from transform and batch as Retromod output, so in-place loading keeps them instead of translating them again.

• Reads pre-release NeoForge loader bounds such as [21.0.110-beta,) when it works out which Minecraft a mod was built for.

• Reads the target in devhelp <mod.jar> [target], shows each shim's own changes in diff and devhelp, finds the client jar for score in common launcher folders, and makes embed say when nothing was added.

• Writes Retromod's messages to the game's own log, so translation errors and warnings appear in logs/latest.log on Forge and NeoForge. Notes from generated compatibility classes and translated Forge mods go there too, and Fabric pre-launch lines keep their real level.

• Keeps logs/latest.log short. Retromod logs its start line, one line per mod it translates or serves, the end-of-pass summary, and in-place status. Each translation step now goes to logs/debug.log on Forge and NeoForge, and "log_level": "DEBUG" in config/retromod/config.json brings those lines back to latest.log on any loader.

• Logs one warning per mod with unresolved references and names the report in config/retromod/verify-reports/ that lists them.

• Describes what Retromod found instead of saying a mod cannot load or needs another version, because those checks are estimates. A class built on a removed base is reported as a warning that the class may fail when it loads.

• Tries every mod you pick in game or pass to aot, whatever its complexity score. The Try unlikely mods setting is gone, aot --skip-risky brings back the old skip, and --force is still accepted but changes nothing.

• Logs the full stack trace when the Forge or NeoForge bootstrap or the in-place discovery pass fails. The first line of each message is unchanged.

• Reports when a Curios, JEI, capability, Architectury, or Fabric item group compatibility call fails, naming the API, the call, and the mod class. The call still returns its old fallback value.

• Warns once per rarity when a rarity cannot be added on the current loader, and stops claiming that an old GameRegistry.register call was intercepted.

• Bridges old structure types, structure pool elements, chunk generators, and biome sources in CLI and aot output for 26.2 and 26.3, matching an in-game translation.

• Keeps hasPermission(int), withPermission(int), and the int-level CommandSourceStack constructor working for older Fabric mods on Fabric and Quilt 1.21.11, and reads ServerPlayer.server through the player's level there from 1.21.6.

• Bridges old game rule reads for older Fabric mods on Fabric 1.21.11, keeps the meaning of disableRaids and the movement-check rules that 1.21.11 renamed, and answers a client level's getGameRules() with the default rules on every loader.

• Repairs old Fabric mods that build configuration-phase packets on 26.x, such as Forge Config API Port, and reports Fabric API as loaded to mods that check for the fabric mod id.

• Keeps older Fabric and Quilt mods that add keybinds working on 1.21.9 to 1.21.11.

• Runs Forge 1.20.1 tick listeners added with addListener on Forge 26.2, and the single handler of an old @Mod.EventBusSubscriber class. A handler whose event no longer exists is skipped with a warning.

• Warns about the removed Fabric networking v0 and renderer material APIs only when a mod uses them.

• Returns the real mod list from ModList.get(), LoadingModList.get(), and FMLLoader.getLoadingModList() on Forge 26.2 once mods have loaded, so Puzzles Lib and the mods built on it construct again.

• Keeps Forge's own MinecraftForge, ICapabilityProvider, and LazyOptional when translating for Forge, so old mods reach the live event bus and capability system instead of replacements that were never added to the jar. Replacement IForgeRegistry and ICondition classes are no longer embedded where the Forge host still ships them.

• Keeps old @SubscribeEvent priorities on Forge 26.2 and newer by converting the removed EventPriority value to the byte EventBus 7 reads, so those handlers register instead of failing.

• Runs each handler of an old listener object once on Forge 26.2 and newer, at its own priority, including a lone handler or one that is not public. Static handlers on that object no longer run a second time, because Forge 1.20.1 registered only an object's instance handlers.

• Repairs new Material(atlas, texture) in old client mods on 26.1 and newer, for every loader. It now becomes 26.1's SpriteId, which has the same constructor and accessors, instead of an unrelated class with the same name.

• Repairs old Forge entity interaction and sapling growth listeners on Forge 26.2 and 26.3, which replaced or renamed those events without changing what they carry.

• Sends old Forge NetworkHooks menu and spawn calls to what Forge 26.2 and newer keep, so mod menus open with their extra data and modded entities still get a spawn packet.

• Bridges ForgeMod's removed reach, gravity, and step height attributes, the old biome generation builder, the old ForgeEventFactory.getMobGriefingEvent check, ToolActions.SHIELD_BLOCK, ForgeRegistries.Keys.ENCHANTMENTS, and old Forge tag constants on Forge 26.2 and newer.

• Rebuilds Forge's FakePlayer and FakePlayerFactory on Forge 26.2 and newer for old mods that act as a player for machines and automation. A fake player from one mod counts as fake in every other mod's instanceof FakePlayer check.

• Keeps the 1.20.1 game packet listener constructor that mods' own fake player connections call, on Forge, NeoForge, Fabric, and Quilt from 26.2.

• Rebuilds Forge's removed PathPackResources on Forge 26.2 and 26.3 on top of the vanilla folder pack, so old mods that build it, extend it, or test a pack with instanceof link again, and disables ModernFix's and Fusion's mixins on that removed class.

• Keeps old Forge mods that add enchantments from code loading on Forge 26.2 and newer, and lets them read ForgeRegistries.ENCHANTMENTS from the enchantments the loaded world takes from data packs.

• Gives old mods that read BuiltInRegistries.ENCHANTMENT, removed in 1.21, the enchantment registry of the loaded world on NeoForge, Forge, Fabric, and Quilt from 1.21.

• Keeps those reads, and ForgeRegistries.ENCHANTMENTS on Forge and NeoForge, working while a data pack loads, so trade and loot data that names enchantments loads with the world.

• Repairs old calls to ItemStack.enchant(Enchantment, int), which now takes the enchantment's holder.

• Redirects Forge's old enchantment, painting variant, and biome registries the same way offline as in the game when translating for NeoForge.

• Repairs old mods that read and write text as JSON on NeoForge and Forge from 1.20.5, and on Fabric and Quilt from 26.1, including mods that register or extend the old text and style Gson adapters.

• Reads text written before 1.21.5, with its click and hover events, through the game's own text upgrade, and passes the loaded world's registries so an item or entity shown on hover resolves.

• Repairs old mods whose biome, structure, and loot modifier serializers, chunk generators, biome sources, density functions, and surface rules stopped loading from 1.20.5, on NeoForge and Forge. Each converted serializer reads its data the way Forge 1.20.1 did and still works as the codec the mod registered.

• Updates biomes written before 1.21.2, whose carvers were split by step, to the single carver list, so a placeholder biome such as TerraBlender's no longer stops a world from loading.

• Repairs Forge 1.20.1 arm poses on Forge 26.2 and 26.3. Old mods add them through Forge's current create, and their pose code receives the entity holding the item, as Farmer's Delight's skillet expects.

• Keeps an old arm pose from stopping client setup on NeoForge. Items using it hold the plain item pose.

• Repairs Minecraft.getFrameTime(), which 1.21 removed, in the game on Forge and NeoForge from 1.21 and on Fabric from 1.21.

• Repairs Forge's spawn placement type create on Forge and NeoForge.

• Repairs old Fabric and Quilt mods that read and write text as JSON on 1.20.3 to 1.21.11, including mods that register or extend the old text and style Gson adapters. A number reads as its text and plain text is written as {"text": ...}, as on Forge and NeoForge.

• Reads style flags written as strings, such as "bold":"true", in old text on every loader from 1.20.3 to 1.21.4, as 1.20.1 did.

• Runs Forge 1.20.1 AttachCapabilitiesEvent<T> listeners on Forge 26.2 and 26.3, each for the holder kind it asked for, whether added with @SubscribeEvent or addGenericListener, and posts the old RegisterCapabilitiesEvent to each mod in mod order after every mod has constructed and before any registry event.

• Saves and loads capability data from Forge 1.20.1 mods on Forge 26.2 and 26.3, so saving an entity, block entity, chunk, or level with an old capability provider no longer crashes, and gives old item handler, energy storage, entity, and capability save calls the registries of the save in progress.

• Runs an old item's capability setup when Forge 26.2 and 26.3 ask the item for its capabilities, so backpacks, pouches, and buckets keep their inventories, and answers CapabilityManager.INSTANCE and ItemStack.areCapsCompatible, which Forge 26.2 removed.

• Restores the previous registries when an old block entity or saved data load throws on NeoForge 1.20.5 to 1.21.5.

• Restores Forge's static brewing registry on Forge 26.2. Old mods add brewing recipes during setup as before, and getOutput, hasOutput, getRecipes, isValidInput, and isValidIngredient read the running game's brewing.

• Brings back Forge's brewing recipe interface, its plain BrewingRecipe class, and addRecipe on Forge 26.3, where old recipes are written as brewing recipe files as on NeoForge 26.3, and rebuilds the plain BrewingRecipe class on NeoForge 26.3 too.

• Names each mod's brewing recipe pack on Forge and NeoForge 26.3 after the mod that added the recipes, including recipes added with an ingredient and an output stack, which used to land under minecraft or be dropped.

• Restores villager and wandering trader trades that Forge 1.20.1 and 1.21.1 mods add through the old trade events on Forge 26.2 and 26.3. Retromod writes them as a data pack when the server starts, and a subscriber class that handles the removed trade events keeps loading, so its other listeners still run.

• Writes the trades of a mod that handles only one of the two trade events, on Forge and NeoForge, which used to write no trades at all.

• Prevents a startup crash on 26.1 and newer when an older mod's Mixin builds an item stack in a static field, as Carry On does. Retromod now builds that stack the first time the Mixin uses it, for every loader.

• Repairs the NBT reads 1.21.5 changed: the byte, short, array, and UUID getters, hasUUID, getTagType, putUUID, Tag.getAsString, and the number tag getters. A missing key still returns 0, an empty array, or an empty string, and UUIDs keep their four-int format.

• Restores ItemStack.parseOptional, saveOptional, parse, both save forms, and the ContainerHelper forms that took a CompoundTag, which 1.21.5 and 1.21.6 removed, for every loader, including Fabric and Quilt 1.21.5 to 1.21.11 under intermediary names.

• Keeps old block entity, entity, and player food save code working on 1.21.6 and newer. Overrides written for the old CompoundTag save and load methods are called again, with their data passed through a CompoundTag, and old calls to the save and load helpers are repaired.

• Repairs mods that subclass Level with the 1.21.1 constructor on 1.21.2 and newer, where the profiler argument was removed.

• Repairs old chunk position code on 26.1 and newer: new ChunkPos(pos) and reads of its x and z fields work again.

• Restores I18n.exists on 26.2 and newer, getServer() on entities and players from 1.21.9, ServerPlayer.displayClientMessage and ChatComponent.addMessage on 26.1 and newer, and new BlockPos(Vec3i) on 26.3.

• Bridges InteractionResultHolder and the InteractionResult factories that took an item, which 1.21.2 replaced, along with RegistryAccess.registry(key) and the two-argument BlockState.isSolidRender.

• Translates Style.withFont and getFont to the 1.21.9 font description, keeps EditBox.setFilter working on 26.1 and newer, keeps old Screen.resize overrides working on 1.21.11 and newer, and renames Registries.CONFIGURED_FEATURE on 26.3 on every transform path.

• Gives blocks and items their registry id on Forge 1.21.11, Forge 26.1 to 26.1.2, and NeoForge 1.21.11, so content mods no longer stop at Block id not set there.

• Keeps old GameRegistry calls on Retromod's stand-in when the CLI translates a 1.12.2 Forge mod for NeoForge, and stops warning about redirects to classes that were never written.

• Logs a plain notice instead of asking for a bug report when in-place loading is not available on NeoForge 1.20.2 to 1.20.6 builds with older FML.

• Repairs old tree growers, MobType checks, spawn placement types, entity data definitions, and attribute operation names for NeoForge 1.20.2 to 1.20.4 mods on NeoForge 1.20.3 to 1.20.6.

• Logs a warning when Retromod cannot remap a mod's Mixin refmap.

• Lists the loaded polyfills once per batch or aot run, logs version alias lookups at debug level, and translates Forge mods that declare Minecraft 1.12 or 1.12.1 through the 1.12.2 shim chain.

• Lists Minecraft gaps first in transform verification output, labels a class missing from another mod as such, reports a missing client class on a dedicated server as not checked, and checks 26.3 com.mojang.renderpearl classes against --mc-jar.

• Corrects the In-Game UI, troubleshooting, installation, and SRG pages of the docs.

• Makes the compatibility classes Retromod copies into translated mods, and those the legacy command adds, use the game's own Gson and SLF4J instead of Retromod's private copies.

• Repairs older mods that read the default, evergreen, birch, or mangrove foliage color on Minecraft 1.21.4 and newer, which turned those getters into constants. Leaf and vine color handlers get the same colors on Fabric, Quilt, Forge, and NeoForge instead of failing while rendering.

• Repairs worldgen mods built for 1.20.4 and older that call KeyDispatchDataCodec.codec(), of(Codec), or its constructor on 1.20.5 and newer. A codec handed straight to a registration gets the map codec the registry holds, which ends a crash in Bootstrap on Forge 26.2 with TerraBlender.

• Rebuilds KeyDispatchDataCodec on 26.3, which removed it, so mods that name it keep loading.

• Leaves a repaired 1.20.1 registry mixin unapplied when its code, or a mod class that code loads during startup, names a member or class the host no longer has, so TerraBlender no longer stops the game in Bootstrap on 26.2 or 26.3.

• Reads 1.20.1 worldgen data built with a unit codec, such as Lithostitched's markers in Tectonic's data, without the "value" key newer DataFixerUpper versions expect.

• Hands registrations made from a codec() method reference, such as Citadel's surface rule, the map codec the registry holds.

• Answers Minecraft's codec() call on old surface rule sources and conditions on 26.2, and on material rules, conditions, and density functions on 26.3, instead of failing with AbstractMethodError.

• Keeps a rule source that extends another mod's rule source working on 26.2 and 26.3, where both jars carry their own copy of the codec() bridge.

• Keeps a codec() method reference handed to a Minecraft or loader utility, such as Forge's Lazy.of, returning the old Codec, and gives the map codec only to registrations.

• Keeps Farmer's Delight and other Forge 1.20.1 mods that extend or call CompoundIngredient, DifferenceIngredient, IntersectionIngredient, StrictNBTIngredient, or PartialNBTIngredient working on Forge 26.2 and newer. A mod's own compound ingredient gets a rebuilt base, and the factories reach Forge's current ingredient types.

• Renames old FriendlyByteBuf.writeResourceLocation and readResourceLocation calls and method references to the Identifier names that 1.21.11 and 26.x use, on every loader, so Balm-based mods such as Waystones construct again.

• Bridges Forge 1.20.1 event network channels (NetworkRegistry.newEventChannel) onto Forge 26.x's own event channels, so JEI and mods built the same way construct, and each listener gets only the payload direction it asks for.

• Restores ChatFormatting.getByName, getById, and getId, which 26.2 removed.

• Fixes JEI and Architectury API redirects that named Minecraft types the target methods never declared.

• Sends the old compound, intersection, and difference ingredient factories to NeoForge's own when a Forge 1.20.1 mod runs on NeoForge.

• Keeps TerraBlender and the biome mods built on it generating worlds on 26.1 and newer, where chunk keys and weighted region picks changed, and on 26.2, where biome surface rules changed.

• Rebuilds the old weighted entry classes inside each mod that uses them, on 1.21.5 and newer for every loader.

• Builds old biome surface rules on 26.2 without a running server, so a mod can build them while its blocks register. They keep matching in cave carvers and after a world reloads.

• Keeps loot chests from Lootr and similar mods working with 1.20.5's loot table keys, including a mod's own overrides of the old loot table methods.

• Restores the compound tag entity data serializer that 1.21.9 removed, registered once in the loader's own registry while mods load, so Carry On's carried blocks sync again on Forge 26.2 and newer and on NeoForge.

• Repairs Patchouli's crash report line on 26.2, so a crash with a book open shows its real error.

• Bridges smaller old calls on newer hosts: VillagerData.getProfession() on every loader from 1.21.5, ItemStack.isEdible(), Forge's stack crafting remainder, ChunkAccess.getStatus(), and game event constants that became holders.

• Rebuilds the old surface rule API on 26.3's material rules for every loader, so TerraBlender, Biomes O' Plenty, and other mods that build surface rules hand their rules to 26.3's world generator.

• Builds old biome surface conditions on 26.3 without a running server, so a mod can build them while its blocks register.

• Points TerraBlender's surface rule hook at 26.3's rule holder, so the rules it collects from its addon mods join each world's own.

• Lets TerraBlender 1.20.1's rule registration apply on 26.3 once everything it loads is there.

• Reads the world seed the old way on 26.1 and newer, so TerraBlender sets up its regions when a server starts.

• Rebuilds the density function API that 26.3 replaced with compiled samplers. Old functions keep compute, mapAll, and their bounds, and 26.3 samples them through those methods.

• Samples the 26.3 functions inside an old one over the whole chunk at once, so world generation keeps its speed and its exact values.

• Keeps TerraBlender's End biomes working on 26.3, which reads erosion from the climate sampler.

• Lets Lithostitched swap its placeholder functions through mapAll in trees of 26.3 functions, and maps the old interpolated and cache factories onto 26.3's.

• Moves surface rule accessors such as Regions Unexplored's and Lithostitched's onto 26.3's rule holder, together with the code that calls them.

• Lets Citadel group another mod's old biome rules for TerraBlender on 26.3.

• Reads a 1.20.1 flower's stew effect through Minecraft's public registry interface, so block registration no longer stops on it on Forge 26.2 and 26.3.

• Calls host and mod methods through their public class or interface in Retromod's reflective helpers, so an object whose own class is not public no longer fails with IllegalAccessException.

• Reads Minecraft.screen as null while mods construct on 26.2 and newer, as the old field did, and ignores a write made then, so Patchouli's crash report line no longer crashes the game.

• Prevents a crash when an old mod asks for Minecraft's entity models while its items register, which 26.x hosts do before they have models. The mod gets a model set that bakes from the game's current models once they exist, on Fabric, Forge, and NeoForge.

• Keeps entity models that an old mod saved during startup working after the game reloads its resources.

• Prevents a startup hang on Forge 26.2 and 26.3 when an old mod's extra model listener waits for that mod's own common setup, as Patchouli's does. Old mods are now asked for extra models while the game loads its item models, after common setup, as on Forge 1.20.1, so Patchouli's book models load with the first resource load.

• Rebuilds TextureAtlasHolder on 1.21.11 and newer, so a mod's own sprite atlas, such as JEI's GUI sprites, registers as a reload listener and stitches from its atlas info file again.

• Adapts a mod's own KeyMapping subclass whose constructor passes a String category, so its keys build with a registered category on 26.2 and newer.

• Keeps LocalPlayer.getServerBrand() working for Forge 1.20.1 mods on Forge and NeoForge 1.21 and newer, and ClientPacketListener.getId() on 26.x, where it was removed.

• Lets a class that listens for the old ModelEvent.RegisterAdditional load on NeoForge 1.21.11 and 26.x instead of losing every listener it has.

• Reads brewing recipes on Forge 26.3 through the recipe manager's public view.

• Repairs calls that older Forge mods make on Forge types that Forge 26.2 turned into interfaces, such as a config listener reading ModConfigEvent.getConfig(), which stopped loading with IncompatibleClassChangeError.

• Keeps Registry.getTagNames() and asLookup() working for mods built before 1.21.2. Tag names read before a world loads its tags come back empty instead of stopping the game.

• Lets Sophisticated Core's stack keys work on Forge 26.2, where ItemStack no longer has the capability tag field it looked up.

• Bridges ModList.get() and LoadingModList.get() for Forge mods built for 1.21.1 as well as older ones.

• Removes an unused join message that never reached servers, so Retromod sends nothing when you join a world.

• Keeps an add-on working when it passes a rebuilt interface, such as an old tool tier, to two library mods that each carry their own copy, including overrides the libraries call. Neither library is translated again.

• Gives a library's items and blocks the id of the mod that registers them from its own deferred register, so Forge and NeoForge add-ons such as Sophisticated Backpacks no longer stop with "Item id not set" when they register items from their library mod.

• Gives an item or block that a RegisterEvent consumer builds and registers under an id it already knows that id while it is built, on Forge and NeoForge 26.x. This covers registrars that call each entry's supplier inside the consumer, such as Architectury's and Bookshelf's, and mods that build an item into a local before registering it by a literal id.

• Builds an entity type that a RegisterEvent helper registers under the helper's id.

• Saves and loads block entities from mods built for 1.20.4 or older on 1.21.6 and newer, on Forge and NeoForge. Their data was dropped at every reload before.

• Keeps the persistent data Forge 1.20.1 mods store on block entities on Forge 26.2 and newer, saved under ForgeData as before.

• Loads chests and other block entities that Forge 1.20.1 mods saved, including their loot tables, items, and custom names, on Forge 26.2 and 26.3.

• Upgrades item stacks a mod saved before 1.20.5 with Minecraft's own data fixer, starting from the newest Minecraft version the mod's jar shows it was built for, and saves stacks larger than 99 in mod containers without failing the save.

• Reads a custom name saved as JSON before 1.21.5 as the name it was, and keeps names typed on newer versions exactly as typed.

• Repairs the old calls those block entities make while saving, loading, and opening: container items, UUIDs, block positions, loot tables and loot data, update tags, ItemStack.serializeNBT, Item.getShareTag, JSON text components, and the piglin anger and loot advancement calls.

• Prevents an endless save or load loop when an add-on's block entity extends one from a library mod, and bridges such add-ons the same way whether the library is linked, in the mods folder, or on the class path.

• Finds the entity a render event was drawn for, so old Forge and NeoForge mods that call RenderLivingEvent.getEntity() keep working on hosts from 1.21.9 on.

• Keeps getModifiers() on typed characters, getScrollDelta() on screen and in-game scroll events, and getScanCode() on screen and in-game key events working for old Forge mods on Forge 26.2 and 26.3. It also keeps a typed character's modifiers working on NeoForge 26.2 and newer.

• Gives an old advancement event handler the advancement it expects, and answers Advancement.getId() for it.

• Streams the (tag key, set) pairs an old mod expects from Registry.getTags() on Minecraft 1.21.2 and newer, on every loader. Mods built for 1.21.2 or later keep the new form.

• Lets a mod's own event extend Forge 1.20.1's EntityEvent, LivingEvent, PlayerEvent, LevelEvent, or BlockEvent on Forge 26.2 and 26.3, where Forge made those interfaces.

• Judges whether a mod was built before a change by the newest version its jar shows, not only its declared minimum.

• Leaves a newer mod's method references as written when Retromod redirects that member only for older mods.

• Applies NeoForge's later member renames to Forge mods translated with the CLI or AOT for NeoForge, as the game already did.

• Rebuilds ItemParser.parseForItem and its result, removed in 1.20.5, so old item strings such as minecraft:diamond{Damage:3} give the item and its NBT again.

• Keeps the animal food fields that became item tags in 1.20.5 readable as those tags, and writes the items a mod adds to them as a data pack in config/retromod/legacy-item-tags/, which applies when a world loads.

• Keeps Villager.WANTED_ITEMS working for mods built for 1.20.5 to 1.21.1 on hosts from 1.21.2, where it became the villager_picks_up tag.

• Turns a mod's change to Villager.FOOD_POINTS into the villager food component on 26.3.

• Applies access transformer entries for classes Minecraft moved under the class's current name.

• Keeps advancement triggers that implement the trigger interface themselves loading, reading their JSON and awarding their criteria, including on 26.2 and newer, where the trigger listener was removed.

• Releases a departed player's advancement listeners when the player leaves or the server stops.

• Restores ChestBlock's shape constants for chest subclasses.

• Repairs old constructors and constructor references of removed classes whose argument types were renamed, such as new ModelResourceLocation(ResourceLocation, String).

• Reads a tag ingredient's items as empty before a world binds tags, as 1.20.1 did.

• Lets older mods build item stacks before a world loads on 26.1 and newer, as static fields, config handlers, and setup code do. Each stack picks up the item's default data when a world loads, then stacks, compares, and saves like any other.

• Makes Item.getDefaultInstance() called before a world loads return a stack of the item instead of an empty stack.

• Rebuilds EntityRenderDispatcher.getSkinMap() and the renderers map on Minecraft 26.1 and newer as views of the game's renderers, so mods that add player layers in a reload listener load again.

• Lets old render layers written for Minecraft 1.21.1 and earlier draw on 26.x on Forge, NeoForge, and Fabric. A layer draws nothing for an entity it cannot match.

• Restores the Forge AddLayers lookups getSkin, getSkins and getRenderer on Forge 26.2 and newer and on NeoForge 26.x. getSkins is bridged only for mods built before 1.20.2.

• Keeps Minecraft.getItemRenderer() and the renderer contexts' getItemRenderer() working at any time, so a mod that keeps the item renderer from a constructor or reload listener loads again.

• Draws items that old renderers draw with ItemRenderer.renderStatic on Minecraft 26.1 to 26.3, when an old render layer, item renderer, block entity renderer, or entity renderer makes the call.

• Draws block entity renderers written for Minecraft 1.21.4 and earlier, such as Farmer's Delight's stove and skillet and Waystones' stones. A renderer built on a vanilla renderer, such as a sign renderer, still draws only what the vanilla renderer draws.

• Draws a mod's own entity renderers written for 1.21.1 and earlier when they extend EntityRenderer directly, with the name tag they asked for. Renderers built on vanilla mob or living renderers are not covered.

• Draws entities that old block entity and entity renderers draw through EntityRenderDispatcher.render, and honors setRenderShadow.

• Stops an old renderer that throws after one warning, without leaving half of its drawing in the frame.

• Skips Fabric mixins into the removed ItemRenderer instead of applying them to Retromod's own copy.

• Fixes old Fabric layers that call their base layer's render, and layers under a base with a helper shaped like the old render.

• Rebuilds the rest of the old ItemRenderer on 26.1 to 26.3 for every loader: getModel, render with a model, renderModelLists, renderQuadList, the glint buffers and getItemModelShaper. The model resolves the stack through Minecraft's own item models when it is drawn.

• Answers old BakedModel calls on that model and on Minecraft's block models, from quads and the 3D flag to display transforms and render types. On Forge 26.2 and 26.3, getModel returns an old mod's own model when it replaced the item's, so Sophisticated Backpacks finds its backpack model.

• Rebuilds BlockRenderDispatcher, the renderer contexts' getBlockRenderDispatcher() and BlockModelShaper on 26.1 to 26.3, available at any time. renderSingleBlock and ModelBlockRenderer.renderModel draw inside the renderers Retromod runs. On Forge 26.2 and 26.3, Sophisticated Backpacks builds its backpack shapes again.

• Rebuilds NeoForge 1.21.1's IDynamicBakedModel, BakedModelWrapper and ChunkRenderTypeSet inside each old mod on NeoForge 26.1 to 26.3, for NeoForge 1.21.1 mods and Forge 1.20.1 mods running there, so model classes built on them load again.

• Answers NeoForge's model data members of an old BakedModel (getQuads with model data, getRenderTypes, getParticleIcon(ModelData), getModelData and the occlusion questions) on old models, and on Minecraft's block models from their quads, and maps Forge 1.20.1's model data classes to NeoForge's.

• Makes an old dynamic model or wrapper a complete Minecraft block model on NeoForge 26.x, drawn one part per layer it names, so code that hands one to Minecraft no longer fails on a missing member.

• Lets old RegisterGeometryLoaders listeners register on NeoForge 26.x. NeoForge never posts the event, so old geometry loaders bake nothing.

• Keeps old ItemOverrides subclasses that call the list constructor, such as Patchouli's book model, on every loader from 26.1.

• Draws enchantment glint for old item draws on 26.3 through the glint variant of each item sheet.

• Prevents an endless loop when an old model's own method calls the old default through super, as CreativeCore's does.

• Rebuilds ItemProperties, which Minecraft 1.21.4 removed, inside mods built before 1.21.4 on every 26.x loader and on NeoForge 1.21.11, so a mod that registers item properties in client setup keeps loading.

• Translates model overrides on a mod's own item property into item definitions that read the mod's registered function, so those items switch models again.

• Relinks Fabric API's removed FabricModelPredicateProviderRegistry to the rebuilt registry on Fabric 26.x.

• Keeps old NeoForge block and item color handlers working on NeoForge 26.1 to 26.3, so tinted leaves, grass, and mod items keep their colors. Mods that listen for the old color events construct again instead of stopping on a missing class.

• Applies the same color repair to Forge 1.20.1 mods running on NeoForge 26.x.

• Draws item tints opaque for mods built before 1.21 and keeps the alpha a 1.21 or newer mod gives them, on Forge and NeoForge alike.

• Skips old mixins into the removed item color table on Forge and NeoForge, since they cannot apply to Retromod's rebuilt copy.

• Repairs old mods' loot function, condition, entry, number, NBT, and score provider types on 26.1 and newer, on every loader and registration path, so a world that uses their loot tables opens.

• Converts old structure processor types to the codecs 26.2 registers, including those registered by mods built for 1.21.

• Repairs loot functions built for 1.20.5 to 26.2 on 26.3, which gives a loot function one condition instead of a list, so loot tables that use them load again.

• Reads the one condition 26.3 loot data holds for loot functions built with 1.20.1 serializers, so their conditions still apply.

• Rebuilds the single loot entry base that Minecraft 26.3 removed, so custom loot entries from mods built for 1.20.5 to 26.2 load on every loader and roll with their weight, quality, conditions, and functions.

• Keeps a loot predicate or item modifier named by id when an old loot function or entry is written back, and lets old 1.20.1 loot functions read a condition named by id.

• Keeps old loot code working on newer hosts. Removed loot entry type constants and getType() return the registered types, and loot context parameter calls such as getParam reach their renamed forms and still throw for a missing parameter.

• Reads an entry's condition and function lists from the holders 26.3 keeps when old code reaches into them from outside the entry.

• Rolls a loot table that old code names by key when no registries are in reach, by looking it up in the loot context when the entry rolls.

• Gives old code empty stand-ins for built-in registries the host removed, such as schedules and loot number providers, so startup code that lists them no longer crashes.

• Points old reads of the built-in feature registry at the feature type registry 26.3 renamed it to, and repairs old calls to the registry codec factories that 26.3 moved or retyped.

• Gives mods built before 1.20.5 their loot table ids back from BuiltInLootTables, all(), Block.getLootTable(), and EntityType.getDefaultLootTable() on NeoForge from 1.20.5, Forge from 1.21, and Fabric and Quilt in a running game from 1.20.5. An id read twice is the same object, so maps keyed by it keep working, and it equals the id a loot table event reports.

• Bridges old loot table setters on suspicious sand and gravel, chest minecarts, and container vehicles, and loot table lookups through a loot context's resolver, which loot modifiers use to add a table's drops.

• Restores the death loot table an old mob names in its own getDefaultLootTable() on Forge, NeoForge, and Fabric from 1.20.5 through 26.3, except Fabric 1.21.2 to 1.21.8 and Forge 1.20.6.

• Keeps an old mob's call to super.getDefaultLootTable() returning its entity type's table, and restores the loot table a non-mob entity names in its own getLootTable().

• Keeps command contexts that old mods build themselves working on newer hosts, so a mod that wraps one for an item argument no longer stops a world from loading. Such a context answers an empty lookup when Minecraft asks it for a registry it does not have.

• Gives registry providers and registry access built for 1.21.1 or older the members newer hosts call, and keeps their listRegistries, filterElements, and asGetterLookup calls working.

• Runs reload listeners written for 1.21.1 and older, and for 1.21.2 to 1.21.8, on newer hosts on every loader. That covers listener classes, lambdas, and method references such as GeckoLib 4's model and animation loading, so their resources load.

• Keeps listeners that wrap other listeners working. The wrapped listener runs in the host reload's own state, so it can read what other listeners prepared.

• Answers Forge's FMLEnvironment.production, dist, and naming, and ModLoader.isDataGenRunning and isLoadingStateValid, for Forge mods on NeoForge. The CLI and the running game now translate these the same way.

• Keeps a library's own classes under their own names when Retromod moves those names for the mods that use it. GeckoLib 4 translated for 26.1 to 26.3 keeps its own classes on every loader, and mods translated together with it keep its software.bernie.geckolib names.

• Rebuilds what GeckoLib 4 needs on Forge and NeoForge 1.21.11 and on 26.x: animated entity textures change frames, glow masks light up at full brightness, and entity rendering no longer stops on the buffer classes 26.2 removed.

• Answers GeckoLib 4's Molang saddle, charge, armor slot, and owner queries from the mobs and equipment that replaced the removed interfaces.

• Rebuilds render calls, ABGR colors, humanoid part visibility and pose copies, armor slot lists, owner ids, component patch lookups, and the name tag check for mods built before they were removed, and drops the static GUI lighting setups 1.21.11 replaced.

• Keeps an addon's own copy of a generated item base when its library's copy lacks the addon's constructors, so GeckoLib armor mods register their items.

• Repairs player cape, body, and elytra texture lookups in Fabric mods on 26.x.

• Keeps configs of NeoForge mods built before 26.3 working: their common and server configs load as local and synced configs under the same file names as before, and config libraries that build names from the old types still get them.

• Reads the libraries a mod bundles when it rebuilds stack frames, so a mod that mixes two of its library's types no longer fails verification.

• Removes client-only methods and fields from Forge mods, and from NeoForge mods built for 1.21.1 or older, on a NeoForge dedicated server, as the older loaders did, so a client listener in a shared class no longer stops the server.

• Marks a mod translated on a NeoForge dedicated server as made for servers, so a client and export leave it out.

• Keeps mods that name NeoForge's removed model generators or vanilla's removed tag providers loading, since those classes only matter when a mod's data is generated.

• Drops a NeoForge event listener added for an event class the running version removed, instead of failing the mod's construction.

• Restores findResource and the jar root and location lookups that NeoForge 1.21.9 removed from mod files, which libraries use to read their own files.

• Carries the FMLLoader and FMLEnvironment side and production checks to Forge mods running on NeoForge 1.21.9 and newer.

• Translates Forge mods for a NeoForge target offline with the same shims the game registers, so transform, batch, and aot move Forge 1.21 mods onto NeoForge and their items, blocks, and worldgen types register as they do in the game.

• Adds --host-jar to transform, aot, and batch, which reads a loader jar such as NeoForge's universal jar as the target's own classes, so offline checks answer as the running game does.

• Moves Forge's annotation scan data to NeoForge's, so libraries that find fields through annotation scans register them on NeoForge.

• Removes Mixin's placeholder package from mods translated for NeoForge on every path, so NeoForge 26.3 no longer refuses to start.

• Reads NeoForge's own jars next to a patched game jar during offline translation when --host-jar is not given, and prints which jars it chose, so bridges that check the loader apply as they would in game.

• Restores DirectionalPayloadHandler, so mods that register two-way packets with it load on NeoForge 1.21.7 and newer.

• Keeps chorus fruit teleport listeners and entity interaction listeners working on newer NeoForge events.

• Keeps command color arguments, container slot codecs, recipe serializer constants, saved data factories, and biome spawn probability calls from 1.21 mods working on 26.x.

• Gives items built in a registration listener their id when the mod names the registry through BuiltInRegistries.

• Never guesses a renamed field or method that the calling class cannot access, such as the private PackMetadataSection.FALLBACK_CODEC for a mod's read of the removed PackMetadataSection.CODEC, which failed with IllegalAccessError.

• Answers the old public pack metadata codec on Minecraft 1.21.11 and newer, which replaced it with a private codec and one codec per pack type. An old mod that reads or writes its own pack.mcmeta works again, and Retromod writes the format fields the host requires for that pack's range.

• Keeps moving NeoForge classes that became Minecraft classes, such as TriState, when the CLI translates with a NeoForge --mc-jar.

• Keeps a mod's own pack class a full resource pack on Minecraft 26.3, which deleted the base class those packs extended. The pack moves onto 26.3's metadata base as before and now also answers the host as a resource pack, through the resource methods it already had.

• Leaves worldgen feature and carver references alone when it renames old block and item ids in mod data, so a rebuilt grass patch no longer stops a 26.3 world from loading.

• Stops guessing a renamed Minecraft tag key from a similar name, so a removed tag such as ItemTags.TOOLS is no longer read as ItemTags.WOOL.

• Reads the tag keys 26.1, 26.2 and 26.3 renamed under their new names, such as BlockTags.SNOW_LAYER_CAN_SURVIVE_ON as SUPPORT_OVERRIDE_SNOW_LAYER, BlockTags.BAMBOO_PLANTABLE_ON as SUPPORTS_BAMBOO, ItemTags.DYEABLE as CAULDRON_CAN_REMOVE_DYE and BlockTags.CONCRETE_POWDER as CONCRETE_POWDERS.

• Gives pack suppliers written for Minecraft 1.20.5 to 26.2 the two methods Minecraft 26.3 opens packs with, so a mod that adds its own data or resource pack gets past pack discovery. The host reads the pack's metadata from the mod's primary pack and its files from the mod's full pack.

• Answers the old WorldVersion.getPackVersion on Minecraft 1.21.11 and newer, which replaced it with a pack format that has a major and a minor number. An old mod gets the major number, as it got the single number before.

• Builds the old pack metadata from a format number, or a format and a supported range, on the same versions, so a mod that adds its own data pack keeps loading.

• Rebuilds the composter's chance table on Minecraft 26.3, which made compostability an item component, for mods built before that release. A mod that adds a compostable item gives it the component at vanilla's nearest chance, and a mod that reads the table gets each item's chance from its component.

• Rebuilds NeoForge's brewing registration event on NeoForge 26.3, which replaced it with brewing recipe files, for mods built before that release. Retromod posts the old event once the server has started and saves what it collects as brewing recipes.

• Bridges the chunk's moved-by-piston flag, the spawn entry codec and the villager type constants on Forge and NeoForge 1.21.11 and on every loader from 26.1, where those members already have their new shapes.

• Keeps a mod's own biome source working on 26.3: its old biome lookup now answers the resolver 26.3 asks each source for, so custom dimensions no longer stop with AbstractMethodError.

• Keeps one climate sampler per world for old code that asks a random state for its sampler, instead of building a new one on every call.

• Swaps a biome's sugar cane patch and the pumpkin patch right after it, as vanilla's own biomes did by 1.21.11, so worlds with old biome mods no longer stop with a feature order cycle.

• Rewrites loot number providers that 26.3 split into whole-number and fraction kinds. A score or binomial in a fraction field is read through from_int, a score's scale becomes a multiplication, and a binomial's fractional trials round as they did before.

• Gives a bare {min, max} range inside another range its uniform type, as 26.3 requires of every number provider.

• Renames old vanilla ids written without their minecraft: namespace, such as chain, in loot entries, item and block fields, and tags.

• Leaves out an empty smithing transform template or addition list, which 1.21.2 and newer no longer parse.

• Loads an advancement whose icon names another mod's item only when that item exists, on NeoForge, instead of stopping the world when the mod is missing.

• Puts the predicate a Forge loot modifier's condition list names through reference in place of the reference, when the jar ships that predicate.

• Drops an item's entity data when it holds nothing but an id the old game could not read, so a spawn egg keeps its own entity as before instead of stopping the world.

• Repairs @Inject handlers at every injection point, not only HEAD, TAIL, and RETURN, when the target method changed a parameter the handler never reads. MixinExtras @Local captures after the callback keep their place.

• Removes an @Inject handler with MixinExtras captures when its target method still refuses it, so the game no longer stops while loading that Minecraft class. The rest of the mixin still applies.

• Rebuilds TicketType.create on 1.21.5 and newer, so a mod that makes its own chunk ticket types no longer stops the server at startup. Each old type becomes a new unregistered ticket type that loads and ticks its chunks, and a timed type still lapses after its lifespan.

• Keeps the Graphics API on OpenGL from the first start when Retromod creates options.txt, so the game's own options upgrade does not reset it.

• Stops guessing a renamed field whose generic type arguments may differ, such as the removed DataComponents.HIDE_ADDITIONAL_TOOLTIP, which was read as DataComponents.TOOL.

• Reads CustomData.CODEC_WITH_ID, Ingredient.CODEC_NONEMPTY, ItemEnchantments.FULL_CODEC and ExtraCodecs.GAME_PROFILE as the same-typed codec on hosts that renamed or merged them.

• Keeps a static field read on static fields, and an instance read on instance fields, when it guesses a renamed field.

• Points a Forge 1.20.1 mod's item, fluid, and energy handler classes at NeoForge's on NeoForge 1.21.1 through 26.2, and at Retromod's rebuilt ones on 26.3, where NeoForge removed them.

• Rebuilds Forge's RecipeWrapper as a container on NeoForge, so recipes that read a block's item handler, such as a cooking pot's, can match their inputs.

• Keeps the stack counts and item data that a 1.20.1 world saved in a Forge mod's item handler when the world first loads on NeoForge.

• Maps Forge's FluidStack and FluidType to NeoForge's, and keeps Forge's fluid comparisons, display name, and fluid saves and loads working, including tanks a 1.20.1 world saved.

• Keeps Forge's ItemHandlerHelper stack checks and copies, Forge's RecipeMatcher, and the item handler saves that took no registries working on NeoForge.

• Renames Minecraft classes, methods, and fields that Mojang renamed after 1.21, so NeoForge and Forge mods built for an older 1.21 release reach the new names.

• Keeps the old meaning of getMaxBuildHeight and getMaxSection for mods built before 1.21.2 on every loader. 1.21.2 replaced them with getters that return the top block and section themselves.

• Keeps map colors from Fabric mods built before 1.21.2 in the byte order those mods expect, so red and blue no longer swap.

• Lists the Mixin configs a mod names in its manifest MixinConfigs in neoforge.mods.toml on NeoForge 1.21.9 and newer, which read Mixin configs only from the toml, so the mixins of Forge mods and older NeoForge mods apply again.

• Rebuilds SignItem and BedItem on 26.3, so signs and beds from older mods place again.

• Bridges the inventory's armor and offhand lists, getArmor, and new Inventory(player) onto the inventory's equipment slots, feet first as before.

• Bridges entity calls that 1.21.2 to 26.1 changed: hasPermissions(int), getSlotForHand, getCommandSenderWorld, getTags, the two-argument startRiding, and getOwnerUUID on tamed animals and horses.

• Keeps old fall damage overrides running now that the fall distance is a double.

• Lets entities built directly on Entity take damage again, running their old hurt override.

• Bridges item and block calls: cooldowns by item, DyeItem.getDyeColor, item and block state tags, the spawn egg type, and blocksMotion on 26.3.

• Keeps fake players built with the old Player constructor, and isSingleplayerOwner with a game profile, working.

• Draws old 1.21.x GUI code on 26.x on Forge, NeoForge and Fabric: pose stack moves, fills, gradients and lines with a render type or depth, fractional text, word wrap, item and sprite blits, and the old tooltip calls.

• Keeps old list rows, custom drawables and buttons working, since their old render and press methods now run from the methods 26.x calls.

• Bridges old key checks: matching a key or mouse button by its code, and reading a key mapping's category as a string.

• Leaves a call alone when the host still has that exact method, so Forge's own tooltip methods keep working on Forge 26.x.

• Keeps older structure processors working on Minecraft 26.2 and newer, where the processor became an interface with a new processBlock.

• Rebuilds the structure placement types 26.3 removed, so mods that register their own placement still register and read it.

• Repairs old calls to RandomState.sampler(), BiomeSource.getNoiseBiome, and the ChunkAccess.setBlockState form that took a moved-by-piston flag.

• Keeps old reads of the spawn entry codec and the villager type constants working on 26.2 and newer.

• Points old uses of ConfiguredFeature at the 26.3 Feature, which kept the same place method.

• Points mixins at Minecraft methods the host renamed, such as resizeDisplay to resizeGui, pickBlock to pickBlockOrEntity and destroy to exitWorldAndClose, and retypes the handler when the parameters changed too.

• Follows the 26.1 rename of GUI render methods to extract methods for screens and overlays, as it already did for the HUD.

• Picks the one overload a handler's captured arguments fit when the host overloads its target's name.

• Keeps an old mob's own death loot table when another mod rebuilds the entity type's default table.

• Gives old model code the corners of a block model face that names no uv, filled in from the element's bounds as 1.20.1 did.

• Accepts mod jars that repeat a folder entry, as merged fat jars do, on every translation path.

• Logs an INFO line when it removes a Mixin handler that Mixin would refuse.

• Lets a NeoForge 1.21.11 or 26.x dedicated server load a mod whose shared classes name client classes the server no longer ships, such as a screen or the local player. The server's copy gets empty stand-ins with the client class hierarchy, and client code that actually runs on the server still fails as before.

• Keeps the names of a mod's own networking methods on Minecraft 26.1 and newer. Retromod renamed methods ending in S2C or C2S on any class whose name contains networking, a rule meant only for Fabric API, so Architectury and the mods built on it stopped with NoSuchMethodError while starting.

• Updates worldgen data from 1.21.x mods for 26.1 to 26.3. Forest rocks become block blobs, huge mushrooms get their placement tags, dripstone clusters and pointed dripstone become speleothems, large dripstone and root systems get the fields they now need, a multiface growth without a block places glow lichen, and cave, nether cave and canyon carvers get the counts, thickness and scales their old classes hardcoded.

• Rebuilds the vanilla patch features 26.1 removed, such as minecraft:patch_grass, around the feature they placed when a mod's placed feature still names them.

• Applies the same worldgen updates to pack overlays the host loads, and keeps a feature's loader conditions, such as neoforge:conditions, when it unwraps the old config object.

• Replaces the reference loot condition and function that 26.3 removed with the predicate or item modifier id, and turns value_check into int_value_check with its test range.

• Converts old type_specific entity predicates to the keyed kinds 26.2 reads, including the entity predicates nested in looking_at and entity_struck, and drops entity predicate fields the old game ignored.

• Renames the 1.21.1 attribute ids, such as generic.max_health, in data files and in function commands and NBT. Another mod's ids are left alone.

• Gives old time checks the overworld clock, renames damage_item to change_item_damage, rebuilds 1.21.1 wolf variants with assets, spawn conditions and baby textures, and gives a visible root advancement the background 26.3 requires.

• Updates item components that 1.21.2 to 26.3 replaced: fire_resistant, hide_additional_tooltip, the object form of attribute_modifiers, and map_color.

• Converts item modifier lists, empty trigger check lists, exploration map destinations, and untyped number ranges inside other providers to the shapes 26.3 reads.

• Converts lone item and tag ingredients in a mod's own recipe types, and writes lenient JSON, such as an unquoted string, strictly from 1.21.6.

• Keeps a tag the mod's own version read as empty, such as #minecraft:carpets or a missing structure tag of its own, as an empty tag on 26.3, and drops its own biomes that it never shipped from its surface rules.

• Repairs Forge 1.20.2 to 1.21.x channel networking on NeoForge: ChannelBuilder, SimpleChannel message builders, CustomPayloadEvent.Context, version tests, and PacketDistributor targets send through NeoForge payloads.

• Registers Forge 1.21 payload channels (ChannelBuilder.payloadChannel()) with NeoForge as the mod's own custom payload types.

• Keeps IExtensionPoint.DisplayTest and registerDisplayTest loading for Forge mods on NeoForge 1.21 and newer. NeoForge checks client and server compatibility itself, so the test is accepted and not run.

• Maps Forge's FMLModContainer and the typed FMLJavaModLoadingContext.getContainer() to NeoForge's.

• Disables a mixin whose target changed between class and interface, such as a class mixin on Explosion or Feature, instead of letting Mixin stop the game.

• Keeps placement modifiers, placement filters, repeating placements, and block state providers from mods built before 26.3 loading and placing, and registers their old types as the codecs 26.3 expects.

• Calls methods on game types that changed between class and interface in the form the current version needs.

• Leaves EMI plugin, Trinkets 3, and @WrapWithCondition mixin class names as they are, because current EMI, Trinkets, and MixinExtras releases still ship those classes. Earlier builds moved them to classes no release has, which broke EMI plugins and silently disabled @WrapWithCondition handlers.

• Moves Sodium, Iris, Cardinal Components, and Trinkets 2.x class names, and bridges old Curios members, only when the library installed, or translated together with the mod, has dropped the old names, and only for mods built before the rename. With no library in view, Retromod decides from that library's published versions for the host.

• Repairs old @Inject handlers whose target gained, lost, or changed parameters, so they take every new argument, or only the callback when they read none. Mixin refused the shorter layout earlier builds wrote. It also points the mod's refmap entry at that method, on Fabric hosts before 26.1 as well, so the handler finds its target. A handler that calls cancel() keeps working when its target gained a primitive return value, and one that may cancel a method which now returns an object is removed and logged, instead of being left for Mixin to refuse.

• Keeps the compiler's own stack map frames on a method whose types Retromod cannot read, such as loader config values or library exceptions during offline translation, so the class passes verification.

• Reads a Fabric mod's class hierarchy under its new names in the passes that run after renaming, so a screen class no longer fails verification.

• Removes a @ModifyReturnValue handler whose target now returns another type, so the rest of the mixin applies and the target class loads. That handler's effect is lost.

• Opens every Minecraft version range shape when translating offline, including sets such as [1.21],[1.21.1] that NeoForge refused after the rewrite.

• Translates mods whose bundled jars repeat a folder entry.

• Accepts archive entries up to 128 MiB, so a mod that bundles a large jar translates. Retromod still counts the bytes it reads and caps the total.

• Remaps every access widener a Fabric mod declares, whatever its file name, so Fabric accepts it on 26.x.

• Opens an exact Java version in Fabric metadata, such as "java": "21", so the mod loads on the Java 25 that 26.x needs.

• Keeps 1.20.5 to 1.21 item parsing working on 26.1 and newer, where ItemParser.parse returns a different result.

• Calls Retromod's helper classes as classes when the original call went to an interface, which ended in IncompatibleClassChangeError.

• Keeps a mixin that extends a chunk generator or biome source on that class, so Mixin accepts it on 26.3.

• Translates Java 1.4 and 5 classes without computing frames they never use, which logged warnings and could drop their rewrites.

• Rebuilds the VertexConsumer calls Minecraft 1.21 removed, such as vertex, color, uv, overlayCoords, uv2, normal, endVertex, the whole-vertex call, and defaultColor, so old mods write the same vertices on Forge, NeoForge, and Fabric from 1.21 to 26.3.

• Gives a mod's own vertex consumer written for 1.20.x the newer builder methods, so its wrappers and collectors still receive what host code and old code draw through them.

• Keeps the base draw an old entity renderer asks for from a method other than render, as GeckoLib 4's renderFinal does, so those entities are drawn on 26.x.

• Brings back an old entity renderer's own render offset and name tag rule on 26.x, and answers their base calls as 1.20.1 did.

• Points Entity.getTeam() calls from mods built before 1.20.3 at the PlayerTeam it returns now.

• Reads the old moon phase, moon brightness, and time of day from the environment attributes that replaced them in 1.21.11, and the day time from the world clock.

• Repairs old geometry loaders whose nested models have parents several files deep, such as lootr's barrel, on Forge 26.2 and 26.3.

• Lets old model code read and build block model elements, faces, UVs, and rotations on 26.1 and newer, so models like Sophisticated Backpacks' backpacks bake.

• Keeps old item models that mix block and item textures working on 1.21.11 and newer, which gave items their own atlas. On Forge 26.2 and 26.3 it also adds a fluid bucket's fluid texture to the items atlas under the item/ path Forge's bucket model reads.

• Logs a recipe serializer built before 1.20.5 that has no codecs as a detail line instead of a warning with a stack trace.

• Loads recipes that Forge 1.20.1 mods read with their own serializers on Forge and NeoForge 1.21.2 through 26.3.

• Builds the result stacks those serializers read on 26.1 and newer, where item components bind late, so they stack with stacks made later.

• Treats a tag ingredient in those recipes as present, bound or not, as 1.20.1 did.

• Matches and assembles those recipes through the mod's own matches and assemble, and bridges old recipe lookups by type, id, and cached check, and old crafting recipes that extend the shaped recipe.

• Loads Forge mods whose c: tags also list their forge: twin on NeoForge and on Forge 26.x. The translated tag no longer names itself, which sent the server's tag loader into endless recursion at startup.

• Bridges Minecraft.getDeltaFrameTime(), which 1.21 removed, to the frame's tick delta, so overlays that animate with it keep drawing.

• Lets NeoForge build a Forge 1.20.1 mod whose main class takes the mod loading context, as newer MCreator mods do. The mod gets a context tied to its own container.

• Adds an old listener on a parent event that NeoForge made abstract, such as AdvancementEvent or BlockEvent, to each event below it, instead of NeoForge stopping the mod while it loads.

• Answers ForgeVersion with the Forge 1.20.1 build whose API the mod sees and MCPVersion with the running Minecraft version, and gives old tick listeners on NeoForge the side field they read.

• Loads a config a Forge mod opened itself through ForgeConfigSpec.setConfig, and answers a config value's default until its config loads, as Forge 1.20.1 did.

• Maps Forge's FMLConfig, VersionChecker, and fluid SoundActions to NeoForge's, and uses NeoForge 1.21.1's ids for the reach, gravity, and step height attributes Forge kept on ForgeMod.

• Keeps GeckoLib 4 mods on their software.bernie.geckolib names on Minecraft 1.21.5 to 1.21.11, whose GeckoLib 5.0 to 5.4 still use that package. The move to com.geckolib now follows the installed GeckoLib and never applies to a mod built for GeckoLib 5.

• Keeps Retromod's own bytecode work on ASM 9.5, the oldest release a supported loader ships, so it no longer stops with NoSuchMethodError on older Forge, NeoForge, Fabric, and Quilt builds.

• Stops the Fabric and Quilt pre-launch with one clear error when the loader's ASM cannot read Minecraft's class files, naming the ASM release and the loader versions that can.

• Repairs 1.20.1 arrows on 1.20.5 and newer. The old constructors get a pickup stack, the arrow answers the pickup default its parent now asks for, and knockback a mod sets on its arrow applies on a hit.

• Lets an old arrow item fire its own arrow from bows and crossbows on 1.21 and newer, with the bow's enchantments applied.

• Runs old mob effect code again on 1.20.5 and newer: the tick, the tick check, instant effects, and the attribute add and remove overrides, which get the entity they used to, also after a world reload. A 1.21.1 effect's tick also runs on 1.21.2 and newer.

• Runs an old mob's custom death loot again on 1.21 and newer, with the killer's looting level.

• Keeps 1.20.1 world data saving. Direct saves pass the current registries, and data that saves its own file reaches the host's file save.

• Keeps writes made through the old item tag calls on the stack they were made on, including a stack's first tag. A copy of the stack, such as the one a menu keeps to notice changes, keeps its own data.

• Bridges the 1.20.5 item name and tag element calls, stack comparison, tooltip lines, the attribute number format, block corner boxes, chat character checks, and the effect resend packet.

• Bridges player scores looked up by name, which 1.20.3 replaced with score access, and reads 1.20.1 position tags on 1.20.5 to 1.21.4, as newer hosts already did.

• Treats a jar that reads enchantment levels the 1.20.1 way as an old enchantment jar on 1.21 and newer, and leaves its mixins into Enchantment on the host's class.

• Draws old Forge item renderers (BlockEntityWithoutLevelRenderer) on Forge 26.2 and 26.3 through an item model type each mod adds, with the item's old display transforms.

• Answers old IClientItemExtensions.getCustomRenderer() calls with the item's own renderer, also when it comes from another translated mod.

• Keeps an item's flat icon when its old renderer is missing or fails while drawing.

• Draws old item renderers (BlockEntityWithoutLevelRenderer) on NeoForge 26.1, 26.2, and 26.3, for NeoForge 1.21.x mods and for Forge 1.20.1 mods running there, through an item model type each mod registers with NeoForge.

• Drops what an old item renderer writes after its draw has ended, so one item's late writes never show on another item.

• Builds Forge 1.20.1 fence gates that pass their own open and close sounds, using an oak wood type that plays them where the host has no sound constructor.

• Answers Mth.color(float, float, float), which 1.21.2 removed, with the same packed color.

• Rebuilds the 1.20.1 RecipeHolder interface, so Forge block entities that implement it load on 1.21 and newer.

• Rebuilds RandomPatchConfiguration on 26.1 and 26.2, so a mod's own patch feature registers and its data reads with the old fields.

• Keeps Forge entity types with a custom client factory registering on Forge 26.x.

• Builds flowers through vanilla 1.20.1's FlowerBlock(MobEffect, int, Properties) on 1.21 and newer.

• Reads a food effect given as a supplier, as Forge 1.20.1 allowed.

• Maps Item's old base attack UUIDs to the host's base attack ids, so weapons built the old way still show base damage and speed.

• Finds the id of an item a mod registers through a helper it hands its register helper to, so Patchouli's book builds on 26.x.

• Lets a deferred register's supplier register the entry it returns, as Balm's creative tabs do, without a duplicate key on Forge 26.x and NeoForge. A supplier that registers one object and returns another stops with an error naming the entry.

• Reads library mods translated earlier when rebuilding an addon's stack frames, on the Forge, NeoForge, and Fabric runtimes, the CLI batch, and batch --aot, so an addon that picks between two library types passes verification.

• Moves old mixins that extended a removed screen class onto the class it extended, so Patchouli's inventory book button applies again on 26.1 and newer.

• Keeps Patchouli's smithing recipe pages working on Forge and NeoForge 1.21.5 and newer and on Fabric 26.1 and newer, where the template and addition ingredients became optional.

• Restores TerraBlender 1.20.1's surface rule registration on 26.x by rebuilding the registry overload it calls, which Minecraft removed.

• Lets a mixin load when it declares, but never calls, a method the host changed. A mixin with nested classes keeps every shadow.

• Bridges 1.20.1's BlockSourceImpl onto the dispenser BlockSource record, so mixin handlers and mod code that name it load.

• Follows the rename of the keyboard handler's debug key flag, also when translating offline, so GlitchCore's keyboard mixin loads on 1.21.11 and newer.

• Removes two mixin members that can no longer bind, GlitchCore's handler for Forge's old dimension change method and Balm's renderSlot invoker, so Balm's other screen accessors work again for Waystones and Sophisticated Core.

• Accepts a method descriptor in a mixin blocklist entry, so an entry can remove one overload.

• Keeps the stored object when a mod's bytecode saves a new identifier in a local before building it, so JEI's recipe types and key bindings no longer fail with "Operand stack underflow".

• Leaves a constructor call as written when a mod's optimizer moves the new object or reuses its local, so JEI's tipped arrow and stew recipe makers build their items correctly.

• Sends DataFixerUpper's old Codec.unit calls to MapCodec.unitCodec on every loader, so Balm, Waystones, and other 1.20.1 and 1.21.1 mods build their codecs on 1.21.11 and newer.

• Restores DataFixerUpper's old DataResult.getOrThrow(boolean, Consumer) on Minecraft 1.20.5 and newer for Fabric, Quilt, Forge, and NeoForge mods, Forge 1.20.5 and 1.20.6 included. It returns the value, or reports the error once and throws, as before.

• Keeps fields and calls typed as the old Tiers and ArmorMaterials enums working on 26.x, so Farmer's Delight's skillet and JEI's anvil repair list pass verification. values() and valueOf(name) return the vanilla materials, and each answers toString() and name() with its old constant name, as KubeJS expects.

• Lets a class load when it overrides a method Minecraft has since made final, such as JEI's shaped recipe and Farmer's Delight's cutting board dispenser. The override is renamed, and the mod's own calls and method references follow it. An override that an access transformer or access widener applied by the mod's loader opens keeps its name.

• Runs old overrides of Entity.isAlliedTo (from 1.21.2), a button's drawing method (from 1.21.11), and a widget's updateNarration from the hooks Minecraft's final methods now call, and keeps a button that calls its old super drawing method from failing when drawn.

• Reads the access transformers a mods.toml declares, including Forge's list form, and Quilt's access widener, when deciding which methods a mod has opened to override.

• Reads an old DataResult.PartialResult error as the newer DataResult.Error from 1.21.1 on, so mods that print a codec error message keep working.

• Gives Farmer's Delight's RecipeBookType.create call the smoker's recipe book type on Forge 26.2 and on NeoForge, where the old call no longer adds a type.

• Makes transform, batch, prepare, and aot give each redirect the target a running game gives it, so a jar translated offline matches the same jar translated in game.

• Repairs old Fabric API ScreenEvents.beforeRender calls in Fabric mods translated in game on 26.1 to 26.3, which went to a stand-in method that does not exist; they now call beforeExtract.

• Repairs old RenderType.solid(), cutout(), cutoutMipped(), and translucent() calls on 26.1 and newer, which returned no render type in game; they now return the host's moving-block render types.

• Sends old PoseStack blit and fill draws in Fabric and NeoForge mods to the 26.1 GUI bridge, as Forge already did.

• Repairs old SoundEvent id reads: getLocation() in Forge and NeoForge mods on 1.21.2 and newer, and getId() in Fabric mods on 26.1 and newer.

• Keeps a Fabric mod's custom placement modifier working when translated in game on 26.1 and newer. Its getPositions override was renamed to count, which broke world generation with an AbstractMethodError.

• Adds the Forge stand-in classes, such as DistExecutor, IForgeRegistry, and recipe conditions, when translating offline for NeoForge 1.20.2 and newer, and NeoForge's removed FMLJavaModLoadingContext and DeferredSpawnEggItem from 1.21.11, as the game does.

• Ships the license texts of the bundled ASM, Gson, SLF4J, and toml4j libraries, and MCPConfig's notice for the bundled Forge name tables, under META-INF/licenses/. THIRD_PARTY_NOTICES.md now lists every library, the mapping sources behind Retromod's name tables, and the rebuilt Forge, NeoForge, and Fabric APIs.

A mod whose only clue is an old Forge requirement it never raised is read as built for that older version, which applies extra shims that find nothing to change. Fabric and Quilt 1.21.2 to 1.21.11 still lack most of the 1.21.x client repairs, because those hosts run intermediary names and the changes are not plain renames. Old screen overrides of keyReleased, charTyped, and the widget click hooks are never called on 1.21.9 and newer. Binding an off-screen render target still fails from 1.21.5, and GuiGraphics.bufferSource() has no stand-in from 1.21.6, where GUI drawing became queued render state. Names the fuzzy resolver no longer guesses now fail with NoSuchMethodError or NoSuchFieldError when they run, until each gets its own bridge: Entity.kill(), Mth.sin and Mth.cos with a float argument on 1.21.x hosts, the cow, pig, cat, and wolf sounds 26.3 split per variant, and ExperienceOrb.value. Fabric and Quilt 1.20.5 to 1.21.11 hosts still lack the NBT, spawn, recipe lookup, and several entity bridges, because those hosts run intermediary names and need intermediary-native bridges. Saplings from 1.20.1 mods still fail on 26.3, which replaced the TreeGrower constructor, and chest boat models from 1.21.1 mods still fail on 1.21.2 and newer. The NeoForge 26.3 fuel and compost bridge reads only jars Retromod translated, skips conditional entries, and does not cover code that reads NeoForgeDataMaps.FURNACE_FUELS or COMPOSTABLES. With the new CLI default, players on 26.1.x or 26.2 pass --target or --mc-jar. In-place loading is not available on NeoForge 1.20.2 to 1.20.4 or on NeoForge 1.20.5 and 1.20.6 builds that run FML 3.0.18, so Retromod leaves mods/ unchanged there. With write_translated_jars on, it still translates on those 1.20.5 and 1.20.6 builds. Forge and NeoForge 1.21.2 to 1.21.10 still stop at Block id not set for content mods from before 1.21.2. On 26.3 old placement modifier and structure placement registrations are not converted, because those registries now hold map codecs directly. The CLI applies the Forge-only repairs, such as the rebuilt DistExecutor and the priority conversion, only with --target-loader forge. On Forge 26.2 and 26.3 an old entity interaction listener runs twice per click on the client, and an old mod's register(object) still hooks instance handlers that are not public, which Forge 1.20.1 skipped. Subscriber classes register in name order at the end of the constructor, so equal-priority listeners can run in a different order than on 1.20.1. A subscriber class that also names an event Forge 26.2 removed, such as RegisterGuiOverlaysEvent, still loses its listeners until that event is rebuilt, and a listener typed to one of the moved events' base interfaces does not run. Casting another mod's fake player to FakePlayer still fails, because each mod carries its own copy. A direct new PathPackResources(name, path, builtin) still fails on every loader, and packs offered through ResourcePackLoader or Pack.readMetaAndCreate do not reach the pack list yet. Enchantments a mod defines in code are never added on Forge 26.2 and newer, because the game loads enchantments from data packs. A later listener cannot undo a cancel, and on Forge 26.3 old listeners on RenderBlockScreenEffectEvent, which became an abstract parent and dropped its overlay type, do not run. A base TickEvent listener runs in registration order among listeners of the same priority, and an object one mod registers and another mod unregisters stays registered. On 26.3 the brewing lookups that JEI, EMI, REI, and Create read are not rebuilt yet, and brewing recipes added in code take effect from the next server start. Added trades also apply from the second start with the mod, a random trade keeps the one offer it produced, and the vanilla trade classes removed in 26.1, such as VillagerTrades.ItemsForEmeralds and VillagerTrades.TRADES, are not rebuilt yet. A denied LeftClickBlock now stops later listeners, a RenderNameTagEvent allow cannot show a tag the game hid, and a result read on another thread reads the default. Capability data on an item stack is not saved on Forge 26.2 and 26.3, so a provider on a stack starts empty after a reload or a copy, and an old save call made with no world loaded stops with an error naming the call. The old RegisterCapabilitiesEvent fires one loading step earlier than on Forge 1.20.1. Biome modifiers that name a carving step still fail, old biome modifiers cannot change mob spawns on Forge 26.3, and a custom shield that answers SHIELD_BLOCK links but does not block. BlockEntity.removeComponentsFromTag(CompoundTag) and the old NbtUtils UUID and block position helpers are not bridged yet. The old contains(String, int) and getList(String, int) ignore their type filter on 1.21.5 and newer. ChatComponent.addMessage now adds a client system message, which 26.1 shows with the single-player tag. Mods built for 1.21.4 to 1.21.11 that pass on a material from model texture slots (TextureSlots.getMaterial, addTexture) now stop at that call on 26.x, which kept those members on the new sprite Material. Until a world loads, an item stack an older mod builds early has none of the item's default data. It reports a maximum stack size of 1 and a maximum damage of 0, shows an empty name, and draws no item model. Code that clamps it before then keeps the clamped value. A stack put into a container is cut to 1, and damage set on a tool is stored as 0. A default component an old mod removes before then comes back once a world loads. One it sets to the item's default value stays as a change, so that stack does not stack with a new one until it is saved and loaded. A hash set of stacks filled before then keeps the old hashes. Before a world loads, getDefaultInstance() gives the plain item, so a potion, or an item whose own default calls Minecraft's, comes back without its extra data. Code that reads an item's components directly before a world loads, such as Item.getDefaultMaxStackSize() or ItemStack.getPrototype(), still fails. On Forge 26.2 and 26.3, Forge draws several old HUD overlays in one layer, such as the hearts, armor, food, and air, so cancelling only one of them cannot hide it. Old HUD events follow Forge 26.2's draw order, not Forge 1.20.1's, and old overlays draw only as far as the GUI drawing bridges cover their calls. The dropped ForgeGui mixins take their features with them, such as BetterF3's debug screen and ImmediatelyFast's HUD batching. Custom ingredients that rely on Forge 1.20.1's Ingredient internals, such as Farmer's Delight's tool ingredient and KubeJS's ingredients, still fail to read on Forge 26.2 and 26.3, and their recipes are skipped. Old custom ingredients show no items in recipe viewers or the recipe book. A serializer registered after Forge registers ingredient serializers, as Cobblemon does, is not registered. On Forge 26.3, data recipes that use an old custom ingredient stay unloaded. Only the ingredient half of CraftingHelper is rebuilt. On Forge 26.2 and 26.3, every old render stage fires after all vanilla world passes, so geometry an old mod draws at an early stage such as AFTER_SOLID_BLOCKS lands on top of water, particles, and weather. Drawing from these listeners does not reach the screen yet. The projection leaves out the nausea and portal warp, and listener priority holds within one mod but not across mods. Old block colors on Forge 26.2 and 26.3 cover tint indexes 0 to 3. Old item colors apply only to items of a jar whose own @Mod constructor sets them up, never to vanilla items or another mod's items, and are drawn opaque as Forge 1.20.1 drew them. Items whose model comes from a custom model loader, such as Sophisticated Backpacks' backpacks, get no item tints yet. Quads on Forge 26.2 and 26.3 keep no per-vertex color or custom normal, and a lightmap keeps only its block light. A layer set with setRenderLayer does not change the layer Minecraft picks from a block's textures. Mods that extend BakedQuad or write its fields directly, such as CreativeCore and DynamicTrees, still fail. The rebuilt foliage color getters return the colors with a full alpha byte, as 1.21.2 and 1.21.3 did; 1.20.1 returned them without one. Farmer's Delight's cutting board mixin applies on 26.2, but its handler no longer matches the dispenser method, so dispensers do not use tools on cutting boards. Clumps' orb clumping, Balm's ImageButton texture accessor, and GlitchCore's key and dimension change events still need ports. Patchouli smithing pages are not covered on 1.21.2 to 1.21.4 hosts. An extra model in a namespace no installed mod owns, other than minecraft, loads only from the resource reload after it first appears. Mods that drive ModelBakery internals, such as ModernFix, DynamicTrees, and CreativeCore, still need real ports. Handlers and lambdas an old mod adds at run time to a parent event reach its children as plain listeners, so they do not carry receiveCanceled or a cancel on a child such as RightClickBlock. An EntityEvent handler no longer receives RenderNameTagEvent, which Forge 26.2 moved out from under EntityEvent. Fabric jars, and jars written with write_translated_jars set to true, need to be translated again to pick up the RenderType repair; Forge and NeoForge in-place translations rebuild on their own. An offline transform applies only the shims between a mod's version and the target, while the game applies every shim up to the host, so for a known source a few targets still differ: Registry.register keeps Forge's late-registration helper in game for every Forge and NeoForge mod but offline only for Forge mods built for 1.20.x, and a newer mod that still names Forge 1.12.2 lifecycle classes gets different stand-ins. A mod's own recipe book type shares the smoker's open and filter switches. Offline translations for 1.21.2 to 1.21.10 targets do not get the Codec.unit redirect, because Retromod could not check those versions' DataFixerUpper; in game, Retromod checks the running host instead. Old geometry textures come only from the block and item atlases, so geometry using chest, sign, or banner sheet sprites shows the missing texture. Multipart and weighted block states keep the quads read up front. Kiwi's and DynamicTrees' loaders, and parts of Fusion, athena, and ModernFix that reach into Forge 1.20.1's model loading, still fail. Minecraft's codec() call is answered only for surface rule sources and conditions, material rules, and density functions. On 26.3, a rule source that extends another mod's rule source works only when its jar was translated with the other mod's jar available, as the game folder provides. An override of a method Minecraft made final loads under a new name and no longer runs when Minecraft calls it, except for ally checks, button drawing, list narration, and entity dimensions, which Retromod routes through Minecraft's hooks. Calls through a mod interface, reflection by name, and other mods' mixins that target a renamed method still reach Minecraft's method. The 26.3 surface rule support has not run in game yet. On Forge, Regions Unexplored still fails before its surface rules, on ForgeRegistries.FEATURES. Citadel reads another mod's biome keys by reflection, so a mod with an explicit module-info that does not export the package hides them, and those rules are skipped without a message. Lithostitched's lithostitched:biome and lithostitched:slope conditions throw a ClassCastException when 26.3 compiles them. Old surface rules on 26.3 follow 26.3's own generation, which samples noise in floats and prunes the biomes each chunk can hold. Surface rules and density functions in data pack JSON are not converted. An old density function that reads a 3D noise itself still computes it point by point, about four times slower than 26.3's own noise, and one whose compute hands its context to a helper, reads a coordinate, or reads a child its mapAll does not visit is sampled on every axis. Old interpolated(df) uses 4 by 8 cells, which is right for the overworld, Nether, caves, amplified, and large biomes, but not for the End, floating islands, or custom settings such as Deeper Darker's Otherside. The flat cache now caches exactly, so values between grid points differ from the old corner value. Old code builds no wired noise on 26.3, so Lithostitched's sample_density, which Tectonic uses for underground rivers, still fails. An old compute runs on a single-point context, so its getBlender() is empty and a cast of the context to NoiseChunk fails. The old noise router, RandomState.router(), and the old generator settings constructor with its aquifer and ore vein flags are not rebuilt. Oh The Biomes We've Gone's band rules read the old surface system, which has no 26.3 counterpart, and Deeper Darker builds its dimension's generator settings with the old constructor. When a launcher's sandbox keeps mods/ read-only, Fabric and Quilt installs, jars you pick or drop, and write_translated_jars cannot write there. In-place loading on Forge and NeoForge still works, because it writes only to retromod-cache/. The buttons in Retromod's pre-launch windows on Fabric and Quilt, such as Open GitHub Issues and Read Compatibility Notes, now show the link instead of opening the browser, because Retromod opens links only through a running Minecraft client. Dropping jars does not work on Forge 1.20 to 1.20.4 or NeoForge 1.20.1, where the Retromod screen cannot open. An empty launch folder can stay in retromod-cache/work/ after the game closes until the next start removes it. A public field declared in a class that is not public still cannot be read reflectively by Retromod's helpers, and some older helpers still look methods up on the object's own class. Baking an entity model layer before the game has loaded its models still fails, as it did on 1.20.1, and hosts from 1.21.4 to 1.21.11 do not get the early entity model set. Rebuilt classes, such as the old banner pattern item, still need both libraries to use the same copy, so an add-on call that passes one into a second library fails with NoSuchMethodError. A class that implements an add-on interface whose default method overrides a library interface method gets no bridge, and neither does a mixin class, since Mixin would merge the bridge into its target. A block or item that a library stores in a static field, and that only another mod registers, still gets no id, and a jar translated by an earlier Retromod build keeps its own id slot until it is translated again. An object registered under an id the mod works out after building it, as YungsApi does, still gets no id, and neither does an object built in a supplier passed to RegisterEvent.register(key, id, supplier). Persistent data on a vanilla block entity stays in memory on Forge 26.x and is not saved, and NeoForge keeps its own data under NeoForgeData, so ForgeData from a Forge 1.20.1 world is not read there. Fabric and Quilt block entities and entities from mods built for 1.20.4 or older still keep their old save code unbridged. Item keys a vanilla parent reads other than Items, such as a record or a book, are not upgraded from the old stack shape, and block entity names from 1.20.5 to 1.21.4 mods are not converted. When nothing in a jar names a version newer than its declared floor, its item data is read from that floor, so a mod that declares 1.13 while built for 1.20.1 shows old item lore as raw JSON. A name a player typed as exactly a JSON object, such as {"text":"Ores"}, is read as 1.20.1 JSON. Component.Serializer's toJsonTree, its constructor, and its Gson adapter are not rebuilt, the rebuilt loot data answers only getLootTable, and DimensionDataStorage.get(Function, String) is not bridged. JEI 1.20.1 still needs a real port on 26.x: its recipe lookup depends on the client recipe manager that 1.21.2 removed, and its screens draw with rendering calls that 26.x removed. Old RegisterAdditional listeners load on NeoForge but are never called, so the models they register stay missing. Fabric and Quilt mods still lose getServerBrand(), because they call it by an intermediary name the host no longer has, and Forge-family mods on 1.20.2 to 1.20.6 hosts do not get the brand bridge. Hosts before 1.21.11 do not get the rebuilt TextureAtlasHolder, and a legacy atlas that names an id in Minecraft's namespace is registered under a Retromod id instead. The compound tag serializer is not restored on Fabric or on Forge 1.21.9 to 1.21.11, and a jar that names it but has no @Mod class gets no registration. An old biome condition cannot be written back to data. Old code that picks from an old SimpleWeightedRandomList it holds gets the value where it expected the wrapper, and SimpleWeightedRandomList.getRandomValue has no 26.x counterpart yet. An old item renderer that calls other removed rendering APIs, such as ItemRenderer, Tesselator, or BufferUploader drawing, fails on its first draw, and its items show their flat icons until the next resource reload, or nothing when the jar ships no icon. Enchantment glint on these items does not show yet, IClientItemExtensions.DEFAULT draws nothing where Forge 1.20.1 drew vanilla's chests, shields, and banners, and geometry drawn outside the unit cube may be clipped in the GUI. Add-ons whose jars never name BlockEntityWithoutLevelRenderer keep the flat icon, and a mixin into that class stays disabled, because 26.x draws no item through it. Old item renderers keep the flat icon on NeoForge 1.21.4 to 1.21.11, whose item models bake without the transformation the rebuilt model uses, and on Fabric and Quilt for items drawn through BuiltinItemRendererRegistry. 26.3 turned Feature into an interface and removed FeatureConfiguration and Forge's feature registry, so old patch features and other old feature classes cannot load there, and 26.3 also removed SignItem, PlacementModifierType, and Forge's IForgeShearable, which Farmer's Delight, Waystones, and Lootr reach while registering. Data that uses the vanilla minecraft:random_patch type, such as Farmer's Delight's patch files, still does not load on 26.1 and newer. A supplied food effect is read when the food is built, not when it is eaten. The rebuilt RecipeHolder defaults do not unlock the recipe, fire the crafting trigger, or check the limited crafting rule. A block entity that overrides awardUsedRecipes, as Farmer's Delight's cooking pot does, keeps its own behavior. Fabric 1.21.2 to 1.21.11 hosts lack the Mth.color and flower bridges, and Forge 1.20.2 to 1.21.x hosts lack the RecipeHolder bridge and the spawn packet redirect. The single-jar transform and aot commands, the Fabric full precompile, and the hybrid background pass do not read library mods when rebuilding frames, and an AOT jar compiled with library mods is reused only while those same library files are present. The rebuilt compound and strict NBT ingredients write through the host's serializer, which accepts only Forge's own ingredients, so writing a mod's own one fails, for example in synced stonecutter recipes or data generation. Partial NBT ingredients compare custom data only, as Forge 26.2's NBT ingredient does. ChannelRegistrationChangeEvent and the login payload events are not bridged, so Shulker Box Tooltip's listener still fails to link, and NetworkDirection.getReceptionSide is not rebuilt. On NeoForge, Ingredient is final, so a mod that extends the old compound ingredient still cannot load that subclass, partial NBT is not bridged, and old event channels deliver nothing. Forge 26.3's Ingredient constructor was checked only through Forge 66.1.2's AbstractIngredient, and the ingredient bridge was not checked on Forge 1.20.6 to 26.1 hosts. getEntity() finds the entity from the render state's type, position and age, or from the entity id that player and witch states carry, and the entity must match the state either way. It returns null for an entity drawn outside the level, such as a spawner's display mob or a preview in a book or recipe viewer. Alex's Mobs dereferences that null. It also returns null when two entities of one type fit the same state, as mobs pressed into one farm block do, and for an entity that moves more than 4 blocks in one tick. On NeoForge 1.21.2 to 1.21.8, getEntity() stays unanswered and fails as before, because those states lack the entity type or are reused for every entity drawn. getMultiBufferSource(), getPackedLight() and getPartialTick() on the render event are still missing. On 26.3, getScanCode() returns the key event's layout keycode, so a key event the mod rebuilds matches the host's. A mod that uses the scan code as a physical key id gets the layout keycode instead. A typed character's modifiers come from the keys held when the listener reads them, and report only Shift, Control and Alt. On 26.3, the key events' own getModifiers() returns SDL's bits, which old mods compare against GLFW's. Advancement.getId() answers only for an advancement the mod got from an event or looked up by id on the server; on the client it returns null. Before a world binds tags, getTags() streams nothing. A mod's own subclass of LevelEvent does not reach listeners of Forge's LevelEvent, and mod events on other Forge classes that became interfaces are not rebuilt. Forge 1.21.2 to 26.1 hosts are untested because no Forge jars for them were on this machine. On Fabric and Quilt, food items a mod adds to the old animal food fields are not applied, though reading the fields works. Removing items from those fields is not supported. If the advancement cleanup listeners cannot register, for example on Fabric without Fabric API, a departed player's advancement listeners stay until the game closes. A compound ingredient with one unbound tag child returns no items before tags bind, where 1.20.1 returned the other children's items. An old render layer or renderer that calls an API 26.x removed stops drawing until the next resource reload instead of stopping the game. Old model draws reach the screen only from the block entity renderers, entity renderers and layers Retromod runs, so a call from a screen or a render event draws nothing. On 26.3 an old glint buffer for a render type that is not an item sheet, such as an entity, armor or compass type, returns the plain buffer. isGui3d answers whether the item is lit like a block, the closest flag 26.x keeps. Quads read from an item model all come back on the unculled side. On NeoForge and Fabric, an item whose model a mod builds in code, such as Sophisticated Backpacks' backpack, has no quads to draw, because only Forge 26.2 and 26.3 rebuild old model baking. Old geometry loaders register without error but never run on NeoForge 26.x, so dynamic block models such as Sophisticated Backpacks' backpack do not draw there. Mods that register item or block color handlers still stop on NeoForge 26.x, which replaced those events. Old ModifyBakingResult and BakingCompleted listeners on NeoForge 26.x still call a getModels() that NeoForge removed. BlockModelShaper.stateToModelLocation and ModelManager.getModel with a model location are not rebuilt on NeoForge and Fabric. A mod's own subclass of ItemRenderer, such as Iceberg's, ModelBlockRenderer.tesselateBlock, and the renderSingleBlock variant that takes model data are not rebuilt. ItemRenderer.renderStatic called from a screen or a render event still draws nothing, and Carry On draws its carried blocks and entities from render events, which no longer get a buffer to draw into. Block entity renderers from mods built for 1.21.5 to 1.21.8 are not drawn yet, old shouldRenderOffScreen overrides are not honored, and old block entity renderers draw no block breaking overlay. Minecraft 1.21.2 to 1.21.11 hosts are not covered, because each of those versions has a different renderer shape. An old layer that extends one of Minecraft's own layers, such as the armor or elytra layer, still draws only Minecraft's layer, because 26.x never calls its old render. A layer that extends another mod's layer draws only what that mod's layer draws on its own. Layers written for 1.21.2 to 1.21.8, which draw a render state into a buffer source, stay off. Before any world loads, the old enchantment registry is empty. On Fabric and Quilt it is also empty during the first data pack load, because Retromod learns the loading registries from a NeoForge and Forge event. Registering an enchantment through Registry.register on the old field still fails. In a jar written against the old Enchantment class, holders from the registry carry the new enchantment record, which that jar cannot cast. Before any world loads, old text reads without registries, so text that names registry content fails as the host would for unknown content. Item data inside an old item hover is not carried over. A modifier serializer registered through RegisterEvent.register(key, id, supplier) is not converted. When a biome lists its carvers by tag, only the air carvers are kept. Writing an old modifier back through the game still fails, because its class still returns a codec. Forge 1.20.1's HolderSetType is not bridged. On NeoForge an old custom arm pose shows the plain item pose, because NeoForge adds arm poses only from metadata it reads before the game starts. A figure drawn outside the world, or a render state that two entities fit equally, keeps its default arm pose. A pose whose code fails stops posing after one warning. A spawn placement type built with create does not keep its name. Translations made with the CLI or AOT for 1.21.2 to 1.21.10 do not include the getFrameTime repair; a running game is read directly. Forge 26.3 arm poses were checked against Forge's 26.3 universal jar and the vanilla client, not a patched Forge 26.3 client. On 1.20.3 and 1.20.4, old text that names a registry entry, such as an item on hover, reads without the world's registries. The rebuilt ItemProperties does not cover Forge and Fabric 1.21.4 to 1.21.11 hosts or NeoForge 1.21.4 to 1.21.10. Items that read an old property through Retromod's item definitions need Retromod on the client. ItemProperties.getProperty answers only properties old mods registered, not Minecraft's own such as pull or angle, so old code that looks up a vanilla property gets null. NeoForge 1.21.4 to 1.21.11 hosts still lack the old item color event, so a NeoForge 1.21.1 mod that listens for it stops there. Listeners inside a bundled library that has no mod class of its own register but never receive the color events. Mods that read Minecraft's internal block color map through a mixin, such as Zeta, still stop on 26.x, because 26.1 replaced that map with tint source lists. The particle color call BlockColors.getColor(state, level, pos) is not rebuilt. Mods built for 1.20.2 to 1.20.6 are drawn opaque, on the assumption that item tint alpha arrived with 1.21, and an old mod reading ItemColors.getColor gets the color with full alpha. Writing an old mod's loot function, condition, or structure processor back out, as data generation does, still fails. On 26.3, old custom number providers have no registry to join. Custom int and float providers need a port on 26.1 and newer, and custom placement modifiers, structure placements, block state providers, and carvers need one on 26.3, because their base classes became interfaces. A 1.20.1 mod's custom loot pool entries still need a port, because their serializer and entry base changed shape. A Forge mod class with two public constructors is still refused by NeoForge. Until NeoForge loads a world's server config, an old mod reads that config's defaults, and villager trades built before then use them until the next /reload. On NeoForge 1.21.2 to 1.21.10, an old listener on a parent event misses child events those versions added. On NeoForge 26.1 and newer, an old listener on RenderLevelStageEvent or RenderNameTagEvent still stops the client while mods load. ForgeVersion reports a Forge 1.20.1 build on every NeoForge host, and Forge's early window settings in FMLConfig have no NeoForge counterpart. GeckoLib 4 mods still need a port to run on GeckoLib 5, which reorganized its classes and reads models and textures from a render state. Mods built for GeckoLib 5.0 to 5.4 keep software.bernie names that GeckoLib 5.5 on 26.x lacks. Minecraft 26.1 and newer need Fabric Loader 0.16.14 or newer, or Quilt Loader 0.29.0 or newer, because older releases ship an ASM that cannot read Java 25 class files. On 1.21.5 to 1.21.11, an old mod's world data is not loaded or saved. A tag reference an old mod holds across a copy of its stack still writes into that copy, and code that moves the custom data instance between stacks leaves them sharing it. Arrows an old mod builds outside an arrow item have no weapon, so the old code's own bow enchantments apply instead, and knockback a mod sets on a vanilla arrow is kept but not applied. A level read inside a mixin into Enchantment stays unresolved, and the 1.20.5 renames of the Enchantments fields, such as BLOCK_FORTUNE, are not bridged. Fabric hosts from 1.20.5 to 1.21.11 need intermediary bridges for these 1.20.5 members. Custom loot pool entries built before 26.3 still fail there, because 26.3 removed their base class and gave each entry one condition and one function. A loot condition that names a predicate by id loads and applies on 26.3, but such a loot table cannot be written back out. Building vanilla loot functions such as SetComponentsFunction or ExplorationMapFunction in code with a condition list is not bridged yet. An old command context lists no registries and reports every feature as enabled, because the old interface could do neither. Fabric hosts from 1.20.5 to 1.21.11 do not get these registry provider bridges. On Forge 26.2 and 26.3, the Safe Mode retry after a data pack failure fails in Forge's own code, independent of Retromod. Old reload listeners that wrap Minecraft's model or particle managers still fail when the wrapper hides AtlasManager from the host's prepareSharedState call, as ModernFix does for every listener. A wrapper that forwards from another thread hands its listener a fresh state. Mixins into a vanilla listener's old reload, such as those in Continuity, Athena, and Architectury's loot data mixin on Forge, are not covered. A mod subclass of the 26.x model or shader manager keeps only its old reload, which the host never calls. On NeoForge, ModLoader.addWarning, hasCompletedState, and postEventWithWrapInModOrder called on an instance are not bridged. Mods that extend SimpleJsonResourceReloadListener(Gson, String) still fail on hosts from 1.21.2 to 1.21.11, and Fabric API's SimpleResourceReloadListener changes from 1.21.2 are not bridged. A mod translated before GeckoLib 4 arrived in the same game keeps its com.geckolib names until it is translated again, after a Retromod update or a change to the mod's file. The same happens when both are picked one after the other in the in-game file picker. A GeckoLib 4 bundled inside another mod's jar keeps its own names, but does not count as installed for the mods around it. The Java agent mode transforms classes as they load, with no jar in view, so it still moves a library's own classes. The rule covers class moves only, so a member redirect on a library class that is not moved still applies inside that library. Other old libraries whose names Retromod moves, such as EMI, Trinkets, and Forge Config API Port for Fabric, now keep their own classes too. Mods that use them still take the same moves as before. An @Inject handler that reads a parameter the host removed or reordered is still left as it was. So is a handler at an INVOKE point, on a constructor, bound to several methods, or one that captures locals or uses @Coerce, @Local, or @Share. Mixin still rejects these, and each needs its own repair. A handler whose refmap still names the old target finds no target even with a corrected layout. putBulkData is not rebuilt. When host code or old code writes through a mod's collecting vertex consumer one setter at a time, the final vertex stays open until the next draw. Subclasses of DefaultedVertexConsumer and BufferVertexConsumer are not adapted, which leaves Embeddium, Oculus, and particle_core. Calls from one mod to another renderer's getRenderOffset or shouldShowName are not bridged, as in EntityCulling, the physics mod, and Supplementaries. On Fabric, LevelTimeAccess on 1.21.11 hosts and the 1.20.5 and 1.20.6 normal(Pose) call are not bridged. A mod entity that overrides getTeam() keeps its old return type. In the Nether, getTimeOfDay answers 0 where 1.21.1 answered 0.5, because 26.x keeps only whether a dimension has a fixed time, not the time. A loot entry that overrides expand still fails on 26.3, because 26.3 made that method final. Entries built before 1.20.5, which read their JSON through a Gson serializer, are not rebuilt yet. Mods that extend LootPoolEntryContainer or CompositeEntryBase directly still need a port, since 26.3 changed those constructors and codec fields too. Code that reads the functions or conditions field of an entry it holds as the old base type still fails. Reads of weight and quality work. A 1.21.1 data pack outside a mod reads on 26.3 without the conditions and functions of its entries, as vanilla entries do. A class that implements ContainerEntity with the old id methods, such as a modded chest boat, is not bridged. On 26.3, LootTableReference.lootTableReference(id) is not bridged, because 26.3 builds a nested table from a registry holder that only a method holding the registries can look up. MinecraftServer.getLootData() is bridged only from 1.21.11. Forge 1.20.6 hosts get none of these loot table id bridges, and neither does offline translation for Fabric 1.20.5 to 1.21.11. Reflection that reads BuiltInLootTables fields by name still gets keys. Old code that writes an element's rotation, as Supplementaries' awnings do, still fails, because 26.1 elements are records that cannot change. Forge and NeoForge face data on elements and faces (getFaceData and the ExtraFaceData constructors, used by fusion and athena on NeoForge) is not bridged. Hosts from 1.21.5 to 1.21.11 keep the old class names with the new record shape and get no element bridge, and 1.20.1 mods' face field reads also fail on 1.21 to 1.21.4, where faces were already records. A handler whose read value could match either of two new arguments is left alone. The refmap repair covers only @Inject handlers at HEAD, TAIL, or RETURN. Entries for other injectors, INVOKE and FIELD targets, accessors and invokers, renamed or removed methods, and moved classes still name their old targets, and each needs a class-side repair that moves with the entry. A handler whose annotation uses a Yarn source name keeps its entry unless its name has exactly one method on the host. Offline runs index vanilla Minecraft unless --mc-jar names the loader's patched client. When no library can be read and the host is not covered by a checked version table, Retromod leaves a library's old names alone, as with Sodium on 1.21 and 1.21.1, where both 0.5 and 0.6 exist, and Curios' getCuriosHelper on hosts between 1.21.1 and 26.3. The Trinkets 2.x moves rest on Trinkets 3.x lacking the old names, since no Trinkets 2.x build is on Modrinth to check. Old Curios calls to getCuriosHandler and getAttributeModifiers(String) are not bridged on Curios builds that removed them. Sodium 0.8 has no SodiumGameOptions, so old code that reads Sodium's options does not link there. A translated mod keeps the names chosen for the library installed when it was translated, and replacing the library with one that renamed them needs the mod translated again. A loot entry that names a table built in code cannot be written back to data. It is not validated at load, and a missing table rolls nothing. Removed registries read as empty, so codecs built over them find nothing, and registering into one fails because its stand-in is frozen. Data-driven variants now live in the world's registries. Mods that load the removed Schedule class or register a schedule still fail. Old mods that register armor materials still fail on 1.21.2 to 1.21.10. On Fabric, LootTable.Builder.pool comes from Fabric API at runtime, so it works only when Fabric API is installed. Forge 26.3's loot table event carries no registries, so its handlers use the roll-time lookup too. /loot kill on an old mob still reads its entity type's table from 1.21.2 on, because Minecraft made the mob's table getter final there. Calls to an old mob's getDefaultLootTable() from outside its own super call are not bridged, and neither is mod code that calls the old Mob.getLootTable() returning an id. On Fabric 26.x an offline run recognizes an old mob only with the Minecraft jar, from --mc-jar or an installed copy. Passes that rewrite a class after the main translation still recompute all of its frames, and offline they cannot read loader or library classes, so a class those passes rewrite can still get a widened frame. A real fix gives the offline CLI the loader's and libraries' class files. Only bundled jars may repeat a folder entry; a mod jar that repeats one at its top level is still refused. A removed @ModifyReturnValue handler's feature is lost on 26.3. Essential's inner game jar passes through unchanged, because Essential loads it itself. Forge Config API Port's Forge build still fails on NeoForge 26.3; use its NeoForge build there. An archive entry larger than 128 MiB is still refused. Recipes read through a 1.20.1 serializer do not appear in the recipe book. Such a serializer only reads recipes, so data generation through it does not work, and NBT in a recipe's result is not kept. On NeoForge, a Forge 1.20.1 block that matches recipes through Forge's item handler wrapper, such as a cooking pot, loads its recipes but cannot match them yet. GeckoLib 4 armor is not drawn on 1.21.11 and newer, because armor now renders from equipment assets and a render state. Wearing it does not crash. On Fabric, GeckoLib item renderers are not drawn, and Fabric before 26.1 and Forge and NeoForge 1.21.5 to 1.21.10 get none of the rebuilt GeckoLib textures. Glow areas declared in a texture's .mcmeta file are not read; a _glowmask image works. Textures a mod generates through its own GeoAbstractTexture subclass are not loaded. Rebuilt animated and glow textures keep the old pixels until restart after a resource pack reload. When an addon keeps its own copy of a generated item base, its library's type checks on that addon's items no longer match. NeoForge 26.3 reads per-world config overrides from syncedconfig/ instead of serverconfig/, so an existing world's overrides need to be moved by hand. Mods built against early NeoForge 26.3 betas keep the new config file names. IModFileInfo.moduleName, the early loading window, coremod, and discovery APIs are not rebuilt. A listener for a removed event is dropped only when it is a lambda or method reference written at the addListener call; one passed in from a field or another method still fails. Old data generation does not run on these hosts. NeoForge 1.20.2 to 1.20.4 clients, which run no discovery pass, cannot hold back a server-made jar copied into mods/. Forge 1.21 mods on NeoForge 26.x still stop on Forge APIs NeoForge never had, such as IExtensionPoint.DisplayTest, Forge 1.21 networking, FMLModContainer, Forge's permission API, and the scan data members getTargets() and interestingAnnotations(). They also stop on data files that name vanilla ids 26.3 renamed or removed. Without --host-jar, an offline translation for NeoForge keeps a Forge name wherever the game first checks that NeoForge has the class. A mixin disabled because its target changed between class and interface does not apply, so features that depended on it, such as explosion events, do not run. Code that reads vanilla's old placement modifier or block state provider type constants still fails, and an old call that asks a vanilla block state provider for a state passes no level, so providers that read the level fail there. Mods that extend a game class turned interface without a rebuilt base still fail, including ArmorMaterials, BlockModel, BakedGlyph, WorldCarver, StructurePlacement, InterpolationHandler, AbstractHugeMushroomFeature, TestFunctionLoader, and anonymous PacketSendListener implementations. 26.3 uses one creature spawn probability for every biome, so a mod's own value is ignored and its setter does nothing. A mod that ships an invalid advancement still stops a 26.3 server, because 26.3 loads advancements as a registry. Offline translation cannot yet read Brigadier for stack frames, so some command builders can fail verification; a game that translates the mod itself is not affected. The new team color argument does not accept reset, and code that reads it as ChatFormatting instead of through getColor fails. When no loader jar can be read, offline translation decides NeoForge boundaries before 21.11 from version numbers alone. Forge raw-buffer channels (ChannelBuilder.eventNetworkChannel()) are not bridged, so mods that use them still stop at construction on NeoForge. Version tests on bridged channels are kept but not enforced, because NeoForge registers each bridged channel as optional, so a client with a different mod version can connect and then fail on its first packet. Forge 1.21's handler protocols (PayloadHandlerProtocol with SimplePacket) are not bridged, and a payload channel built after NeoForge registered its payloads cannot send. Variant type_specific kinds, such as cat, wolf and frog, and kinds a mod registers itself are left unconverted. A carver's own replaceable and lava_level settings are dropped, since 26.3 has no such fields. Packs nested inside a jar under resourcepacks/ or datapacks/ are not rewritten, and neither are 1.18 configured_structure_feature files. Data from a mod whose Minecraft version cannot be read gets only the updates its shape proves, so an old time_check there still has no clock. A Forge loot modifier condition that names a predicate file through reference still fails to load on Forge 26.3 when the jar does not ship that file. The cactus, melon and sugar cane patches, patch_grass_meadow, single_piece_of_grass and the wildflower features are not rebuilt. On Forge and Fabric, an advancement icon that names another mod's item still stops the world when that mod is missing. A score with a scale in a whole-number field reads the unscaled score. A biome whose sugar cane and pumpkin patches are not side by side keeps its order, and so does a mod built for 1.21.11 or newer. Hosts from 1.21.2 to 1.21.10 do not get the swap yet. Function files that use 1.21.1 command syntax for particles, item enchantments or the potion entity still fail to load, and the world starts without those functions. On a NeoForge dedicated server, a mod that runs client code while the server starts still fails, and NeoForge 1.21.2 to 1.21.10 servers get no client stand-ins. Stand-ins are made per mod and per bundled jar. Mixins are not rewritten, so a common mixin that calls its own mod's method whose signature names a client type, or a duck or accessor interface whose methods name one, still fails when it runs on the server. A call between two translated mods whose signature names a client type fails with NoSuchMethodError on the server, and an override of such a method from another mod does not take effect there. On 1.21.11 and 26.x hosts Architectury's inventory hook does not apply, because its mixin names the inventory armor field that newer versions removed. Architectury still loads without it. Mixin targets that moved to another class (SkyRenderer, WeatherEffectRenderer, CloudRenderer, Minecraft.pick) are not repaired. Neither are splits (Camera.setup, Minecraft.clearLevel), removals (the debug overlay lists, reloadShaders, sendUnsignedCommand) or render-state redesigns (render to submit). Each needs the mixin moved to the new class or a bridge. A handler that reads a parameter the rename changed keeps its old selector and still finds no target. An overloaded target stays unresolved when the handler takes only the callback or fits more than one overload. Handlers that capture locals cannot follow a descriptor change. A mixin handler on the old hurt now runs only on the server, since 26.x splits damage into a server and a client half. A mod's own placement that extends a vanilla placement, such as random spread, is written back under the vanilla type, so its extra settings are lost if Minecraft saves the structure set. A mod chunk class that overrides the old setBlockState is not adapted. A configured feature's feature() and config(), its constructor, and its DIRECT_CODEC and LIST_CODEC have no 26.3 counterpart and still fail. An old processor's original-block argument carries the template position with the current state, because 26.2 no longer passes the original state. Fabric 1.21.11 is not covered for the chunk flag, spawn entry codec and villager type changes, because it runs intermediary names and these bridges are written in Mojang names. A mod's biome source that overrides getBiomesWithin with the old sampler argument keeps that override unused on 26.3. On 26.3, a biome source that extends a vanilla source such as MultiNoiseBiomeSource keeps its old getNoiseBiome override unused. A 26.3 biome source is no longer a BiomeResolver, so a mod that stores a biome source in a resolver field, such as Lithostitched's injector, still fails there. Only the 2D part of an old pose stack carries over. Depth moves, tilts out of the screen plane and depth scaling are dropped, because 26.x stacks GUI layers in draw order. A pose stack's mulPose with a Transformation is not copied to the 2D stack, and last().pose() on the copied stack does not include GUI transforms made before the mod asked for it. List rows no longer receive their place in the list, so each row reads as the first. A text selection fill keeps its highlight blend only when its render type is passed in directly; one kept in a field draws as a plain fill. Old key checks match without modifiers, so a key bound with a modifier does not match through the old call. A Renderable whose old render calls super.render on a Minecraft class that is neither a widget nor a screen keeps that old call. The private tooltip and sprite helpers that mods reach through access wideners (renderTooltipInternal, blitTiledSprite, blitNineSlicedSprite), the removed bufferSource() and the extractor constructor that takes one, and buttons that leave extractContents unimplemented are not bridged yet. These repairs apply on Forge and NeoForge 1.21.11 and newer, and on Fabric and Quilt 26.1 and newer. On 26.3, an old instanceof SignItem or instanceof BedItem check matches vanilla's and other mods' signs and beds, but a check that also casts to the class, such as a pattern match, still matches only the mod's own. A fake player built with the old constructor starts at the world origin instead of the position it was given. An entity built on LivingEntity that overrides the old hurt still misses damage the game deals. FlyingMob, Saddleable, MossBlock, the profile cache, the old game rule API, and the 1.21.2 attribute ids in code are not rebuilt yet. Another mod's mixin that injects inside an adapted entity's old hurt body, rather than at its head, no longer finds its injection points. About 250 methods and 130 fields changed type as well as name and still need a dedicated bridge. Mixins on renamed classes stay inert. Mods built for 26.1 or 26.2 get no renames. Overrides in another jar and names in reflection strings keep their old names. A Fabric mod that declares no Minecraft version, or only an older floor, counts as built before 1.21.2. A class in another jar that extends a mod's own level or chunk class reads that class's height one lower. A mod whose toml already declares a static mixins array keeps only that list. Nested Forge libraries are promoted only on the runtime path, as before, so the CLI and AOT add Mixin config entries only to bundled jars that already ship a neoforge.mods.toml. A NeoForge mod whose Minecraft version cannot be read keeps its manifest configs unlisted, and a mod built for NeoForge 1.21.9 or newer keeps only its toml list, as on its own host. A config named in one mod's manifest but shipped in another mod is listed only by the mod that ships it. A Forge mod's handler classes now load on NeoForge, but its capabilities are not connected to NeoForge's own capability lookups, so other mods' pipes and hoppers may not see a Forge mod's inventory. On 26.3, each translated mod carries its own copy of the rebuilt handler classes, so two Forge mods that pass a handler to each other through Forge's capability API fail when one casts the other's handler. Forge's Tag key on a fluid is not carried over, and Forge's FluidStack constructor that copies a stack with a new amount and its packet read and write are not bridged yet. On 26.3, a Forge FluidType that overrides the per-state light, density, or viscosity methods is not asked for them. On NeoForge, a Forge mod that registers its own ingredient serializer still stops before a world loads, because Retromod does not yet map Forge's ingredient serializers to NeoForge's ingredient types. Mods that read HIDE_ADDITIONAL_TOOLTIP or HIDE_TOOLTIP, which 1.21.5 replaced with the tooltip display component, fail with NoSuchFieldError there until a bridge rebuilds them. A removed field is still matched by name similarity when every field of its type on the class shares one generic type, so a removed field whose type differed from all its siblings can still be guessed wrong. On 1.21.11 and newer, ItemEnchantments.FULL_CODEC reads the plain enchantment map, so enchantments a mod saved in the old levels form do not load. On the first start of a 26.4 snapshot with an options.txt carried over from 26.3, the game resets the setting once and picks OpenGL or Vulkan at random. Retromod sets OpenGL again for the next start. These tickets are matched by type and level only, as on 1.21.5 and newer, so a mod that held two tickets of one type at the same chunk and level with different values now holds one. Mods that use vanilla ticket types removed since 1.21.5, such as PLAYER or POST_TELEPORT, still fail, and calls into the distance manager's own ticket methods are not bridged. A handler that reads a parameter whose type changed is removed instead of repaired, so that one feature of the mod stays off. The same happens when the handler shares a value through a generic LocalRef, when one of its @Local captures has the type of a parameter the target changed, or when a @Local names a slot the new parameters may move. Handlers that use Mixin's own locals capture or a slice are not repaired. Offline, a Forge or NeoForge translation removes such a handler only when --mc-jar is that loader's patched client. With a vanilla jar the handler stays, and the game can still stop on it. Brewing recipes from the rebuilt NeoForge event apply from the next start, because 26.3 loads recipes before a mod can build the items they use. Mixes apply only to the potion, splash potion, and lingering potion, so a bottle added with addContainer brews nothing. Forge's own brewing event on Forge 26.3 is a separate API and is not rebuilt here. Chances are rounded to vanilla's five: 30, 50, 65, 85, and 100 percent. A component that names none of them reads back as 50 percent. A mod that reads vanilla's chances while the game loads reads 0. A chance set after a world has loaded applies from the next world load or /reload. A mod that checks for or adds a vanilla item at setup sees it as absent and can replace vanilla's chance. Going over the table lists only the items that mod itself added, not vanilla's or other mods'. Fabric API's composting registry is a separate API and is not changed here. Setting an item's chance to 0 leaves it as it was. On Fabric 1.21.9 to 1.21.11 the pack format calls still fail, because those hosts run Fabric mods under intermediary names and the bridge uses Mojang's. The pack metadata constructor with an extra map that some Forge 1.20.1 mods call is not bridged. Old code that calls openPrimary, openFull, or Pack.open() on a pack it did not build still fails on 26.3, because those calls are not redirected. Suppliers that mods for 1.20.4 and older wrote as lambdas are not covered on 26.3. A supplier whose old methods are declared in a subclass of the class that names the interface is not covered. A removed tag key with no curated rename, such as BlockTags.TALL_FLOWERS or BlockTags.OVERWORLD_CARVER_REPLACEABLES, now fails with NoSuchFieldError where a mod reads it, instead of reading a different tag. A reference whose only close match is private, package-private, or protected in an unrelated class now fails with NoSuchFieldError or NoSuchMethodError where it runs, until a bridge covers it. Resource packs and data packs gained minor formats at different format numbers, so a resource pack whose range starts between 65 and 81 is read without its formats. On Fabric 1.21.11 the old pack metadata codec still fails, because that host runs Fabric mods under intermediary names and the bridge uses Mojang's. Old code that calls the old pack base's static getMetadataFromStream still fails, because that method is not rebuilt. An abstract pack class in a mod that declares no Minecraft version stays a metadata-only pack.