1.20 Summary of Patches - embeddedt/ModernFix GitHub Wiki

mixin.bugfix.buffer_builder_leak

Attempts to work around mods constructing BufferBuilder objects that leak memory. This can cause the JVM to crash with an hs_err_pid file in some rare cases. If you experience this type of crash, try disabling this option.

mixin.bugfix.chunk_deadlock

Attempts to prevent chunk system deadlocks or provide additional debug information in the log when they occur. These deadlocks usually manifest as the server freezing indefinitely (e.g. entities not moving), while the client continues to work just fine.

mixin.bugfix.cofh_core_crash

Fixes a multithreading issue in CoFH Core that can cause rare crashes during launch.

mixin.bugfix.concurrency

The patches in this group fix concurrency-related issues within Minecraft and/or Forge. Most of them result in rare, hard-to-diagnose crashes during loading.

mixin.bugfix.ctm_resourceutil_cme

Fixes a multithreading issue in ConnectedTexturesMod that can cause rare crashes during launch.

mixin.bugfix.ender_dragon_leak

Fixes a memory leak in vanilla caused by the ender dragon retaining a reference to the previous client world.

mixin.bugfix.entity_pose_stack

Fixes Forge issue #9118, where mods can cause undebuggable render crashes by pushing the matrix stack without popping it.

mixin.bugfix.extra_experimental_screen

Fixes the experimental feature warning being shown still being shown the first time you reopen a world that was created as experimental.

mixin.bugfix.fix_config_crashes

Fixes Forge configs occasionally becoming corrupted when launching the game.

mixin.bugfix.forge_at_inject_error

Fixes a major oversight in Forge's early error handling code that causes some parts of mods to load, but not others, which usually results in the game crashing rather than displaying the intended error screen. This issue was fixed in NeoForge, and eventually fixed in new enough versions of Forge.

mixin.bugfix.forge_vehicle_packets

Fixes a bug introduced by a Forge patch that causes excessive amounts of chunk data packets to be sent to the player if they are riding a vehicle on a chunk border.

mixin.bugfix.missing_block_entities

Hypixel sends chunks to the client that are missing some block entity data, which makes chests etc. appear invisible. This 'fixes' the problem by creating the needed data on the client. Has no effect for properly behaved servers or in singleplayer.

mixin.bugfix.model_data_manager_cme

Works around design flaws in the Forge ModelDataManager system that can cause unexpected concurrency issues.

mixin.bugfix.packet_leak

Experimental, not enabled by default. An attempted fix for the memory leak issue that occurs after playing long enough on 1.16.

mixin.bugfix.paper_chunk_patches

1.18 and newer. A key optimization. Ports a patch from Paper that fixes issues on 1.17 with chunkloading requiring huge amounts of memory and generating many CompletableFuture instances. 1.18+ are now able to load worlds on only 400MB of memory like 1.16 could.

mixin.bugfix.recipe_book_type_desync

Fixes Forge clients being disconnected when connecting to a vanilla server if mods add custom recipe book entry types.

mixin.bugfix.removed_dimensions

Fixes the game failing to load worlds if dimension mods are removed. Backport of Forge PR #8959.

mixin.bugfix.restore_old_dragon_movement

Fixes MC-272431, which tracks the ender dragon being unable to dive to the portal as it did in 1.13 and older. This causes the dragon to fly quite a bit differently from what modern players are used to and also patches out one-cycling, so it's not enabled by default. Thanks to Jukitsu for identifying the regression in the vanilla code.

mixin.bugfix.unsafe_modded_shape_caches

Fixes various ConcurrentModificationExceptions that can occur in content mods when computing block shapes

mixin.bugfix.world_leaks

Reduces the memory usage of old client-side worlds that aren't needed after switching dimensions. These are normally garbage collected in vanilla, but mods sometimes retain references to them.

mixin.bugfix.world_screen_skipped

Fixes MC-251068, where deleting the last world takes you back to an empty world list.

mixin.core

Core patches required for ModernFix to work

mixin.devenv

Patches used when running in a development environment, for speed improvement and/or testing

mixin.feature.blockentity_incorrect_thread

This is a debug option and should not be enabled for regular gameplay. Attempts to detect mods interacting with block entities on the wrong thread and crash the game with more information, rather than an unclear ConcurrentModificationException

mixin.feature.branding

Adds ModernFix to the branding list on the title screen, and also to the F3 screen.

mixin.feature.cause_lag_by_disabling_threads

Disables the game's use of worker threads for the server and for chunk rendering. This will make performance worse on almost all hardware, and should only be enabled on a client, when you know exactly what you are doing, and probably only on hardware with very few (2 or less) physical CPU cores. In those rare cases, it can reduce lag spikes since there is less contention over the limited cores.

mixin.feature.direct_stack_trace

Normally off, can be enabled to force the raw stack trace to be dumped to the log when a crash occurs. Occasionally vanilla's crash report system fails to work properly and gives an entirely irrelevant stack trace/report.

mixin.feature.disable_unihex_font

Remove the Unicode font, saves 10MB but causes special characters to no longer render

mixin.feature.integrated_server_watchdog

Adds the vanilla watchdog to singleplayer worlds as well, but just prints out the stacktraces rather than forcefully terminating the world. This version includes the functionality of Fullstack Watchdog, but the latter is still needed for multiplayer.

mixin.feature.measure_time

Uses a couple injections to measure world load time, datapack reload time, resource reload time, bootstrap time, and adds the necessary hooks to enable vanilla's unused profiler logic for resource reloading if so configured.

mixin.feature.registry_event_progress

Runs the Forge loading screen on a background thread for part of the loading process, to allow progress to be shown while content is being registered. May have compatibility issues with some GPU drivers (e.g. macOS), so do not enable it by default in a modpack.

mixin.feature.remove_chat_signing

Prevents the Minecraft client from obtaining the keypair for chat signing. This disables the client's ability to sign chat messages (like No Chat Reports, but in a simpler, albeit less user-friendly way).

mixin.feature.remove_telemetry

Prevents the Minecraft client from sending telemetry to Mojang. The telemetry is generally not relevant to them anyway for a modded instance.

mixin.feature.snapshot_easter_egg

Adds easter egg features (does not affect any vanilla visuals or behavior) when running on a snapshot version.

mixin.feature.spam_thread_dump

To be used for debugging purposes only. Causes a thread dump to be output to the log every 60 seconds. This can help to diagnose unexplained freezes during loading/gameplay.

mixin.feature.spark_profile_launch

If enabled, and a compatible version of Spark is installed, the entire launch sequence will be profiled until the main menu.

mixin.feature.stalled_chunk_load_detection

This option may help to detect the cause of chunkloading freezes. However, leaving it enabled may cause slightly worse performance.

mixin.feature.warn_missing_perf_mods

Shows a warning on startup if other performance mods considered essential and highly compatible are not present

mixin.perf.blast_search_trees

All versions. If REI or JEI are installed, construction of the vanilla search trees for creative searching is disabled, and searching is instead done using these mods' search implementations. This saves several seconds during world loading, and probably also saves some RAM as well (although I have not measured).

mixin.perf.cache_blockstate_cache_arrays

All versions. Avoids creating fresh copies of enum arrays each time a blockstate cache is initialized. Minor optimization, but easy to do.

mixin.perf.cache_model_materials

All versions. Memoizes the RenderMaterial (texture) collection and dependency list that models return instead of requiring them to be recalculated on each request. Helps accelerate the model load/bake process.

mixin.perf.cache_profile_texture_url

Avoids pointlessly creating a URL object and speeds up skull block rendering.

mixin.perf.cache_strongholds

All versions. Saves the generated list of stronghold positions with the world, instead of regenerating it on every world load. Saves a little bit of time on 1.16, and quite a bit more on 1.18 and 1.19.

mixin.perf.cache_upgraded_structures

All versions. Many mods ship outdated structure files, which requires the game to upgrade them using DFU every single time they are loaded. This can be quite slow. This patch adds logic to instead save the upgraded version of the structure, and reuse it on the next load. To handle the case that the mod changes a structure file but not the name, the original file's hash is compared against the cached version, and if they do not match the structure will be upgraded again.

mixin.perf.chunk_meshing

Implements some minor optimizations to the vanilla chunk meshing logic (they will have no effect with a mod that replaces chunk rendering entirely).

mixin.perf.clear_fabric_mapping_tables

Reduces memory usage by clearing mapping data structures in Fabric Loader that are either redundant or rarely used by mods. Off by default for compatibility reasons.

mixin.perf.clear_mixin_classinfo

Force-loads all mixins when launch finishes and then clears out mixin data structures to remove most of Mixin's memory footprint. Disabled by default for compatibility reasons.

mixin.perf.compact_bit_storage

Fixes memory waste caused by some legacy servers (e.g. Hypixel) sending empty chunks as if they contain blocks. Reduces memory usage significantly on these servers.

mixin.perf.compact_mojang_registries

(Fabric) Experimental option that reduces the memory usage of registries by roughly 50%. Not useful in most modpacks unless they contain millions of blocks and items.

mixin.perf.datapack_reload_exceptions

All versions. Reduces log spam and possibly slightly improves loading speed by not printing the stacktraces for some commonly thrown exceptions during datapack reload (e.g. missing items in loot tables/recipes). The message is still printed.

mixin.perf.dedicated_reload_executor

All versions. Moves resource pack and data pack reloading to a dedicated worker pool instead of using the default Worker-Main threads. This allows mods to Smooth Boot to still potentially improve singleplayer performance at runtime while not slowing down launch due to a limited thread count.

mixin.perf.deduplicate_climate_parameters

Deduplicates climate parameter objects used by the new biome system, can save ~2MB but also slows down datapack reload somewhat.

mixin.perf.deduplicate_location

All versions, but disabled by default due to load time impact. Deduplicates resource location namespaces and paths. This saves RAM but also increases the cost of constructing a new ResourceLocation by quite a bit.

mixin.perf.deduplicate_wall_shapes

Makes most wall blocks share the same shape object instead of each one having its own copy. Can reduce memory usage substantially when lots of wall blocks are added by mods.

mixin.perf.dynamic_dfu

All versions. Modifies DFU initialization to happen the first time something needs to be upgraded. This sounds similar to LazyDFU but is distinctly implemented, as it avoids loading any DFU classes/data structures, while LazyDFU only disables rule optimization. Essentially, this option is a safer version of DataFixerSlayer as it will still load DFU when needed.

You should typically continue to use LazyDFU even with this option enabled, as otherwise DFU rule optimization will cause lag.

mixin.perf.dynamic_entity_renderers

Constructs entity models the first time they are seen instead of during launch. Some mods are not compatible with this option and will cause EntityRenderer crashes.

mixin.perf.dynamic_resources

All versions. See https://github.com/embeddedt/ModernFix/wiki/Dynamic-Resources-FAQ.

mixin.perf.dynamic_resources.ctm

CTM compatibility patch for dynamic resources

mixin.perf.dynamic_resources.ldlib

LDLib compatibility patch for dynamic resources

mixin.perf.dynamic_resources.supermartijncore

SuperMartijn642CoreLib compatibility patch for dynamic resources

mixin.perf.dynamic_sounds

All versions. Allows the game to unload sounds, instead of sounds indefinitely persisting after being loaded.

mixin.perf.dynamic_structure_manager

All versions. Allows the game to unload structure files after generation concludes instead of keeping them loaded forever.

mixin.perf.fast_forge_dummies

Speeds up Forge registry freezing during launch by using a faster code path

mixin.perf.fast_registry_validation

All versions. Forge needlessly looks up a method via reflection every single time a registry is validated. This patch simply caches the returned value since it will be the same every time.

mixin.perf.faster_command_suggestions

Mitigate lag when there are hundreds of thousands of suggestions while typing a command

mixin.perf.faster_item_rendering

All versions. Avoids rendering the sides of items in GUIs. (Yes, vanilla appears to do that.)

This can triple FPS with a mod like REI/JEI installed on weaker GPUs, if enough items are visible. Disabled by default since it's new and not tested much, but should be safe. The most likely issue is items being completely invisible in GUIs, or appearing flat in the world.

mixin.perf.faster_structure_location

Improves the speed at which structures like buried treasure can be located.

mixin.perf.faster_texture_stitching

All versions. Enables the game to use a faster texture stitching system originally written by SuperCoder79 for lwjgl3ify on 1.7.10, which can save some time during loading. Rarely, it's been reported to cause weird artifacts on blocks or in GUIs, this may be a Sodium bug.

mixin.perf.fix_loop_spin_waiting

Fixes Minecraft's built-in wait function consuming excessive amounts of CPU resources.

mixin.perf.forge_cap_retrieval

Small micro-optimization that makes retrieving custom entity data slightly more efficient on Forge.

mixin.perf.forge_registry_alloc

Fixes more oversights in Forge that lead to excessive allocation in hot registry methods.

mixin.perf.forge_registry_lambda

Fixes oversights in Forge that lead to excessive allocation in hot registry methods.

mixin.perf.kubejs

1.16 only. Optimizations to KubeJS to avoid needless ItemStack copying, etc., which reduces the time taken to load datapacks.

mixin.perf.memoize_creative_tab_build

Improves on vanilla's existing caching for creative tab contents in a way that is compatible with the timing requirements of mods like JEI/EMI. This can reduce the lag spike when opening the creative inventory for the first time in a modpack.

mixin.perf.model_optimizations

All versions. Implements optimizations to speed up the model loading process.

mixin.perf.mojang_registry_size

Fixes an issue causing registration of blocks/items to slow down proportional to the number already registered. This improves startup time.

mixin.perf.nbt_memory_usage

All versions. Uses a more efficient backing map for compound NBT tags that deduplicates key names and also uses an array map for very small compounds. This reduces the overhead of storing many compound tags in memory.

mixin.perf.patchouli_deduplicate_books

Fix Patchouli books storing many empty items with NBT tags, reducing memory usage.

mixin.perf.potential_spawns_alloc

Optimizes the Forge event for finding potential mobs that can spawn. This reduces allocations and the overhead of rebuilding a weighted list when no mods modify the potential spawns.

mixin.perf.reduce_blockstate_cache_rebuilds

All versions. A key optimization. Newer Minecraft versions (after 1.12) implemented a blockstate cache system that caches frequently used information about a blockstate, such as whether it is solid, its collision shape, etc. Rebuilding this cache is quite fast in vanilla (it takes only a second or two) but is quite slow with many mods installed, as there are many more blockstates present in the game which all must have their caches rebuilt.

This problem is exacerbated by Forge as the cache is rebuilt at many points when the data would almost certainly be unused before the next rebuild. Examples include right before reaching the main menu (during the "Freezing data" stage), as well as multiple (!) times when a world is being loaded.

ModernFix solves this performance bottleneck by instead making cache rebuilds lazy. Each blockstate rebuilds its cache the first time the data would be accessed. At any point when vanilla or Forge would attempt to rebuild caches for all blockstates, this is redirected to simply invalidate the cache on each blockstate instead.

This should not have any impact on TPS after startup concludes.

mixin.perf.remove_biome_temperature_cache

All versions. Removes the biome temperature cache as Lithium does on modern versions.

mixin.perf.remove_spawn_chunks

Completely removes spawn chunks from the game. They are no longer loaded at all, unlike Ksyxis.

mixin.perf.resourcepacks

All versions. A key optimization. Launches on modern versions are heavily bottlenecked by filesystem access. Many requests are frequently made to resource packs to list resources or check if a given resource exists, and each of these result in a very slow file API call.

ModernFix completely eliminates most of the bottleneck here by simply caching a listing of all resources that exist within mod-provided and vanilla resourcepacks. The cache is rebuilt on resource reload (except for the vanilla resources, since they should never change while the game is running).

There are no known compatibility issues with this patch except for OptiFine (its CTM resources do not load correctly). However I do not recommend using OptiFine in any scenario, as it adds several minutes to launch time by itself and is not tested with ModernFix at all.

mixin.perf.state_definition_construct

All versions. Enabled only if FerriteCore is installed. Takes advantage of FerriteCore's handling of blockstates to speed up their creation. This can help speed up launch with mods that add lots of blockstates, such as furniture mods.

mixin.perf.tag_id_caching

Speeds up uses of tag entries by caching the location object instead of recreating it every time

mixin.perf.thread_priorities

All versions. Adjusts the worker and server thread priorities to be lower than the client thread. This helps improve FPS stability on machines with few CPU cores, provided that the Java implementation in use respects priorities.

mixin.perf.ticking_chunk_alloc

Optimizes chunk ticking in vanilla to reduce allocations.

mixin.perf.worldgen_allocation

Optimizes some world generation logic in vanilla to reduce object allocations.

mixin.safety

Concurrency patches to prevent crashes during launch