Collections Of Optimizations: Project Infinity 0.1 config options

Memoise Ad Astra's per-dimension gravity and temperature constants.

Look for screen shaking mobs once per tick instead of once per frame.

Answer Alex's Caves' duplicate climate sample from a one entry cache.

Stop recomputing Alex's Caves' cave biome placement 96 times per column.

Release the level keyed maps Alex's Mobs never clears, when a server stops.

Stop attaching the snow leopard and tiger avoidance goals to every creeper.

How often a vanilla spider may scan for Alex's Mobs flies, in goal evaluations.

Work out whether a biome matches a region's biome patterns once instead of running the regex every client tick. Client.

Stop wall lanterns broadcasting a sway packet every tick for entities that are not moving.

Stop rebuilding the equivalency sigil's block outline every single frame.

Stop Armageddon's progression gate from re-parsing the same identifiers every tick.

Skip Armageddon's entity animation handler for entities that are not Armageddon's.

Reuse the baked model parts an armour item builds for itself instead of baking them again on every call. Eighty six armour items in this pack build a whole model from scratch each time the game asks what model they use, and asking happens several times a frame per worn piece. With asynchronous model loading installed each of those bakes parks the render thread until a worker finishes. The reuse is limited to models built inside an armour model lookup and is dropped on a resource reload. Client.

Remember the edge list of a block outline shape instead of walking the shape again every frame. The walk is the same work for the same block and the game repeats it once per frame for whatever you are looking at, which at a few hundred frames a second is a few hundred identical walks a second. The drawing itself is unchanged. Client.

Make the curio pouch keybind work. Ars Elemental registers the key but its handler is a non static method on the mod event bus, so the game never calls it. Client.

Only give the 50 percent healing bonus to a player actually holding an earth focus. Stock code reads the focus toggle with an or instead of an and, so while "Enable glyph empowering" is on every heal of every living entity in the world is multiplied by 1.5.

Build the throwaway empty curio result only when the curio inventory is actually missing, instead of on every focus and bangle lookup.

Skip the per-attack bangle curio walk when the cached curio set already proves neither side is wearing a school bangle.

Check for sonic boom damage before reading the mirror enchantment level and rolling for a reflect, instead of after.

Stop attaching the SOURCE_TILE wrapper to block entities that cannot back it.

Stop registering a capability listener that can never be observed.

Ticks between refreshes of the offscreen sky texture, which costs a second full sky, cloud and weather pass plus a fog event post every frame. 1 refreshes once a tick, 0 restores the stock every frame behaviour. Client.

Skip the kitty slippers curios scan when the entity has no last-hurt-by mob.

Skip the charm of sinking curios scan when the umbrella glide check cannot pass anyway.

Skip the client-side Artifacts living tick for non-player entities.

Remember which config file belongs to each Balm config class instead of working it out again on every read. Every Balm mod reads its settings through getActive, and each of those reads asks the JVM for the class annotation, builds a brand new ResourceLocation out of the same two strings, validating both character by character, and allocates a lambda before it even looks in the map that already holds the answer. Waystones does that twice per waystone per frame from its block renderer and Cooking for Blockheads does it up to a dozen times per oven per tick, so it adds up across a pack. With this on the identifier is worked out once per class and the config object is looked up straight out of Balm's own map, and only if it is missing there does the stock path run. Turn it off for stock behaviour.

Stop rebuilding a block state's toString on every quad request.

Cache WeaponRegistry#getAttributes per item. Stock does a registry reverse lookup plus a map get on every Player#getItemBySlot call, twice.

Hand Biolith the registries at the start of WorldStem instead of the end. BCLib asks every vanilla biome source for its biome list from inside that constructor, which is before Biolith has a registry to look biomes up in, and Biolith throws.

Re-tag the biome source with its dimension after another mod swaps it. MCreator biome mods replace the overworld MultiNoiseBiomeSource on ServerAboutToStart, and the replacement never passes through LevelStem, so Biolith loses track of which dimension it is and silently stops applying every biome replacement and sub-biome it was asked for.

Return Biolith's cached biome list without entering its lock. Biolith synchronizes on the biome source on every single biome lookup, and world generation runs those lookups on several threads at once.

Remember the dimension key string the spatial store is indexed by. Biomancy builds it with ResourceLocation.toString on every query, which concatenates the namespace and the path into a brand new String each time, and that string is then used only as a map key. It is now built once per dimension and reused, and the value is character for character the one the stock code produced.

Remember the spatial database handle instead of looking it up again for every query. Biomancy resolves it by asking the server for the world folder, resolving the data directory, resolving the database file name, turning that into a File and then into a String, and handing the result plus two freshly allocated lambdas to the dimension data storage, and it does all of that on every single spawn check and every membrane spread tick. The answer is one object that lives for as long as the server does, so it is now worked out once per server and reused, and it is dropped when Biomancy closes the store on world unload so a second world in the same session gets its own.

Skip Biomancy's mob spawn filter entirely in a world that has none of its shapes in it. Biomancy keeps the volumes that block mob spawning, the primordial mound and anything else that claims an area, in an embedded H2 MVStore database rather than in memory, and it asks that database on the position check event, which the game fires for every single natural spawn attempt: every pack of every group in every eligible chunk around every player, several hundred to a few thousand times a second on a populated server. Every one of those questions rebuilt the path to the database file, allocated two Path objects, a File and a String out of it, allocated the two lambdas the saved data lookup takes, turned the dimension key back into a fresh String, built a query box object and then ran a real R-tree cursor over the store, all to find out that the world contains no shapes at all, which is true of every world where nobody has built a primordial cradle yet. With this on the shape map for the dimension is remembered the first time Biomancy opens it, which is the same live map object the mod itself writes into, and the whole handler is skipped while that map is empty. The moment a cradle or a mound registers a shape the map stops being empty and the check goes back to running exactly as it did, with no delay, because it is the mod's own map being read and not a copy.

Skip the Crag Gardens and Basalt Barrera terrain passes in chunks that contain neither biome. Both passes run on every chunk generated in every dimension and build four noise generators, two weighted state providers and 512 biome lookups before they ever check whether the biome is present.

Filter the retro-gen chunk sweep through each section's block state palette.

Give the ARC's furnace mode the recipe cache vanilla furnaces already have.

Stop rebuilding the whole ARC recipe list on every tick of every ARC.

Give the item routing network's connectivity search a visited set that is actually a set.

Skip the levitation block flight check while no levitation block is loaded. The mod runs this off the player tick event for every player on the server, and it is not cheap: it allocates a list, fills it with nine block positions, streams that into a set of chunk positions through a lambda, then streams the set again and for each chunk resolves the level capability into an Optional and asks it for a list of levitation blocks, allocating a result list every time. That is roughly sixty short lived objects per player per tick, on the tick thread, in a world where the Obsidilith arena that contains those blocks may not even be generated yet. With this on a player who cannot already fly and is nowhere near a tracked levitation block skips the whole thing. Players who can fly, which includes creative and spectator and anyone the block has already granted flight to, always run the stock code, so flight is still taken back correctly when you walk out of the beam. One call in four thousand runs the real check regardless so the tracker cannot drift.

Skip the monolith explosion scan while no monolith is loaded. Every explosion in the world, from any mod or any creeper, goes through the mod's hook that asks whether a monolith is standing within sixty four blocks so it can boost the blast, and that question is answered by the same nine by nine chunk walk the mob ward uses, with a fresh chunk position and a fresh result list for each of the eighty one chunks. Monoliths only exist in the Obsidilith arena, so in an ordinary world every single explosion pays for a hundred and sixty odd throwaway objects to be told no. This uses the same position tracker as the ward patch and returns the unmodified blast power straight away while no monolith is loaded, with the same one in four thousand real scan as a safety net.

Skip the mob ward proximity scan while no mob ward is loaded. Bosses of Mass Destruction hooks the natural spawner so a mob ward blocks spawning around it, and the check it runs there is the most expensive thing in the mod: for every spawn position the game accepts, anywhere in the world, it builds a chunk position, resolves a capability off the level into an Optional, allocates a closure, and then walks a nine by nine block of chunks around that position, allocating a fresh chunk position and a fresh result list for each one of the eighty one, just to learn that not one of them holds a ward. The game asks that question hundreds to thousands of times a second on a loaded server, so on a world with no wards in it this alone is tens of thousands of throwaway objects a second on the tick thread. This patch keeps track of every position the mod itself puts into that cache and every position it takes back out, and returns straight away when there is no ward anywhere, which is the same answer the scan would have arrived at. So the guard cannot go stale if a future version of the mod changes how positions get in, one call in every four thousand runs the real scan anyway and anything it finds is folded back into the tracker, which turns the guard off within a second of a ward actually existing.

Run the mod's player tick handler once a tick instead of twice. Forge fires the player tick event twice per tick, once before the player ticks and once after, and this handler never checks which of the two it is in, so everything behind it runs double: the capability lookup and the closure it allocates for every player every tick, the levitation block flight check, and the movement history the Lich reads to lead its shots. That last one is the visible part, since the history only holds ten samples and at two samples a tick it covers five ticks of movement rather than the ten the mod is written for, which makes the Lich's aim read your position over a shorter window than intended. With this on only the end of the tick runs. Turn it off if you want the stock double firing back.

Narrow the four Born in Chaos minion claim scans to the mod's own entities.

Skip Born in Chaos' entity animation handler for entities that are not its own.

Bail out of Born in Chaos' held item animation handler before it copies your hands.

Stop 83 Born in Chaos mobs from resizing themselves once per tick for no reason.

Walk only Bosses' Rises entities in the per frame boss VFX pass instead of every entity in the level.

Only collect Bosses' Rises entities in its per player cinematic scan.

Run the boss bar bookkeeping once per client tick for the local player instead of twice for every player entity the client is ticking. The handler has no phase check so it counts the start and the end of the same tick, and it fires for remote players too, which also means another player looking at a boss is what keeps your own boss bar alive. Turn off for stock behaviour.

Only hand the boss capability to living entities. Brutal Bosses attaches a fresh BossCapability plus a LazyOptional to every single entity the client builds, arrows and dropped items and experience orbs included, which also forces Forge to build a capability dispatcher for entities that would otherwise have none, and on the server it runs a reverse registry lookup per spawn to decide. Only living entities can ever be a boss, so everything else is pure allocation.

Answer 'is this entity wearing a full Noir set' from the chest slot before walking the armour iterator. The renderer asks it twice per living entity per frame and the mob visibility event asks it again for every entity a mob can see, and almost every answer is no.

Only let Brutality's tick counters advance once per game tick. Both ServerTickHandler and ClientTickHandler subscribe without a phase check, so they count the START and the END of the same tick and every duration measured off getServerTick runs at double speed, and the tick sync packet is broadcast to every player every ten ticks instead of every twenty. Fixing it makes those durations twice as long as you are used to, because that is what the mod meant them to be.

Only look for a nearby black hole, ruined king and explosion ray every this many client ticks. Stock walks every entity the client has loaded three separate times every single client tick just to decide the sky and fog colour, and the third walk is not behind a config toggle at all. Colours can settle up to interval minus one ticks late. Set to 1 for stock behaviour.

Answer a facade lookup with a single flag read while no facade has been placed in the loaded world. Cable Facades queries this map from seven hooks in the hottest vanilla block methods, so it runs for every block of every chunk rebuild and every light update. Client.

Skip the flight attribute lookup for non-player entities that are not already fall-flying.

Answer the is this accessory worn question out of the equipped curio set the patch mod already keeps per entity per tick. Caster Curios Bonus has one shared helper for this and nine of its twelve trinkets call it: the mana overflow hat alone asks four times, once on cast, once when anything asks a spell's level, once on spell damage and once on spell healing, and the night hunter ring asks it for every single mob that dies to a player anywhere in the world while the void snare necklace asks again for that same mob's drops. Each of those questions resolves the curios capability off the entity, unwraps a lazy optional into a real Optional, maps it through a lambda into a second Optional, boxes the answer into a Boolean, and behind all of that walks every slot of every curio type the player has looking for one item and building a slot result object the moment it finds it. A player fighting with a multi target spell pays that whole walk once per entity hit, per listener. The set of items a player is actually wearing is already worked out once per entity per tick by this mod and thrown away when curios reports an equip, unequip or change, so the answer now comes out of a set lookup and the walk only happens when the cache cannot say, which is exactly the cases where the stock code ran anyway.

Give each wearer their own refresh schedule instead of one counter shared by everyone. Both the cooldown charm and the mana to health necklace only want to redo their attribute maths every twenty and every ten ticks, and both keep the countdown in a field on the item. Items in Minecraft exist exactly once, so that field is not per player, it is per server: with three people wearing the same charm the counter is bumped three times a tick, whoever's tick happens to push it over the line does the work and resets it to zero, and the other two are simply skipped until their turn comes round again. The result is that the refresh rate speeds up as more people wear it while any one player's bonus can go stale for twice as long as it should, and on a server where players join and leave the rotation is not even stable. With this on the countdown is read off the wearer's own tick counter, spread out by entity id so everyone does not land on the same tick, so every wearer gets refreshed on exactly the interval the mod asks for no matter how many other people are wearing one. The item's own counter is left alone and the work done on a refresh is identical.

Stop the mana to health necklace running on the client. Curios ticks a worn trinket on both logical sides, and this one never checks which side it is on, which its sibling the cooldown charm does. So on the client it walks the same path as the server: an attribute lookup for max health, a modifier removal, an attribute lookup for max mana, a full recompute of that attribute's value through every modifier your gear puts on it, a config read, a fresh modifier object and finally a permanent modifier put back on the client's own copy of the player, which the server then overwrites with the real value a moment later anyway. Worse, the counter the necklace uses to only do this every ten ticks is a plain field on the item, and an item exists once for the whole game, so in single player the client thread and the server thread are both incrementing the same counter with no synchronisation and the refresh ends up firing about twice as often as the mod intended. With this on the client side of the tick returns immediately, the server keeps applying the bonus and keeps syncing it down exactly as before, and the health bonus you see is unchanged.

Run the camera shake entity scan once per tick instead of once per frame. Client.

Check the block the item is lying on before running the transformation recipe lookup. Celestial Core hooks the tick of every item entity in the world and, on the server, builds a nine slot container and runs a full recipe manager lookup for its transformation recipe type on every single one of them on every single tick, and only after that does it look at whether the item is even lying on the block the recipe wants. The container, the stream the lookup builds and the position list are all thrown away again immediately, so a floor covered in dropped loot is thousands of allocations a second to almost always find nothing. With this on the two block states under the item are read first, exactly the two the mod itself reads, and the lookup only happens when one of them is a block some transformation recipe actually asks for. If the recipe list cannot be read the stock lookup is left alone.

Pick the transformation recipe whose block the item is actually lying on. The recipe's own matches check returns true for everything, so the lookup hands back whichever recipe happens to come first in the map and the mod then throws it away when its block does not match, which means only one transformation recipe in the whole pack can ever fire and any others added by a datapack or KubeJS silently never work. With this on the recipes that ask for a different block are skipped during that one lookup, so the right one is found. Celestial Core itself ships a single transformation recipe, so nothing changes unless more have been added. Requires leanItemTransformScan.

Skip the per slot enchantment map allocation for equipment slots that hold nothing enchanted.

Skip the seven map, two array clone enchantment scan for living entities that have nothing enchanted equipped.

Hand back the Celestisynth entity capability out of a field on the entity instead of walking the capability dispatcher on every question. Every living entity in the game carries this capability, and the mod asks for it from isInvisible, isInvisibleTo, the living tick listener, the entity renderer, the living entity renderer and the render layer hook, so a single mob pays for it several times per tick on both sides and several more times per frame while it is on screen. Each of those asks walked every capability provider attached to the entity, which in a large modpack is dozens of them. The cached handle is dropped and looked up again whenever it stops being valid, so entities that are removed, revived or have their capabilities reattached still get the live one.

Sit out this many goal ticks after a cactem finds that an elder is already nearby. Every adult non elder cactem carries a goal whose only job is to promote it to elder when no elder is around, and it decides that by asking the world for every cactem inside a sixty five by thirty three by sixty five block box, ten times a second, forever. That box is roughly a hundred and forty thousand blocks of entity sections walked and type tested, and in a village, where an elder is always nearby, the answer is the same every single time. With this on a sweep that finds an elder is not repeated for this many goal ticks. A cactem whose elder has just died can take up to two seconds longer to promote itself. The sweep is never throttled when it comes back empty, so nothing delays the promotion itself. Set to 1 for stock behaviour.

Sit out this many goal ticks after a cactem fails to find an elder to follow. Every cactem that is not itself an elder carries a follow goal, and that goal answers the question by asking the world for every cactem inside a sixty five by nine by sixty five block box, ten times a second, for as long as the cactem is alive. It then refuses to follow anything closer than twenty blocks, which is exactly where cactems stand in the villages they spawn in, so in the normal case the sweep runs, finds the elder, decides it is too close, and throws the whole answer away a tenth of a second later, forever. With this on a sweep that does not produce something to walk to is not repeated for this many goal ticks, and the moment it does produce one the throttle clears, so following is unchanged once it starts. A cactem can take up to a second longer to start walking after an elder that has just moved away. Set to 1 for stock behaviour.

Reuse the cactem elder's heal search for this many calls instead of redoing it every time. The heal goal asks the world for every cactem inside a thirty three by nine by thirty three block box to find out whether anyone nearby is below half health, and it asks from three places: the goal's own start check, its continue check, which just calls the start check again, and its tick. That is several sweeps per elder per tick while the goal is running and two per elder every goal tick while it is not. With this on the list of nearby cactems is remembered for this many calls and every health reading is still taken live off those cactems, so who gets healed does not change; the list is thrown away and rebuilt early if any cactem in it has been removed. A cactem that walks into range hurt can take up to a second longer to be seen. Set to 1 for stock behaviour.

Sit out this many goal ticks after a cactem elder finds nothing to trade for. The trade goal asks the world for every dropped item entity inside a thirty three by seven by thirty three block box ten times a second per elder, and then throws away everything that is not a cactus, which on a normal world is every item or, far more often, an empty list. With this on a search that comes back with nothing to walk to is not repeated for this many goal ticks. A cactus you throw down in front of an elder can take up to a second longer to be noticed, and once the elder is on its way nothing is throttled. Set to 1 for stock behaviour.

Do not write cactem synced entity data from the render thread. The cactem's GeckoLib animation predicates run once per cactem per frame on the client, and two of them write synced entity data while they are there: the main one rolls a fresh random number and stores a new idle animation index every frame the cactem is walking, and the attack one stores the spear visibility flag every frame the cactem is not throwing. Synced entity data is owned by the server, so neither write ever reaches anyone; they just take the data lock, fire the update callback and mark the entity dirty once per frame per cactem, and the spear flag is not even read anywhere, since the getter behind it returns a hardcoded true. With this on both writes are skipped on the client and left alone on the server, where the idle index is still picked once when the cactem spawns. The only visible difference is that a cactem keeps the idle animation it was given instead of re-rolling it every frame while it walks. Turn it off for stock behaviour.

Sit out this many goal ticks after a friendly sporeling finds nothing to convert. Every friendly sporeling carries a goal that asks the world for every dropped item entity inside a thirty three by seven by thirty three block box, ten times a second, for the whole life of the sporeling, and then keeps only rotten flesh and cursed gear, which is almost never on the floor anywhere near it. Sporelings spawn in groups, so a mushroom field or a nether forest runs that sweep dozens of times a second to produce nothing. With this on a search that finds nothing is not repeated for this many goal ticks, and a search that finds something is not throttled at all. An item you drop next to a sporeling can take up to a second longer to be picked up. Set to 1 for stock behaviour.

Look for a nearby wechuge once per client tick instead of four times per rendered frame. The fog colour and fog distance handlers each run two entity scans every frame just to ask whether one is close by.

Only let those twenty seven handlers run every this many ticks on the server. Stock runs all of them every tick for every player forever, including long after every animal has been met. A toast can appear up to interval minus one ticks later than stock. Set to 1 for stock behaviour.

Keep the Sobbing screen shader to your own player and to shaders Critters n' Crawlers loaded. Stock reacts to every player it ticks and tears down whatever post effect happens to be running, whether or not the mod put it there.

Only run the caribou trample check while a caribou is actually loaded. Stock builds a box, an entity scan, a comparator and a sorted stream for every living entity in the world every tick, whether or not the mod's caribou exists.

Only let the sasquatch decide whether to wear its hidden texture every this many ticks. Stock runs two sixteen block player scans per sasquatch per tick to make that call. Set to 1 for stock behaviour.

Skip the twenty seven 'have you met this animal yet' player tick handlers on the client. Each one scans a four block box for its own mob and walks your whole inventory before it looks at the flag it is trying to set, and the client copy of that flag is overwritten by the server sync anyway.

Skip the sasquatch wood knock handler on the client, where its two hundred and sixteen block reads per sasquatch per tick can only end in a sound the client never plays.

Skip the mod's twenty eight way instanceof chain for entities that are not its own.

Stop the mod's twenty eight mobs from resizing themselves once per tick for no reason. Their hitbox only ever changes with baby state, which the game already refreshes on its own.

Remember which entity classes have a translucent renderer so the per-frame entity walk skips the renderer lookup for the rest.

Remember which block each infecting recipe turns into instead of rescanning the recipe list for it. The lookup copies the whole list of infecting recipes on every single call and then walks it, building a throwaway one slot container for every recipe it tests, and it is called once per neighbour block, so a spreading bibliophage setup pays it six times a second per block and almost always to find out that stone or dirt has no recipe at all. The answer only depends on which block is being asked about, so it is now remembered per block, misses included, and thrown away whenever datapacks reload or a world is joined. Adding or changing infecting recipes with a datapack reload still takes effect immediately.

Answer the fountain and obelisk player checks off the level's player list instead of a full entity box query. The experience fountain asks the level for every player inside the small box above itself on every tick on both sides just to decide whether to play its on and off sound, and the obelisk asks for every player inside its whole configured radius once a second to see whether anyone has a memory tablet linked to it; both of those walk every entity section the box touches and test every mob, item and arrow in them, while the level already keeps a list of exactly the players. The list is normally one entry, the same spectator filter and the same box test are applied to it, and nothing is allocated at all when nobody is standing there.

Stop the bibliophage spread running its whole search on the client for nothing. Every infected bookshelf and every agar block ticks on both logical sides, and once a second each of them reads its six neighbours, turns each neighbour block into a fresh item stack and asks the recipe manager for an infecting recipe that matches it, which copies the entire infecting recipe list and allocates a one slot container per recipe per neighbour. The block that would actually be placed at the end of all that refuses to place anything at all when it is handed a client level, so on the client the whole search is built and thrown away every single second for every bibliophage block in render distance. With this on the client returns straight away and the server does exactly what it did before, so a bookshelf wall costs half of what it used to and spreads at the same rate.

Check who owns the item before building its description tooltip. Cognition listens on the item tooltip event, which fires for every item in the game, and before it looks at whether the item is even one of its own it glues .description onto the item's translation key, builds a translatable component out of that, renders it down to a string through the whole language lookup and searches that string, then polls both shift keys straight off the window. All of that is thrown away for every item that is not from Cognition, which is every item in the pack but a handful, and it is paid again on every frame an item tooltip is on screen and once for every item in the game when a recipe viewer builds its tooltip search index. With this on the owning mod is checked first, which is the same check the mod itself does one line later, and everything else is unchanged for Cognition's own items.

Collapse the tesla network distance rebuilds down to at most one per server tick. Registering a tesla block, unregistering one, adding or removing a wire and indexing a dinamo all kick off a full rebuild of the whole dimension's tesla graph, and that rebuild walks every connected component, runs a breadth first search from every generator and, for each entity node it reaches, scans the entire incoming edge map to find that node's outgoing edges. Every tesla block entity registers itself the moment its chunk loads, so walking back into a base with fifty coils and pillars is fifty whole graph rebuilds in the same tick. With this on the rebuilds are marked instead of run and one rebuild happens at the end of the tick, so a chain's distance and its power cut off can be one tick behind a wire being cut or a block being placed.

Walk the owner chain for the mod's friendly fire check without allocating. Companions asks whether two entities are linked before almost every hit, every projectile impact and every target pick, and the very first thing that check does twice is build a HashSet purely to guard against a loop while walking at most a projectile to its shooter to its owner. That set is allocated and thrown away for every candidate entity of every area of effect scan on every tick. The replacement walks the same chain with a plain loop and a depth limit of thirty two, which returns the same answer including the nothing at the end of a loop.

Only remember players and the mod's own entities in the Companions entity tracker. The mod puts a weak reference into a static map for every single entity that joins a server level and takes it back out when it leaves, so every arrow, item, experience orb and vanilla mob on the whole server pays a UUID hash, an allocation and a concurrent map write on spawn and another on removal, and the map is as large as the entity count of the world. The only things ever looked back up out of it are players, dinamos, shades and the mod's own summons, so everything else is tracked for nothing. With this on the map holds just those, and any entity that is skipped is simply not in it, exactly as if it had already been removed.

Ticks between sweeps of the tesla network for block entities that no longer exist. The network only ever drops a block entity when its block is broken, so every tesla block entity that goes away with its chunk stays in the network's map for the rest of the session, holding the block entity and through it the level it belonged to, and still taking part in every distance rebuild. The sweep drops the entries whose block entity has been removed or has lost its level, which also means a tesla chain that runs through chunks nobody has loaded stops counting as connected until those chunks come back. 0 turns the sweep off.

Remember what an oven turns an item into instead of searching every smelting recipe again. When the oven screen is open the mod asks the oven for the smelting result of every item in its nine cooking slots every single frame to draw the ghost result, and each of those asks walks the whole list of furnace recipes in the game, testing every ingredient, because the oven has no idea it just answered the same question a frame ago. A hopper pushing into an oven asks the same thing per slot every time it tries. With this on each oven keeps the last sixteen answers and hands them straight back for the same item, and the memory is thrown away whenever recipes reload. Turn it off for stock behaviour.

Stop the kitchen compat lists from growing every time a world is joined or datapacks are reloaded. Cooking for Blockheads reads its compat json files, the ones that say which items are tools, water, milk, oven fuel, oven recipes, toaster recipes and which blocks connect a kitchen, from a reload listener, and that listener only ever appends: nothing is cleared first. Each world join and each /reload runs it again, so after five joins in one session every tool, water and milk item is in its list five times, every oven and toaster recipe is in its map five times, the kitchen floor is in the connector list five times and the non food list has quintupled. Those lists are walked by hand on the hot paths: every recipe book click scans the tool list per slot for a fridge with a preservation upgrade, the sink offers one slot per water entry, the recipe book overlay walks the non food list per slot per frame, and the food registry rebuild walks it per recipe. With this on an entry that is already registered is skipped and the json non food list is emptied before the files are read again, so a reload leaves the lists exactly as the first load did. Turn it off for stock behaviour.

Build a list of which items are anywhere in the kitchen once per recipe book refresh, and skip the ingredient searches that cannot succeed. Every click in the cooking table refreshes the whole recipe list on the server, and for every food recipe in the game it searches every kitchen container for every possible item of every ingredient, allocating a fresh predicate per search, with no memory between recipes. Most of those searches are for items that are nowhere in the kitchen at all. With this on the kitchen is walked once per refresh into a set of item types, and a search for an item that is not in that set is answered as not found without touching the containers, which is exactly what the search would have concluded. The set is only used for Cooking for Blockheads' own container types, which find items by walking their slots, plus the fridge whose ice unit is treated as always offering snow and ice; a kitchen containing any other kind of provider runs the stock search. Turn it off for stock behaviour.

Read the oven's facing from its block state instead of from a field that is only filled in on the server. The oven remembers which way it faces in a field that is set on the first server tick, and only for the plain oven, never for the dyed ones. The client never runs that tick, so on the client every oven claims to face north, and the renderer uses that answer to pick which neighbouring block the door handles borrow their light from. An oven set against a wall facing south therefore lights its handles from inside the wall and they render dark. With this on the facing is read straight from the block state on both sides, which is what the field was trying to mirror. Turn it off for stock behaviour.

Read the two Copycats+ client model settings at most once per second instead of twice per copycat model query.

Skip the config lookup, registry lookup and string building Copycats+ runs for every block entity and structure block that is not a copycat.

Replace the lambda and platform lookups Copycats+ runs on every Create block entity update with one cached class check.

Remember each block state's occlusion answer instead of re-running Copycats+' holder and instanceof checks on every canOcclude call.

Keep each player's armour restore queue on the player instead of in a weak keyed Guava cache. The cache is looked up twice per rendered player per frame plus twice more for the held item and the arm, and every lookup pays a hash and a segment read.

Drop the four leftover debug prints in the Melodious Harmony living tick handler. They were never removed before release and they go to System.out, which is unbuffered and synchronised, from the server tick thread for every Iron's Spellbooks summon of a player wearing the Benediction Charm, every tick. Nothing else about the handler changes.

Run the Blasphemy and Cursed Scroll attribute bookkeeping on the end phase only. Neither handler checks the tick phase at all, so both do their whole job twice per tick per player. The Blasphemy one is the expensive half: for each of the twelve spell schools it builds a ResourceLocation, looks the attribute up in the forge registry, strips its modifier and, for a player wearing the Cursed Ring, resolves and renders a translation key to compare it against the player's affinity string, all of it whether or not anything is equipped. Both handlers only remove and re add their own modifiers, so doing that once at the end of a tick leaves the same attribute values in place for the next one.

Shortest gap, in milliseconds, between Create's big outline raycasts. Create casts a fresh ray from your eye to your reach limit on every frame drawn, so above a hundred frames a second it casts far more often than the outline can visibly change. Skipped frames keep the previous target, which also feeds block breaking and placing, so a value here is how stale that target may get. Vanilla only recalculates it every 50. 0 casts on every frame.

Read each block position at most once per big outline pick. Stock tests a 3x3x3 neighbourhood at every raycast step, so neighbouring steps re-read the same positions.

Look up Create's goggles check once instead of once per frame. Create: Solar reflects for a method that this Create version does not have, so every single frame it builds and throws a NoSuchMethodException, fills in its stack trace and gives up. The overlay it was going to draw is dead either way, this just stops it costing anything.

Only let an empty handed otter or leaf insect look for dropped food every this many ticks. Each one runs a twenty four block wide item entity scan every tick while it has nothing in hand. A critter can notice a dropped item up to interval minus one ticks later than stock, and a critter that already found food keeps scanning every tick so its goal does not stop early. Set to 1 for stock behaviour.

Read a critter behaviour straight out of its map instead of wrapping it in two Optionals, and skip the behaviour walk entirely when a mob has none. Critters and Companions attaches a behaviour map to every entity in the game and walks it from Mob tick, Mob aiStep and LivingEntity travel, and its models ask for a behaviour by class every frame. Result is identical.

Only run the red panda flee scan while a red panda is actually loaded. Critters and Companions bolts a priority minus one avoid goal onto bees, endermen, iron golems, llamas, polar bears, spiders, vexes and wolves, and the goal selector asks that goal whether it wants to start every other tick, which is a thirty three by eight by thirty three entity scan plus a fresh box and list per mob forever. Result is identical because a world with no red panda in it cannot contain the red panda the scan is looking for.

Only look for the three nearby koi fish that grant Luck every this many ticks. Stock runs a twenty block wide koi scan for every player every server tick, and the Luck it hands out already lasts two hundred and ten ticks, so the effect timer just ticks down a little between refreshes. Set to 1 for stock behaviour.

Work out which pearl necklace you are wearing once per player per tick instead of once per question. The lookup builds six chained streams over your thirty six inventory slots plus every curios slot, and every drowned and guardian that considers you as a target asks it again, so a dozen of them was a dozen full walks. A necklace swapped mid tick reads stale until the next tick.

Return from the silk leash renderer before it opens an iterator over an empty leash list. Critters and Companions calls it at the end of every living entity render and every geckolib entity render, so on a modded pack that is one throwaway iterator per visible mob per frame.

Remember which item a tag resolved to instead of re-reading config/cucumber-tags.json off disk. Cucumber only caches a tag once the file has been parsed successfully, so every tag it has not seen yet costs a file open plus a full Gson parse, and a malformed cucumber-tags.json makes that miss permanent: every ShapedTagRecipe in the recipe sync packet re-reads the broken file and logs a full stack trace, on the netty thread, once per player join. The memo is dropped whenever Cucumber rebuilds its own tag map, so it lives exactly as long as stock's. Result is identical.

Ask whether an item has any tags instead of building the full lists, when you are not holding CTRL. With advanced tooltips on, stock collects every block tag, every item tag and every fluid tag, running a fluid handler capability lookup and a sorted distinct pass over them, once per hovered item per frame, and then throws all of it away to print 'Hold CTRL for tags'. Result is identical.

Look for a player within sixty four blocks before serialising a block entity, not after. Cucumber's dispatch helper writes the whole tile, inventory NBT and all, into a fresh update packet and only then asks whether anyone is close enough to receive it, and every Mystical Agriculture machine calls it at the end of every tick it changed, which for a running machine is every tick. Also swaps the Math.hypot distance test for the squared distance. Result is identical.

Cache the per-entity curio slot lookup on the entity itself.

Answer 'this entity is not wearing that item' from a per-tick set instead of a full curios inventory walk.

Answer ICuriosItemHandler#findFirstCurio(Item) from the same per-tick set instead of walking every slot handler.

Hand out one reusable unmodifiable view of an entity's curio slot map instead of wrapping the map again on every single call.

Skip the client-side curios tick for non-player entities.

Never attach the Curios render layer to non-player entity renderers.

Skip the per-tick curios handler for entity types that have no curio slots at all.

Stop each boss minion being added to the world twice. The minion summon loop has its whole setup block pasted twice, so every minion the doppelganger summons gets addFreshEntity called on it a second time. The entity manager rejects the second add because it already knows that UUID, but not before Forge has fired EntityJoinLevelEvent for that entity again, so every mod listening on that event, difficulty scalers and trait appliers among them, sees the same minion join twice and can apply itself twice, and the server logs a warning for each one. With this on the second add is skipped and the minion joins once, which is what the first add already did.

Stop the mod flattening every boss bar's name into a fresh string on every frame. Dark Doppelganger subscribes to the boss bar customise event, which fires once per boss bar per frame for every boss bar on screen no matter which mod put it there, and the first thing its listener does is call getString on the bar's name component and ask whether the result starts with Dark Doppelganger. getString walks the whole component tree, resolves the translation and builds a new String through a visitor every single time, and the answer it produces cannot change while the component object is the same one. With this on the answer is remembered against the component instance itself, eight of them at a time, so a bar that is not the doppelganger's costs eight reference compares instead of a full component render, and the listener returns immediately. The doppelganger's own bar still goes through the mod's untouched drawing code.

Skip the second of two identical entity scans in the spell cast handler. When the doppelganger casts, the handler checks the same spell id against the slow spell twice and runs the same hundred block wide box query for Iron's Spellbooks target area entities behind each check, handing both results to the same consumer, so the second query rescans every entity section that box touches to act on a set the first pass has already dealt with. With this on the second query is not run, which leaves the outcome exactly as it was.

Let the sculk jaw skip the same things when you stand in it that it already skips when you step on it. The jaw has two separate bite paths: the step on path lets creative players, sneaking players and the mod's own sculk mobs walk over it untouched and only bites while the block says it can bite, and a second path that fires for anything standing inside the block has none of those checks at all. So a creative player, a sneaking player or a sculk mob that ends up inside an open jaw gets chewed anyway, which is the opposite of what the mod's own rule says. With this on the inside path uses the same three checks the step on path uses. Turn it off for stock behaviour.

Bite once per sculk jaw instead of once per tick. When the jaw bites it sets itself to biting, which removes its collision box so the victim drops into the block, and it schedules itself to reopen thirty five ticks later. Meanwhile the second bite path fires for everything inside the block on every single tick with no cooldown of its own, so one step on an open jaw is the three damage the bite is written for plus another three damage twenty times a second for the whole thirty five ticks, around a hundred damage from one block, and the same damage source is built again on the client every tick as well. With this on the inside path stays quiet while the jaw is already mid bite, so a jaw does the one bite its step on path deals and then stays shut until it reopens. Turn it off for stock behaviour.

Look at which block was broken before reading the enchantments off the tool. Deeper and Darker listens to every block break in the game and the very first thing its handler does is ask the held item for its Silk Touch level, which walks the whole enchantment list stored on that item and builds and looks up a fresh ResourceLocation for every entry on it, and only after that does it check whether the broken block is one of the three blocks it actually cares about, which are crystallized amber, the ice lily and the ancient vase. Every other block in the game, and there are tens of thousands of them in a mining trip, pays that scan for nothing, and a vein miner breaking a whole ore body in one tick pays it once per block. With this on the block is checked first and the enchantment scan only happens for those three blocks, which is exactly when its answer was ever used. Turn it off for stock behaviour.

Only write the sonorous staff's charged flag when it changes. The staff rewrites that flag into its own NBT on every tick for every slot it sits in on both logical sides, and it uses the get or create form, so a staff that has never been charged still gets a tag permanently attached and then written to twenty times a second for as long as it is in anyone's inventory, on both sides, forever. The flag is only read to decide whether the staff glows. With this on the flag is compared first and only written when it actually flips, and a staff that is not charged is left with no tag at all, which is the same answer the glow check reads. Turn it off for stock behaviour.

Reuse one random number generator for the warden heart's heartbeat instead of building a new one every tick. The heart rolls for its ambient thump from its inventory tick, and it builds a brand new random source for that roll, which means a fresh seed uniquifier compare and swap, a nanotime read and an atomic long allocation, per heart, per slot, per tick, on both logical sides, to then almost always decide not to play anything. With this on the roll comes from one generator kept per thread. The thump happens exactly as often as before. Turn it off for stock behaviour.

Remember the last biome while Distant Horizons converts a chunk column into an LOD. Biomes are stored per four blocks but the converter asks for one per block going down the whole column, so three out of four lookups repeat the previous answer. Result is identical.

Drop Distant Horizons' biome wrapper caches when it unloads its world. Those caches are static, are never cleared, and are keyed on the biome registry objects the server hands out on join, so every world you leave keeps its whole biome registry alive for the rest of the session. It also means the LOD tint colours after a world change are still resolved against the previous world's biomes.

Remember the last biome colour while Distant Horizons blends the biome tint of an LOD block. At the default blend radius of three the blend samples forty nine neighbours per tinted block and looks each one's colour up through three concurrent hash maps, and neighbouring blocks are almost always in the same biome. Result is identical.

Run the camera shake entity scan once per tick instead of once per frame. Client.

Read pet upgrade levels out of a small per thread map instead of walking the whole stored enchantment list on every question. The mod asks whether a pet has a given upgrade about twenty times per pet per tick on the server and another eight times per pet per frame in the render layer, and every one of those walked the list and parsed a fresh ResourceLocation out of every entry. The map is rebuilt whenever the list is replaced, resized or written back, so the answers are the same.

Prune the collar swap cooldown map through its own iterator. The stock loop removes entries straight off the map while it is iterating the key set, which throws a ConcurrentModificationException and takes the level tick with it whenever two or more pets have a pending cooldown and the expiring one is not the last in iteration order. Timings are untouched.

Stop asking for a block entity after placing a block that cannot have one.

Stop the world gen rot cascade at a branch that did not actually go away. When a freshly generated tree is trimmed, every branch that rots recurses into its same-block neighbours to rot them too, and nothing checks that the block was really removed. A world gen region only accepts writes one chunk around the chunk being decorated but lets you read further out, so once the cascade walks into a neighbouring tree's branches in a chunk it may not write to, the removal is silently refused, the species still reports a rot, and two adjacent stuck branches recurse into each other until the stack overflows and the chunk generation thread dies. This is Dynamic Trees issue 1150 and it is still there in 1.4.11. A branch that is still standing after its rot call is now reported as not rotted, so the walk stops at the write border. Result is identical everywhere the removal succeeds.

Hand out a prebuilt collision shape for thick trunks instead of building a new one per query. Any branch wider than a full block skips Dynamic Trees' own shape cache and builds a fresh AABB and VoxelShape every single time the game asks for its collision box, which is once per axis per entity per tick for anything walking near a big trunk. There are only sixteen possible widths so they are all built once at load. Result is identical.

Reuse one position object and one cell array while Dynamic Trees works out a leaf's hydration from its six neighbours. Stock allocates a six wide cell array plus a fresh BlockPos per side every time, and this runs for every leaf on every hydration update, every leaf ageing pass and every leaf it tries to grow, on both the world gen threads and the server thread. Result is identical.

Read each block once while Dynamic Trees decides whether a leaf can go somewhere. Stock reads the target block three times and the block under it twice for a single yes or no, and the light check under it allocates a fresh position for the block below plus one per smother layer above. This check runs six times per leaf per ageing pass, and a tree generated by world gen ages its whole leaf cluster three times, so it is the single hottest thing the mod does while chunks are being built. The smother scan also stops at the first gap instead of always walking all four layers. Result is identical.

Ticks between the idle dirty marks the Easy Villagers blocks make. The trader, auto trader, farmer, iron farm and breeder block entities all call setChanged unconditionally on every single tick while a villager is inside them, and setChanged is not a flag write: it marks the chunk unsaved and then runs the comparator update, which allocates a position and reads the block state for all four horizontal neighbours and can walk a second ring on top of that. A trading hall or an iron farm wall is dozens of those blocks doing it twenty times a second for a villager whose only change is one tick of age. The blocks still mark themselves dirty on the ticks that actually do something, since those paths call setChanged themselves, so nothing is lost on save, and a comparator reading one of these blocks updates within this many ticks instead of instantly. 1 restores the stock every tick behaviour.

Stop recomputing an MD5 for every tier attribute modifier.

Run the camera shake entity scan once per tick instead of once per frame. Client.

Answer a repeated climate sample for the same position from a one entry cache.

Skip Elysium API's duplicate biome resolution entirely when no biome replacer exists.

Stop the anger time map growing one entry per neutral mob ever rendered.

Skip building the capability name fallback on every camera capability lookup when the registered capability is already resolved.

Skip the Frost Protection armour scan on entities that have no freeze ticks. The addon looks the enchantment up twice for every living entity every tick, once in its own living tick handler and once through the canFreeze injector that its LivingEntity tick handler calls before checking whether the entity is freezing at all, and the second one drags two Curios inventory walks along with it. Both call sites do nothing at zero freeze ticks.

Stop the addon event handler and the Annihilating Sword, Violence Scroll and Extradimensional Scepter tick handlers from reading, and thereby creating, a ForgeData compound on every entity in the world. Also removes the UUID parse and ImmutableMultimap build the sword did for every living entity every tick.

Stop the Slicing enchantment tick handler from reading, and thereby creating, a ForgeData compound on every entity on both sides every tick.

Answer the isWearing checks for the Moai Charm, Ring of Agility and Divine Shield from the per-tick curio set.

Answer SuperpositionHandler.hasCurio out of the per tick curio contents already cached for the entity instead of walking the curios inventory again. Every question resolves the curios capability, walks every slot of every slot type and allocates an Optional and a triple, and it is asked dozens of times per player per tick by Enigmatic Legacy and its addons, worst of all by Covenant of the Seven whose twenty odd tick handlers each open with two or three of them, plus another eleven per frame from its two hud overlays. The cached contents are rebuilt whenever the entity ticks and whenever Curios reports an equip, unequip or slot change, so the answer is the same one the walk would have given, except for a curio swapped and asked about again inside the same tick, which is seen on the next tick instead.

How often the Heart of the Guardian runs its monster scan, in ticks. The item scans every hostile in a forty eight block cube every tick for every copy in an inventory, before it checks whether the wearer is cursed or whether the active ability is off cooldown, and then line of sight traces from every guardian it finds. One is the vanilla rate.

Ask the Cursed Ring anger scan for the piglins and neutral mobs its loop can actually anger instead of every living entity in a forty eight block cube. The loop computes an armour and invisibility visibility fraction for every entity it is handed and then discards everything that is not a piglin or a neutral mob. Result is identical.

Drop removed entities from the angered guardian map when a new one is added. Enigmatic Legacy keeps every guardian that has ever targeted a Heart of the Guardian bearer in a strong keyed multimap and only clears it when a world is loaded, so a session at a guardian farm retains every dead guardian.

Remember whether a screen class is on FancyMenu's blacklist instead of running every blacklist rule against its name on each render call. Dropped whenever FancyMenu reloads or a new rule is added. Client.

Remember which screen identifier belongs to which screen instead of working it out again on every render call. FancyMenu asks four times a frame, and answering walks a hash map, scans its whole universal identifier table for a matching value, and calls Class.forName. The cache is dropped whenever FancyMenu reloads or a new universal identifier is registered. Client.

Hold FancyMenu's render scale, translation and rotation in plain fields for the render thread instead of in ThreadLocals. Stock reads or writes three ThreadLocals on every PoseStack push, pop, scale, translate and mulPose, which the profiler puts at 2.6 percent of the client thread. Other threads keep the stock ThreadLocal. Client.

Seconds between seamless world loading screenshots. FancyMenu reads back the whole framebuffer each time, which stalls the render thread. Stock behaviour is 1.

Skip FancyMenu's ThreadLocal render scale write when the value is unchanged. Stock writes it on every PoseStack push, pop and scale.

Answer the mod's nearby player checks off the level's own player list instead of running a full entity box query. Faunify asks for every player in a box around the mob from the mouse's seed stealing goal, the dragonfly's darting goal and the silk moth and beefly flight goals, all of which the goal selector re-evaluates every other tick for every one of those mobs, and again from the silk moth's own tick on every server tick while it is sitting on the ground. Each of those calls walks every entity section the box touches and type checks everything it finds, to build a list that on a normal server has one to a handful of entries in it. The replacement walks the level's player list and keeps the players whose hitbox overlaps that same box and who are not spectators, which is exactly what the stock query returns.

Stop a millipede body segment re-running its hundred block wide search for the segment in front of it on every client tick and every frame. On the client a segment resolves its parent by asking for every entity in a fifty block inflated box and comparing UUIDs, and it does that from its own tick and again from the renderer, which asks it for the head to pick which millipede texture to draw and walks the whole chain of parents to get there. While the parent is loaded that is a cached field read, but the moment it is missing, which is every chunk load and any time the head is outside client tracking range, every segment pays that sweep twenty times a second plus once per frame, forever. With this on a failed lookup is not retried for this many ticks. The server side lookup, which is a plain UUID map read, is untouched, and so is everything about how the millipede moves, since the segment positions are driven by the head on the server; the only visible effect is that a segment can draw with the default texture for up to this many ticks after its head appears. Set to 1 for stock behaviour.

Only run the Phase Sphere tick for your own player. The mod hooks the vanilla player tick, which fires for every player entity the client knows about, and its client branch is written against one global flag and one global counter that belong to the local player alone. So while you hold the Phase Sphere in multiplayer, every other player you can see also gets no clip and the flying flags forced on client side, and the use timer is advanced once per visible player per tick instead of once per tick, which drains the sphere several times faster the more people are standing near you. With this on the client branch runs for the local player only. The server branch, which is the one that actually stores and syncs the sphere state, is untouched. Turn it off for stock behaviour.

Skip the arena protection sweep while no boss arena is loaded. Qliphoth Awakening listens to every block break, every block placement and every explosion on the server, and the first thing each of those three listeners does is ask the world for every boss spawner entity inside a two hundred block cube centred on the block, which is thirteen by thirteen by thirteen entity sections walked and type tested, before it has looked at anything else. A quarry, a vein miner, an Ultimine swing or a Create drill breaking a few hundred blocks in one tick pays that whole sweep once per block, and the answer is an empty list every single time unless you are standing in one of the mod's arenas. With this on the patch mod keeps a count of how many boss spawner entities are loaded on the server, updated when entities start and stop being tracked, and the three listeners return immediately while that count is zero, which is exactly what they did with the empty list anyway. The moment one boss spawner is loaded the sweep runs unchanged and the arena is protected exactly as before. Turn it off for stock behaviour.

Skip the hellscape sky scan while no boss spawner is loaded on the client. Every client tick between dusk and dawn the mod asks the client world for every Malkuth boss spawner inside a sixty block cube around you, purely to decide whether the red hellscape skybox should fade in. With this on the patch mod keeps a count of the boss spawner entities the client has loaded and hands that query an empty list while the count is zero, which is the same answer the query gave, so the sky still fades out exactly as it did. As soon as any boss spawner is loaded the query runs untouched. Turn it off for stock behaviour.

Skip the Chesed kinetic field collision query while no kinetic field is loaded. The mod injects into the vanilla entity collision routine and, for every player and every thrown ender pearl, builds two bounding boxes and asks the world for every Chesed kinetic field inside a forty block cube, on every movement step, on both logical sides. Kinetic fields only exist during the Chesed fight, so on a normal world that is a few dozen entity section lookups per player per tick per side producing an empty list. With this on the query is skipped while no kinetic field is loaded on that side and runs unchanged as soon as one is, so the fight collides exactly as before. Turn it off for stock behaviour.

Run the camera shake entity scan once per tick instead of once per frame. Client.

Stop FTB Chunks recording map data entirely. No chunk is scanned when it arrives from the server, no block change is re-rendered, and nothing new is written to disk. Turn this on only if another map mod is doing the job. Already recorded regions still load and display.

Stop the FTB XMod Compat integration from putting Waystones icons on the FTB minimap and large map.

Copy a map region's five images straight into their pixel arrays instead of making 1.3 million per pixel setRGB calls on the calling thread.

Reuse the region and its image across the 225 chunk tiles of one minimap rebuild instead of taking the shared map lock for every tile.

Stop building the minimap texture when the minimap is not being shown.

Memoise BakedGeoModel#getBone(String) per baked model.

Reuse the scratch vectors GeckoLib allocates while writing model geometry.

Answer gnetum's per element caching question once per tick instead of once per element per frame. Each ask is a set lookup plus a guava cache lookup and there are dozens of elements.

Resolve an event handler's mod id with one map lookup instead of a containsKey followed by a get.

Reuse the LazyOptional Goety's capability providers build.

Run the fog listener's Wight#findWight scan once per tick instead of once per posted RenderFog event. Client.

Run the camera shake entity scan once per tick instead of once per frame. Client.

Keep the boat plate log list instead of rescanning the whole item registry on every result lookup. Rebuilt whenever tags reload.

Run the cherry blossom cake entity sweep once every N server ticks instead of every tick.

Test the log tag against the item itself instead of building a throwaway ItemStack for every item in the registry on every boat plate result lookup.

Skip the per-frame walk over every entity in the level while no entity carries a visual effect. The walk re-arms as soon as one is added or synced.

Answer CuriosFinder#findCurio(LivingEntity, Item) misses from the per-tick curio set.

Answer SEHelper#isAlly without resolving anything when the player has no allies.

Check whether the entity is a Wildfire before doing the work that only a Wildfire ever uses. Goety Hostility hangs a listener off the living tick event on the client, which runs for every living entity the client has loaded, twenty times a second, and the only thing that listener can ever do is start the Wildfire boss music. Before it gets around to asking whether the entity is even a Wildfire it reads a Goety config value, resolves Goety's mob target capability off the entity twice, unwraps it both times, and asks the entity type whether it carries a boss music tag, so a few hundred cows, zombies and item frames in render distance pay several capability resolutions and a tag lookup each, every tick, to be told they are not the fire boss. With this on the entity type is checked first, off a cached class test, and everything else only happens for an actual Wildfire, which is the only case the body was ever written for. Turn it off for stock behaviour.

Skip the Squall Golem's proximity sweep when it already has a target. An activated golem asks the world for every living entity in a twelve block cube around it on every single tick, then line of sight traces from each one back to itself, purely to decide whether to refresh its hundred tick activity timer. The very next line refreshes that timer anyway if the golem has a target, so during an actual fight, which is the only time several golems are awake at once, the whole sweep and every trace in it is thrown away. With this on the sweep is skipped when the golem already has a target and runs exactly as before when it does not, so a golem still wakes up for anyone who walks near it. Turn it off for stock behaviour.

Stop probing the eight blocks under the Wildfire after the first solid one. The boss checks whether there is a steep drop below it while it is airborne and chasing, and that check reads the block state eight positions straight down without ever stopping, even though one solid block anywhere in that column already settles the answer, and it rebuilds the boss's own block position three times and allocates a fresh block position for every one of those eight reads. With this on the probe stops at the first solid block and reuses one mutable position, which is the same answer with up to seven fewer block state reads and eight fewer allocations per tick while the boss is in the air. Turn it off for stock behaviour.

Memoise the constant attribute modifiers Goety rebuilds every tick.

Answer repeated CuriosFinder#findCurio(LivingEntity, Predicate) lookups from a per-tick per-entity memo.

Answer ATAHelper#hasHalo and #hasBrokenHalo from the per-tick curio set.

Skip the boss music target lookup for entities that have no boss music. Client.

Stop building the throwaway capability fallback on every query.

Run both camera shake entity scans once per tick instead of once per frame. Client.

Remember the model, texture and animation file names of each Hazen 'n Stuff geo model instead of rebuilding them on every frame. Every one of the mod's thirty seven armour, staff and weapon models answers which model file, which texture and which animation file it uses by building a brand new ResourceLocation out of the same two constant strings, and GeckoLib asks all three of those questions again for every piece of the mod's gear that is on screen, every frame, plus once more per glow layer. Nothing about the answer can change at runtime, so a player in a full set with a staff in hand pays for roughly twenty of those objects a frame, each one also re-validating the same namespace and path character by character. With this on the answer is built once per model and handed back afterwards, so the returned value is identical and only the rebuilding goes away. Turn it off for stock behaviour.

Hold Hexerei's dynamic light toggle in a plain field instead of reading it back out of the config spec on every question. The bundled dynamic light code asks for that toggle first thing inside LevelRenderer.getLightColor, which runs once per block face for every quad of every chunk section the game meshes, and again inside EntityRenderer.getBlockLightLevel for every entity on screen every frame, so a single chunk rebuild is hundreds of thousands of config lookups. The cached answer is thrown away at the start of every dynamic light update pass and whenever the mod's own toggle command runs, so flipping the setting still takes effect on the next frame.

Turn off the dynamic lights Hexerei bundles inside itself. It ships a private fork of LambDynamicLights that nobody asked for and that no other mod can see or coordinate with, wired into LevelRenderer.getLightColor so it runs once per block face for every quad of every chunk section the client meshes, and into EntityRenderer.getBlockLightLevel for every entity on screen every frame. With this on the whole thing reports itself as switched off, exactly as if the mod's own toggle had been used, so nothing registers as a light source, nothing is scanned and both hooks return the stock lighting immediately. Anything already lit when this takes effect is cleared and its chunks are rebuilt on the next frame. Held torches and glowing entities stop lighting the world unless you install a real dynamic light mod, so turn this off if you want Hexerei's version back.

Return straight away from the dynamic light distance scans when nothing in the world is currently emitting dynamic light. Both scans take the shared read lock, allocate an iterator and walk the whole light source set before clamping the result, and they run once per quad during chunk meshing and once per entity per frame. Entities only enter that set while they are actually lit, so most of the time it is empty and the scan can only ever return zero, which is the value the fast path hands back. When anything is lit the stock scan runs exactly as before.

Minimum distance in blocks from world spawn before a dragon cave will generate.

Minimum distance in blocks from world spawn before a dragon roost will generate.

Generate dragon roosts and caves as structures instead of as decoration features.

Key the dragon layered-texture cache on a packed int instead of a built string.

Vertical half-extent, in blocks, of the dragon target search box. -1 keeps stock.

Keep Ice and Fire's EntityData capability handle on the entity instead of in a boxed map.

Trim the per-tick work of dragon, sea serpent and death worm body parts.

Test dragon armour with the four slot ordinals instead of two built strings.

Return early from the dragon banner and rider layers when they would draw nothing.

Stop rebuilding the pathfinding debug render context on every render stage.

Find a render layer's buffer with one map lookup instead of a contains check plus a get.

End only the render layers that were actually drawn into instead of walking every fixed buffer on each flush.

Batch the aircraft HUD instead of flushing the GUI buffer after every primitive.

Answer the steampunk hud overlay check with one item comparison instead of a registry lookup per armor slot per frame. The overlay hook runs from the vanilla hud render every single frame whether or not anything from this mod is worn, and for each of the four armor slots it asks the item registry for that item's id and then builds a fresh ResourceLocation for the steampunk chestplate to compare it against, so a player wearing no Immersive Armors at all still pays four reverse registry lookups and four ResourceLocation allocations, namespace and path validation included, every frame. With this on the chestplate item is resolved once and the frame is dropped straight away unless that exact item is actually in one of the armor slots, which is the only case the stock code could ever have drawn anything in. If the item cannot be resolved the stock scan is left alone.

Stop the client rewriting the armor set counter into its own copy of the stack. Every armor effect of every equipped Immersive Armors piece runs the same base tick on both logical sides, and once a second that tick calls getOrCreateTag on the stack, which permanently attaches an empty compound to a stack that had none, and puts the set count back into it after building a three stage stream over the armor slots to recount it. The server writes the same number into the real stack and that value is what the client is sent, so the client side pass recomputes a number it is about to be handed anyway. With this on the base tick is skipped on the client only; the server side write, the tooltips that read it and everything the individual effects do in their own overrides are untouched.

Stop the Stasis Chamber tick filter from reading, and thereby creating, a ForgeData compound on every mob in the world.

Return early from the enhanced terrain adaptation pass when there is none in range.

Stop the village workstation picker from leaking and racing. The structure processor that swaps a placeholder block for a random workstation keeps its list of candidate blocks in a field on the processor and appends the full candidate set to it on every single block it processes, never clearing it, so the list grows by a few entries for every workstation placed in every village for the life of the world. Worse, one processor instance is shared by every chunk being generated, and chunks generate on several worker threads at once, so two chunks placing workstations at the same moment append to and read from the same plain ArrayList concurrently, which can throw an index out of bounds out of chunk generation. With this on the pick runs under a lock and the list is emptied before each pick, so every workstation is chosen from exactly the same set the first one was and nothing is left behind. Turn it off for stock behaviour.

Throw away the client's copy of other players' spell state when you leave a world. The client keeps a map of every player it has been told is casting, keyed on that player's entity id, and nothing ever removes from it: not logging out, not changing world, not the player leaving. It grows for the whole time the game is open, and because entity ids start again from low numbers on every world or server you join, the next world hands those same ids to completely different players, who then inherit whatever the old occupant of that id was doing. That shows up as players stuck in a casting pose, spin attack fire trails on someone standing still, and entities being drawn through the frustum cull because the stale entry says they are casting, until a real packet happens to overwrite it. With this on the map is emptied when you disconnect and again when you join, so a fresh world starts from nothing. Turn it off for stock behaviour.

Answer "is this curio worn" out of the shared per tick curio contents cache instead of walking the whole curio inventory every time. The mod's curio items answer that question by asking the curios api for the wearer's inventory, handing it a lambda and letting it walk every slot of every curio type until it finds a match, allocating a lazy optional, a slot context, a slot result and a java optional along the way, and it asks from places that run constantly: the invisibility ring is checked from the entity invisibility hook, which fires for every entity anything asks about on every frame on the client and again from mob targeting on the server, and the summon and spell paths ask again on top of that. The answer only changes when someone actually equips or unequips something. With this on the question is answered from the set of worn items this mod already keeps per entity, which is rebuilt at most once per entity tick and thrown away the moment a curio change, equip or unequip event fires, so a repeat question is one set lookup with no allocation. A curio swapped by something that never fires a curios event can read one tick stale. Turn it off for stock behaviour.

Read the item entity's block state through getChunkNow instead of the loading getChunk.

Stop the area preview renderer copying every block entity of all 169 nearby chunks into a fresh list every frame, and skip the whole 169 chunk sweep for the rest of a tick once that tick's first frame found no area affecting block at all. A preview switched on part way through a tick shows up on the next one.

Only start Konkrete's audio volume thread once a mod actually registers a sound with it. Konkrete spawns a plain non daemon thread at client setup that wakes ten times a second for the whole session, reads the master volume slider and pushes it onto every clip it is holding. FancyMenu 3 and Drippy Loading Screen both moved to their own audio systems, so on a normal pack that map is empty and the thread wakes six hundred times a minute to iterate nothing, while holding an OS thread and its stack. The thread now starts on the first registerSound call instead, and registerSound already sets the clip volume itself, so a mod that does use Konkrete audio gets the same behaviour.

Bail out of the held item animation handler before it copies your hands.

Stop re-asking entities that cannot have traits for their trait capability.

Ticks between boss music state broadcasts. Every loaded boss with music sends a packet to every player on the server on every tick, so 20 packets per second per boss per player even when nothing changed. A state change is still sent immediately; this only limits the repeats that let players who moved in or out of hearing range resync. 1 restores the stock every tick behaviour.

Run the camera shake and dynamic zoom entity scans once per tick instead of once per frame. Client.

Fix the Annihilator Leggings shockwave roll. The mod multiplies a full range random int by 100 and compares it to 25, which overflows and fires about half the time instead of the intended quarter.

Skip the camera shake listener when there is no client player instead of reading its tick count first, which is a null dereference placed above the mod's own null check. Client.

Skip the dynamic camera zoom listener. It scans for zoom entities every frame and then throws away the only value it computes, so the eight view clip raycasts behind that value change nothing. Client.

How many ticks between annihilation spell power bonus refreshes. The mod recomputes this bonus off the living tick event for every living entity in the world every two ticks, and every one of those calls resolves three attributes off the entity, each of which allocates a lambda on the way into the attribute map, reads two values back out and looks up the existing modifier, all to arrive at the same number it arrived at a tenth of a second ago. Nothing but a gear change can move it. Raising this to ten ticks cuts four fifths of that work and means a bonus that changes when you swap a piece of gear lands within half a second instead of a tenth. Set it to 2 for the stock rate.

Only look for a tornado when one is actually around. Legendary Spellbooks listens on the living tick event so that anything caught in a Legendary Monsters tornado stops taking fall damage, and that listener has no guard on it at all: for every living entity in the world, on every single server tick, it grows that entity's bounding box by two blocks and asks the level for every tornado inside it, which walks each entity section the box touches and tests everything standing in them, and it allocates a fresh bounding box, a fresh entity type test and a fresh result list to do it. A tornado is a boss projectile that exists for a couple of seconds a few times a playthrough, so in an ordinary world that whole search runs hundreds of times a second to be told no, and in a mob farm it turns into every mob asking about every other mob nearby. With this on a tornado stamps the tick it last ticked on, the search is skipped outright while no tornado has ticked in the last tick, and any entity that still carries the in_tornado tag has it taken off on the way past so nothing keeps its fall damage immunity. As a safety net every entity still runs the real search once a second regardless, so if a future version of Legendary Monsters stops the stamp from landing the tag is still picked up within twenty ticks instead of never.

Run the flameborn drift particle sweep for your own player only. The handler sits on the player tick event, which the client fires for every player entity it is ticking, and the first thing it does is ask the level for every entity within sixty four blocks of that player, a box a hundred and twenty eight blocks on a side, then walks the result looking for anything mid drift. On a server with other people nearby that is one full sweep per player per tick over almost the same set of entities, and worse, anything drifting inside two of those boxes gets its particles spawned twice a tick, so the effect visibly thickens as more players stand near it. With this on only your own player runs the sweep. Nothing is lost visually because the game throws away particles spawned more than thirty two blocks from the camera anyway, which is half the radius the handler was searching, and in single player the behaviour is identical because there was only ever one player to tick.

Stop the backup SOS charms crashing a dedicated server when something asks for their name. Both charms build their display name and their tooltip as animated gradient text, and to pick the animation frame they call Forge's client only executor for the client's tick count and unbox the result straight into an int. On a dedicated server that call returns null, so the unboxing throws a NullPointerException, and the name of an item is asked for on the server in plenty of ordinary places, renaming it in an anvil being the easiest one to hit. The mod's own shared copy of this helper already falls back to a clock derived tick count when the answer is null; the two copies pasted into the charm classes never got that guard. With this on they get the same fallback, so the server answers with a name instead of crashing and the client's animation is untouched.

Test the bonus weapon drops against the entity type instead of rebuilding its id as a string. Lethality hands out four of its swords from four specific Terramity bosses, and it decides which by listening on the drops event, which the game fires for every single living entity that dies anywhere in the world, then turning that entity's type back into a registry key and calling toString on it, which concatenates the namespace and the path into a brand new String, and comparing that string against four literals one after another. Every mob death in a farm, a spawner room or a mob grinder paid for that string. The four entity types are now looked up once and held, and the handler is skipped outright unless the entity that died is actually one of them, which for everything else in the game is one reference compare. The four bosses drop exactly what they dropped before.

Keep the broken biome blade's lifesteal flag on the server. The handler runs on both logical sides for every player on every tick and always writes to that player's Forge persistent data: it either sets the lifesteal flag or, far more often, removes a key that is not there, so every player is paying a held item read, an nbt read and a persistent data write twice over for a flag that only the server's damage handler has any use for. The client's own copy of the flag is only ever read by the client half of the lifesteal hook, which heals the client's copy of the player a fraction of a second before the server sends the real health down, so nothing is lost by stopping it. With this on the client side of the handler returns immediately, the server keeps setting and clearing the flag exactly as before, and the healing you actually get is unchanged because the server is the side that does it.

Run the blade mode handler and the Meowrasama handler once per tick instead of twice. Neither of them looks at which half of the tick it is in, and Forge fires the player tick event twice for every player on every tick, once before the player moves and once after, so both handlers do all of their work two times a tick for every player in the world. For the Meowrasama handler that is two held item reads, an nbt read and an effect lookup per player per tick that only ever needed to happen once. For the blade mode handler it is worse: while blade mode is up it asks the level for every living entity in a five block inflated box around the player and hands a fresh slowness instance to every mob it finds, twice per tick, which is a duplicate effect packet to everyone tracking each of those mobs, and while blade mode is down it is four attribute map lookups and two modifier removals per player per tick for a modifier that is almost never there. With this on both handlers run on the end phase only, which is the pass whose result the game actually keeps, and the end of tick state is identical to what the stock code left behind.

Skip the charm handler for players who are not wearing any of the three curios it looks for. Lethality listens on the hurt event and, for every hit whose direct source is a player, walks that player's whole curios inventory twice before it knows whether anything is equipped: once through the curios helper's find first call to look for the charged redstone piece, which allocates an Optional per question, and once through its own handler lookup, which allocates an Optional, a lambda and a map view and then reads every slot of every curio type looking for the two backup charms. With a melee weapon that hits several entities at once that is two full inventory walks per entity hit. With this on the answer comes out of the equipped curio set the patch mod already keeps per entity per tick, and the handler is skipped only when none of the three items is worn, so a player who has one equipped gets exactly the stock behaviour, cooldown and all.

Merge Lithostitched's biome modifiers into Forge's list once per world load instead of once per biome.

Resolve a block swap processor's id to id table to a block to block table once instead of three registry lookups per placed block.

Build a template pool's weighted shuffle from primitive arrays instead of rebuilding a boxed entry list three times per jigsaw connector.

Skip Lootr's per-server-tick container conversion pass while its queues are empty.

Maximum container conversion candidates Lootr may examine per server tick.

Send Macabre's variable sync packets once per tick instead of once per assignment.

Skip Macabre's entity animation handler for entities that are not Macabre's.

Bail out of Macabre's held item animation handler before it copies your hands.

Stop other players resetting your mouse sensitivity while you are channelling the mystic staff. The mod drops your sensitivity to a third while the staff beam is charging and puts it back from its player tick handler, but that handler runs for every player entity the client has loaded and never checks which one it is looking at, and the tick counter it is throttled by is only ever advanced on the server, so on a multiplayer client it is stuck at zero and the check passes every single tick. Any second player standing nearby who is not holding a mystic staff therefore snaps your sensitivity back mid aim. With this on the handler only runs for your own player on the client, which is also everything it was ever able to do there. The server side is unchanged.

Stop the projector enchantment renderer walking the enchantment list of every armour piece of every entity on screen every frame. It asks whether each of the four armour slots carries the mod's projector enchantment, and the vanilla helper behind that question allocates a fresh empty list tag and does a registry key lookup for every stack that has no nbt at all, which is nearly all of them. With this on the renderer returns early when not one armour slot on the entity carries nbt, which is the same answer the stock scan arrives at. An item that reports enchantments from somewhere other than its own nbt would be skipped, so turn this off if you use armour like that.

Check for the Ripper's invisibility effect before reading the entity's hands instead of after. The same living tick chain runs this for every living entity every tick on both sides, and stock reads the main hand stack, the off hand stack and their items before it ever looks at the effect, even though the whole method does nothing at all unless the effect is present. Nobody in a normal world has it. Turning this off restores the stock ordering.

Drop logged out players from the insight eyes target map. The mod keeps a static map of players who are currently being shown an insight readout and clears an entry on the first tick the player has no target, which never happens if the player disconnects or dies while looking at something, so that entry pins the whole player object and everything it references for the rest of the session. This removes the player on logout and sweeps any key whose entity has already been discarded.

Skip the borrowed authority tick on the client. Mahou Tsukai hangs fifteen separate effect handlers off the living tick event, so every one of them runs for every living entity in the world on both logical sides, and this is the one that costs something before it checks where it is. It resolves the mod's living mahou capability off the entity first, which means a capability dispatcher walk and a lazy optional unwrap wrapped in a try catch, and only then asks whether it is on the server. Everything the handler actually does is inside that server check, so on the client the whole lookup is thrown away. With this on the client side of the handler returns immediately. The server is untouched.

Skip the Origins quiver bookkeeping when Apoli is not installed. Too Many Bows hooks ItemStack#shrink and hands every single shrink in the game to OriginsQuiverCompat, which takes the monitor on one static Collections.synchronizedMap wrapping a WeakHashMap and runs a remove plus a stale entry expunge, from every thread that ever shrinks a stack. Without Apoli that map can never be written to, so the whole lookup is dead work on one of the hottest methods in the game, and the same check also drops the synchronized reflection lookup behind Player#getProjectile. Turn off for stock behaviour.

Hand MCreator mods one shared empty player variables object instead of allocating a throwaway on every single variable read. Procedures that read variables per tick or per frame can otherwise churn hundreds of megabytes of garbage. This rewrites the mods' classes as they load, so a change here only takes effect from the next launch.

Answer the is this accessory worn question out of the equipped curio set the patch mod already keeps per entity per tick. Meet Your Fight has one shared helper for this and its six trinkets all go through it: the ace of iron and the caged heart ask it for every hit any player in the world takes, the slicer's dice and the wilted ideals ask it for every hit any player deals, the tomb planter asks it for every mob that dies to a player anywhere, and the blossoming mind asks again for that same mob's experience drop. Every one of those questions resolves the curios capability off the player, unwraps a lazy optional into a real Optional, maps it through a lambda into a second Optional, boxes the answer into a Boolean, and behind all of that walks every slot of every curio type the player has looking for one item and building a slot result object the moment it finds it. A player swinging a sweeping weapon into a pack of mobs pays two of those whole walks per entity hit and another two for every one of them that dies. The set of items a player is actually wearing is already worked out once per entity per tick by this mod and thrown away when curios reports an equip, unequip or change, so the answer now comes out of a set lookup and the walk only happens when the cache cannot say, which is exactly the cases where the stock code ran anyway.

Stop the spectre's eye running its thirty two block enemy sweep on the client. Curios ticks a worn trinket on both logical sides and this one never checks which side it is on, so once every three seconds the client repeats the whole thing: it grows the wearer's bounding box by the configured range, which is thirty two blocks by default and therefore a box sixty four blocks on a side, walks every entity section that box touches, tests everything standing in them for being a monster, and hands each one a fresh glowing effect instance. None of that lands. Glowing is drawn off the entity flag the server syncs down, not off the client's own effect list, so the client copy of the effect is invisible, it is rolled against a search the server has already done, and it fires the effect added event on the client for every mob in range. With this on the client side of the tick returns before the search, the server keeps applying glowing and syncing it exactly as before, and what you see through walls is unchanged.

Build the swelling chicken's model once instead of once per frame. When a chicken has been fed chicken feed the mod draws a second inflated chicken body over it, and it builds that body from scratch inside the render call: it lays out the whole cube mesh, bakes it into a fresh model part tree and wraps it in a new model object, for every fed chicken, on every frame. Nothing about that model depends on the chicken, and nothing in the mod ever moves a part of it. With this on the mesh and the baked part tree are built the first time one is drawn and reused after that, which is what the vanilla entity models do. Turn it off for stock behaviour.

Look for an Ender Inhibitor by chunk section instead of reading every block in the box. Mob Grinding Utils listens to every teleport on the server, which on a normal world means every enderman teleport attempt and every chorus fruit, and answers the question "is an inhibitor nearby" by walking the entity's bounding box grown by eight blocks in all directions one block at a time, which is about five thousand two hundred block state reads per teleport attempt, each one going back through the world for its chunk. With this on the same box is walked one chunk section at a time and a section whose palette does not contain a lit inhibitor at all is skipped whole, so the usual answer costs a handful of palette scans instead of five thousand reads. The positions that do get read are exactly the ones the mod read, so a teleport is blocked in exactly the same places. Turn it off for stock behaviour.

Do not attach an empty forge data tag to every chicken in the world. The chicken feed handler runs on the living tick for every chicken on the server and the swelling renderer runs for every chicken on screen, and both of them ask the chicken for its persistent data before checking whether it has ever been fed. That call creates and permanently attaches an empty compound to any chicken that does not have one, so every chicken you have ever loaded ends up carrying an empty forge data tag that is written to disk with it from then on. With this on the existing tag is read when there is one and an empty shared tag is used when there is not, which is the same answer without the attachment. Turn it off for stock behaviour.

Only tell clients about a fan when something about it actually changed. Every fan recomputes its blow area on every server tick and then announces a block update whether or not anything moved, and because a fan is a block entity that announcement makes the server resend the fan's entire block entity tag, inventory included, to every player who has that chunk loaded, twenty times a second, forever. A wall of fans in a mob farm is a steady stream of packets that carry the same bytes every time. With this on the announcement is made only when the fan's reach, its blow area or its show area toggle has actually changed, which is also what every other path that changes a fan already does for itself. Turn it off for stock behaviour.

Work out which creative tabs JEI covers by indexing its item list once, instead of asking every tab whether it holds every item. Stock compares each item against each tab, and each comparison hashes the item's NBT, so the first creative search freezes for as long as it takes. Client.

Skip Moonlight's custom map marker refresh on maps that have no markers.

Read the equipped artifact set out of one pass over the curio slots instead of asking the curios inventory forty nine separate times. The player tick handler rebuilds this set to decide whether the damage reduction and damage increase totals need recomputing, and the stock version resolves the curios capability, allocates an Optional and a capturing lambda and walks every curio slot once per artifact, so a player with nothing equipped still paid forty nine full inventory scans per tick per side. The resulting map holds the same items, so the totals and the recompute decision are unchanged.

Drop players that are gone from the five static maps the damage handler keys on the player object. Nothing ever removes from them, so every logout, respawn and dimension change leaves a whole player entity and its cached artifact map reachable forever, on the server and in singleplayer on the client too. The sweep runs about once every thirty seconds and only removes entries whose player has already been discarded, so live players keep their cached totals.

Run the damage bookkeeping tick on the end phase only. The handler has no phase check at all, so it does the whole equip comparison twice per tick per player. Anything it would have noticed at the start of a tick is noticed at the end of the same tick instead.

Skip More Hitboxes' multipart pass over the result of every entity box query when the result holds no multipart. The pass allocates a hash set and re-tests the predicate for each hit, and almost every query returns none.

Build the combined curio inventory once per equipped relic scan instead of twice for every single slot. More Relics calls getEquippedCurios() inside both the loop condition and the loop body, so a thirty slot player allocates sixty throwaway inventory wrappers per relic overlay per frame.

Walk More Relics' delayed task list off a snapshot, drop each task before it runs, and throw the list away when the server it was filled for is gone. Stock iterates the live ArrayList while running the tasks, so any task that ends up scheduling another one, which the Twin Fangs hurt handler does, is a ConcurrentModificationException in the server tick, a task that throws is never removed and so throws again every tick forever, and nothing ever clears the list when a single player world is closed, so its runnables keep the old world and its players alive and then fire into the next world you load. A task scheduled from inside another task now runs on the following tick instead of the same one.

Ticks between boss music state packets. 1 keeps stock behaviour.

Reuse the camera shake entity scan within a client tick instead of once per frame.

Build the sunstrike, solar beam and solar flare render types once instead of once per entity per frame.

Stop every Umvuthana follower re-scanning a 64x64x64 region for its leader every tick.

Stop Mowzie's Mobs attaching its capabilities to every entity twice.

Maximum physics substeps per frame for dynamic chains. 0 disables the clamp.

Keep Mowzie's Mobs' four capability handles on the entity instead of re-resolving them.

Compute the dynamic chain's render matrix once per chain instead of once per bone.

Drop the throwaway Optional from Mowzie's per-frame bone lookups.

Test the bone name before pushing a matrix in the Umvuthana and Umvuthi render layers.

Reuse one vector pair per cube in Mowzie's llibrary model renderer instead of allocating 30 per cube per frame.

Skip the Elokosa transformation layer's full model re-render while it is fully transparent.

Reuse the per dimension spawn count that caps body parts, endersoul fragments and creeper minion eggs instead of rebuilding it for every single one. Stock answers 'how many of these already exist' by streaming every entity in the whole dimension and counting the matches, once per spawn, so a mutant zombie bursting into body parts or a mutant enderman throwing fragments runs dozens of full dimension entity walks inside one tick. With this on the walk runs at most once per dimension per entity type per server tick and every further spawn in that tick reads the remembered number plus the ones already let through, which is the same number stock would have produced. Entities of that type that are removed inside the same tick are not noticed until the next one, so the cap can be up to one tick stricter than stock, never looser. Turn off for stock behaviour.

Skip the parrot on shoulder lookup when there is nothing on the shoulder. The player tick handler runs the creeper minion ambient sound check for both shoulders, on both logical sides, every tick, and it reads the shoulder id and parses it into a ResourceLocation and does a registry lookup before it ever checks whether the shoulder tag holds anything at all, which for almost every player is an empty tag being parsed into nothing four times a tick. With this on an empty or missing shoulder tag returns immediately, which is the same answer the lookup gave, and it also closes the null tag path that would throw. Turn off for stock behaviour.

Walk the augment ability cache with a plain loop and only build the player key once something is actually cached. Stock concatenates the player name and side into a fresh string and runs a stream, a filter, a map and a collector over the whole cache for every player every tick on both sides, even when nobody in the world has an augment equipped. Result is identical.

Read augments off a tinkerable with interned slot keys and a remembered id lookup. Stock builds the string 'Augment-' plus the slot number twice per slot, parses a fresh ResourceLocation for every augment it finds and allocates five lists for one set of armour, and it does that from inventoryTick on all twelve essence tools, from onArmorTick on all four armour pieces and from the armour augment tick handler, on both sides. Result is identical.

Remember a crop's translation key instead of rebuilding it with String.format on every name lookup. The mystical seed and essence items, roughly a hundred of them, resolve their name and their description id through it, so it runs once per hovered item per frame and again whenever a recipe viewer indexes or searches names. Result is identical.

Skip the Soul Extractor's recipe lookup while its input slot is empty. Every other machine in the mod checks its input first, this one does not, so an idle extractor runs a full linear scan of every soul extraction recipe every tick and allocates an inventory wrapper for each one. An empty input cannot match any recipe, so the result is identical.

Run the boss scan behind the fog and fog colour listeners once per tick instead of once per posted event. Client.

Run the screen shake entity scan once per tick instead of once per frame. Client.

Keep each chunk's Nature's Aura capability handle instead of walking the capability dispatcher once per loaded chunk per second.

Stop rebuilding the whole default data component table on every data component question. Every has, get and getOrDefault on an item stack asks NeoBackports for the map of registered defaults, and that getter hands back a fresh ImmutableMap copy of the backing map every time instead of the map itself. Starcatcher asks whether a stack is a golden fish at the head of the vanilla item render type lookup, which is once per item drawn per frame, so a single open inventory or JEI page is thousands of those copies a second, and every mod that ships this library pays the same on every component read. With this on the copy is built once and reused until the backing map gains an item, which is the only way it can ever change, and the returned map is still immutable so nothing can write through it.

Work the pet petting check's entity raytrace out once per tick instead of once per frame. NotEnoughAnimations asks every one of its animations whether it applies for every player model it sets up, so once per player per frame, and the pet animation's only guard is whether that player is crouching. Crouching is something players do constantly, and the moment one is, the check fires a real raytrace: it builds the eye position, the view vector, the reach point and an inflated bounding box, then asks the level for every entity that box touches and tests each of them, all to find out whether there is a tamed wolf or cat right in front of the player's face. That is a full entity sweep per crouching player per frame, and with a shader pack's shadow pass it is paid again for every extra pass. Every input the raytrace reads, the previous tick position, the rotation, the bounding box and the eye height, only ever changes on a tick boundary, so the answer is identical for every frame inside the same tick; it is now worked out on the first frame of a tick and reused for the rest of it. The hit result handed back is the same object the raytrace produced, so the animation, the pet it picks and the height check behind it are unchanged.

Stop the sheathed sword tracker running on the logical server. NotEnoughAnimations is a client only mod, but the mixin that carries its animation data sits on Player rather than on the client player class, so in single player and on a listen server the integrated server's own copy of every player runs it too, and every one of those player ticks calls the render layer's tracker: two held item reads and two lookups into a static HashSet, writing the answer into a field that only the renderer ever reads and that only exists on the client copy of the player. That set is filled once on the render thread the first time the sword layer draws, and read here from the server thread, which is an unsynchronised HashSet touched from two threads for a result nothing uses. With this on the server side of the tick returns immediately, the client side is untouched, and the sheathed sword still shows up exactly as before.

Skip banner pattern layers while rendering the shadow map, keeping the base cloth.

Use the vanilla entity buffer source while no shader pack is loaded. Oculus installs its batched entity renderer on every level render whether or not shaders are on, and that renderer rebuilds a translucency graph per frame. With shaders off the profiler puts it at 1.6 percent of the render thread for no visual difference. Turning a shader pack on restores the batched path. Client.

Report items as having no enchantment glint while rendering the shadow map.

Skip entity name tags while rendering the shadow map.

Skip sign text while rendering the shadow map.

Only resend the Fiberglass Cloak action bar indicator every this many ticks. Stock sends a chat packet to the wearer twenty times a second for a two character string that never changes, and the vanilla action bar holds text for sixty ticks anyway. The indicator can appear up to interval minus one ticks late. Set to 1 for stock behaviour.

Only let the Fiberglass Cloak clear nearby mob aggro every this many ticks. Stock runs a twenty four block wide mob scan every tick for as long as the wearer stays cloaked, on top of the four block scan that decides whether cloaking is allowed, which is left alone. A mob can keep targeting the wearer for up to interval minus one ticks longer than stock. Set to 1 for stock behaviour.

Answer the mod's 'is this accessory equipped' helper from the shared per tick curio presence set when the answer is no. CuriosUtil#isEquipped walks every curio slot type and every slot in it, and the damage handler alone calls it ten times for one hit, on the attacker and the victim, so most of those walks are on mobs that own no curio slots at all. A curio swapped without firing CurioChangeEvent reads stale for the rest of that tick.

Only let the Collectible Meal Toy run its mob scan on the ticks it actually does something. Stock scans a box as wide as the configured toy range, twenty five blocks by default, every single tick, while the pathing and particle work inside it is already limited to every tenth and every eightieth tick. A baby undead can stay locked on its old target for up to nine ticks longer than stock before the toy pacifies it.

Remember the Suspicious Bag reward pool instead of streaming the whole item registry through four filters every time a bag is opened or a naturally generated chest rolls one. The pool is rebuilt whenever the bag blacklist or the disabled accessory list changes, and the item registry is frozen after load, so the result and the random rolls are identical.

Only rebuild the Guts and Clay Vessel display names every this many ticks. Both run from the curio tick and the inventory tick, so a Guts sitting unequipped in a backpack still costs a statistics lookup, a String#format and a component to string conversion every tick. The name is cosmetic and can lag up to interval minus one ticks behind. Set to 1 for stock behaviour.

Remember the stealth total a mob gets from its gear for the rest of the tick instead of rebuilding it for every single visibility question. Opposing Force listens on the living visibility event, which the game fires from inside the targeting test, so it runs once for every candidate entity that every mob looks at while it is picking a target, many times a tick for a busy area. Every one of those calls walked all six equipment slots and asked each stack for its full attribute modifier map, and that ask is not free: on Forge it fires the item attribute modifier event, which allocates the event and runs every listener that Curios, attribute mods and gear mods have hung on it, and for a stack that carries attribute modifiers in its nbt it parses the whole list into a fresh multimap first. Six of those per question, for a number that only changes when the mob swaps gear. The total is now worked out at most once per entity per tick and reused for the rest of that tick, empty slots are skipped, and the visibility answer itself is exactly the one the stock handler produced.

Stop the Electrified and Gloom Toxin effect ticks running on the client where they cannot do anything. Both effects tick on both logical sides because that is how mob effects work, and both of them end in a call to hurt the entity, which the client refuses outright, so the client half is pure waste: Electrified builds a fresh damage source out of the damage type registry every single tick for every entity carrying it, and Gloom Toxin reads the block light and the sky light at the entity twice through the light engine before throwing the answer away. With this on the client returns immediately and the server does exactly what it did before, so the damage, the timing and the zap sound are unchanged.

Answer 'is this item one of the guide books' from a per item cache.

Let Pehkui keep its already existing per tick scale cache on the client too. Pehkui only fills that cache on the server, so every client side scale read walks the whole modifier chain again. WARNING: if a mod changes an entity's scale without going through Pehkui's own setters, the visual size can lag by one tick. Turn this off if you see entities stuck at the wrong size.

Stop allocating two throwaway lambdas per scale type per entity per tick.

Work out an entity's interaction box scales once a tick instead of twice for every entity walked by every AABB query. A scale set part way through a tick is seen on the next one.

Remember which scale type a typed scale modifier points at instead of calling its supplier again on every single scale read. WARNING: a mod that swaps the type a modifier resolves to at runtime will be pinned to the first answer.

Stop allocating a throwaway trail config for every entity and every particle.

Ticks between the crimson moon, the mundus and the golden bell handing their effect to everything standing inside them. All three work out a hit tick of their own, every tenth tick, at the top of the loop and then never look at it, so instead of applying on that beat they reapply to every entity inside the aura on every single tick: a fresh effect instance allocated per entity per tick, an add that bumps the duration back up and therefore counts as a change and sends an effect packet to everyone tracking that entity, and on the crimson moon a walk over the entity's persistent moon frenzy mark list and a write back of it every tick on top. Every one of those effects lasts twenty ticks or more, so applying on the mod's own ten tick beat keeps them up with no gap. This is the only patch here that is not behaviour identical: an entity that walks into an aura now waits up to nine ticks for the effect instead of getting it on the tick it crosses the edge, and an entity that walks out keeps it for up to nine ticks longer. 1 restores the stock every tick behaviour.

Stop the black flame wings contact damage sweep running on the client. The wings effect ticks on both logical sides every ten ticks and asks the level for every entity touching the wearer before it looks at which side it is on, then for each one it builds a spell damage source and calls the damage helper, which the client refuses outright, but it also parks a full second of invulnerability on the client's own copy of every entity it touched, and that copy is what decides whether the hurt flash and the hurt sound play, so anything brushing past a player with the wings up goes quiet on that player's screen for a second at a time. With this on the sweep and everything behind it are skipped on the client, the server still deals exactly the same damage, and the wing particles, the mana drain and the fall damage reset are untouched.

Stop the four aura spells sweeping for entities and handing out their effects on the client as well as the server. The crimson moon, the mundus, the golden bell and the frost fog all run their entity search and the loop that follows it straight out of the entity tick with no side check at all, so the client repeats the whole thing every single tick for every one of them that is in render distance: the moon and the mundus ask the level for every entity in their bounding box, the bell builds a box the size of its full radius, and the frost fog asks for every living entity in a box of its own radius on every tick with a fresh predicate each time. Everything the loops then do is server business. Adding a mob effect on the client hands the entity a copy the server is about to overwrite anyway, the crimson moon walks and rewrites a list in the entity's persistent data that only the server ever reads back, the bell asks Iron's Spellbooks whether every candidate is friendly fire, and the frost fog writes freeze ticks that the server owns. With this on the client does none of it and the server does exactly what it did before, so a boss fight standing in an aura costs half of what it used to and the effects, the timings and the damage are unchanged.

Drop the emptied block effect cache entry instead of leaving one map entry and one empty list per block position for the rest of the session.

Reuse the particle's block position for the per tick light lookup while it stays inside the same block.

Emit billboard particle vertices from reusable scratch vectors instead of allocating around ten JOML objects per particle per frame.

Build trail ribbons from float locals instead of allocating about ten vectors per trail segment per frame.

Draw fully opaque pick-up sprites straight to the screen instead of routing every one through a window sized off-screen render target and a full screen blit.

Skip the HashMap, event object and event bus dispatch Placebo builds on every single ItemStack enchantment level lookup while nothing is listening to GetEnchantmentLevelEvent.

Same throttle for the sheepman's flee from zombified piglins goal. That one searches a twelve block box, which is nearly four times the volume of the villager one, and it runs for every sheepman every other tick in a dimension where the thing it is looking for may not exist at all. The reaction delay and the wrapping caveat are the same as for the villager goal. Set to 1 for stock behaviour.

Do not graft the flee from goblins goal onto every villager in the world. Primitive Mobs listens for any entity joining a level and, for every villager, adds a vanilla avoid goal that hunts for goblins in an eight block box. That goal is not free to ask: the goal selector re-evaluates it for every villager every other tick, and each evaluation walks every entity section that box touches, type checks everything it finds and builds a throwaway list, whether or not a goblin has ever been anywhere near. A trading hall is dozens of those queries every tick forever. Villagers also move off their brain rather than their goal list in this version, so the brain's own walk target overwrites the flee path on the same tick it is set and the goal barely changes what a villager does anyway. Turn this on to skip adding the goal at all, which is the stock behaviour minus the feature. Leave it off and villagerGoblinAvoidInterval keeps the feature and just slows the searching down.

Search for goblins around each villager this many goal ticks apart instead of every one. The goal selector asks an idle goal whether it wants to run every other game tick, so stock is one full entity box query per villager per two ticks, and on a normal world every single one of them comes back empty. With this at five a villager that found nothing waits five of those checks before looking again, which is about half a second, so the searching costs a fifth of what it did. A villager can therefore take up to half a second longer to notice a goblin that walks up to it; once it is fleeing nothing is throttled and the goal runs exactly as it always did. Set to 1 for stock behaviour. Note that the goal is handed to the goal selector wrapped, so another mod that goes looking through a villager's goal list for a vanilla avoid goal by type will not find this one; set this to 1 if you use something that does.

Remember which resource paths no pack contains, so a repeated miss stops rescanning every loaded pack.

Stop attaching a persistent data compound to every animal in the world.

Remember what the furnace fuel handler decided for an item instead of walking its 1100 branch block comparison chain again.

Cap the homing speed of the Holy Locket death and life essences. Their arc step scales with both the distance to the target and their own age, so an essence that misses for long enough accelerates without bound until its query box overflows the entity section index and crashes the game.

Upper bound in blocks per tick for that cap. The step is also never allowed to exceed the remaining distance to the target, so the essence stops overshooting and converges instead.

Skip the walk-on-fluid probe for entities that can never walk on fluid.

Stop posting RevelationFix's hurt-by-target events for mobs that ignore them.

Reuse the band search for this many calls instead of redoing it every time. Every ribbit that is not already in a band asks the level for every other ribbit inside a hundred and twenty eight by thirty two by hundred and twenty eight block box, and it asks twenty times a second while its music goal is trying to start, purely to copy a band leader off a neighbour. A ribbit that cannot join because the nearby band is already full never stops asking, so a village with more ribbits than band slots runs that sweep forever from dusk to dawn. With this on the list of neighbours is remembered for ten calls and the leader is still read live off those neighbours, so who joins which band does not change; the list is thrown away and rebuilt early if any ribbit in it has been removed. A ribbit that walks into range can take half a second longer to be seen. Set to 1 for stock behaviour.

Same throttle for the fisherman ribbit's search for water. It is the same twelve thousand block read scan with no cooldown behind it at all, so a fisherman that is standing somewhere without water pays for the whole box every other tick for the entire night. When water is close by the search stops at the first hit and costs almost nothing, so this only bites on the misses, which are the expensive ones. A fisherman can take up to two seconds longer to notice a pond that appears next to it. Set to 1 for stock behaviour.

Stop the server crashing when a player drops the maraca while playing it. The mod keeps a map of players who are performing and looks the audience up out of it without checking that the entry is there. Its own server tick handler drops the entry as soon as the player is no longer holding the maraca, and the player's own tick then ends the use and asks for that same entry a moment later, so dropping the maraca mid tune throws a NullPointerException out of the player tick on the server. With this on the missing entry reads as an empty audience, which is what it means, and the rest of the cleanup runs as normal.

Look for crops to water this many goal ticks apart instead of every one. A gardener ribbit asks for the nearest waterable crop by walking a thirty three by eleven by thirty three block box out from its feet and reading the block state at every position in it, which is close to twelve thousand block reads, and the goal selector puts that question to it every other game tick all night long. In a village with no farm anywhere near it every one of those scans comes back empty and it does it again a tenth of a second later. With this at twenty a ribbit that found nothing waits twenty of those checks before looking again, about two seconds, and the scan costs a twentieth of what it did. A crop that appears next to a ribbit is therefore noticed up to two seconds later, which is nothing next to the twenty second watering animation, and once the ribbit is walking to a crop nothing is throttled at all. Set to 1 for stock behaviour.

Look for screen shaking dragons once per tick instead of once per frame.

Enable matrix tracking on a dragon's bones once per model instead of every pass.

Skip the footfall particle call for a Simply More unique weapon that is not the entity's main hand item. Every unique in the mod calls the shared footfall helper from inventoryTick with no guard at all, for every slot the weapon sits in, on both sides, and the helper bottoms out in Simply Swords' config reader, which reads and parses general.json5 off disk on every single call. The helper's own first check is whether the stack is the main hand item, so a stack in any other slot only ever paid for that file read and did nothing. The step counter still advances exactly as it did, so the particle rhythm when the weapon is drawn is unchanged.

Milliseconds to reuse Simply Swords' parsed config values before reading the json5 files off disk again. Config.safeValueFetch runs a Files.exists check, a full file read and a Gson parse on every single getBoolean, getInt, getFloat and getDouble call, and those sit in weapon tick and hit handlers, so holding one unique weapon is dozens of file reads and parses per second per side. The values are the same, an edit made to a config file while the game is running is picked up up to this many milliseconds later, and the unsynchronised HashMaps the parse writes into stop being rewritten from both logical sides at once. 0 restores the stock read every call behaviour.

Stop the daylight burn handler from rebuilding its entity tag key for every living entity every tick.

Stop the Resisteel set handler from writing five NBT values into every living entity every tick.

Stop the Resisteel sword handler from firing a MobEffectEvent.Remove at every living entity every tick.

Stop the Resisteel tool handler from rebuilding its item tag key for every living entity every tick.

Replace fourteen sorted region scans that only ask whether a mob's own target is close by with one box test.

Narrow the rest of the mob region scans to the players, owners, monsters or flore heads their loop bodies actually use.

Skip Skarrier Mobs' 17 way instanceof chain for entities that are not its own.

Remember the modifier ids the weapon and armor balance handler builds instead of hashing them again every time. The handler listens on the item attribute modifier event, which fires whenever anything asks an item stack what attributes it grants, so it runs on every equipment change, on every tooltip frame and once for every item a recipe viewer indexes, and for a piece of gear the mod rebalances it then builds up to sixteen attribute modifiers in a row. Every one of those needs a uuid, and the mod makes it with the name based uuid helper, which asks the security provider for a fresh MD5 digest and hashes the key string from scratch on every single call. The key is a fixed string per attribute per item, so the answer never changes; it is now worked out once and reused. The uuids themselves are byte for byte the ones the stock helper produced, so nothing about the modifiers or the values on the gear changes.

Skip the connection spell tick for entities that are not part of a connection. SomakeSpells listens on the living tick event, which the game fires for every living entity on every single tick, and the first thing its handler does is ask that entity for its connection link data and its pending transfer queue. Neither of those is a capability lookup that can answer no cheaply: each one reaches into the entity's Forge persistent data, allocates a wrapper object and pulls out a compound tag that is almost never there, so a world with a few hundred mobs in it was throwing away four objects per mob per tick to find out that nothing is linked to anything. Links only exist while one of the three connection spells is running on a pair of entities, which is a handful of mobs at most and usually none at all. With this on the handler returns immediately unless the entity actually carries one of the mod's three connection tags, and an entity that does carry one is handled exactly as before. The client side of the tick, which the handler already refused to do anything with, now stops before the persistent data is touched at all.

Read the mod's despawn timer without writing to every entity that does not have one.

Stop the Species living entity render listener from running a second time after every entity has already been drawn. The mod subscribes its big disguise renderer to the abstract parent of the render living event instead of to the pre variant, and Forge hands a parent listener both the pre event and the post event, so the whole body runs twice for every living entity on screen every frame. The second run is not just wasted work: the post event is not cancellable, and the disguise branch calls set canceled on it, which throws an unsupported operation exception straight out of the entity render dispatcher, so anything wearing a wicked mask with a stored mob id can hard crash the client. With this on the listener returns immediately unless the event really is the pre one, which is the only phase the code was written for, so the crash goes away and the per entity per frame cost of that listener is halved. Turn it off for stock behaviour.

Let a limpet look for players to be scared of this many ticks apart instead of every tick. Every limpet that is not already fleeing asks the level for every player inside an eight by eight by eight block box every single tick, allocating a capturing filter and a consumer each time, purely to push its scared timer back up to one hundred ticks. Since the timer only counts down one per tick, refreshing it ten times a second is a hundred times more often than it needs to be. With this at ten a limpet can take up to half a second longer to notice a player walking up to it, and once it is scared it stays scared exactly as long as before. Set to 1 for stock behaviour.

Stop the Species status effect tick handler from running on the client. The mod injects into the head of the living entity effect tick, which runs for every living entity every tick on both logical sides, and it rolls its own random number there and plays the gut feeling roar directly, so the client rolls once and the server rolls again and broadcasts, and the roar ends up firing about twice as often as the mod's own one in two hundred chance says it should. The other branch in that handler already refuses to do anything unless it is on a server level, so nothing else is lost. With this on the handler is skipped entirely on the client, which removes the duplicated roar and two hash map lookups per living entity per client tick. Turn it off for stock behaviour.

Let a wicked look for its haunted mob this many ticks apart instead of every tick. A wicked that has a haunted target id saved but has not found the mob object yet asks the level for every mob inside a forty by forty by forty block box, with a filter that allocates two fresh lambdas each time, and it does that twenty times a second on both the client and the server. That search is only there to reconnect the wicked to its victim after a load, so it normally succeeds on the first try, but if the victim died, despawned or is sitting in an unloaded chunk the id never clears and the wicked runs that sweep forever. With this at twenty the reconnect can take up to a second longer and the hopeless case costs a twentieth of what it did, and once the wicked is holding its victim again nothing is throttled at all. Set to 1 for stock behaviour.

Milliseconds between full rescans of the fish radar overlay. The radar keeps a counter of how long it has been since it last rebuilt its list and rebuilds when that counter passes a hundred, but nothing ever puts the counter back to zero, so from the very first frame the radar is on screen it rebuilds the list again on every single frame instead of every five seconds. A rebuild walks the entire fish registry, which is around a hundred and thirty entries in this pack before any addon datapacks, and for every entry that has a guide page it runs the full catch chance calculation, which allocates a bait container and then evaluates every restriction that fish carries, biome, dimension, height, weather and time of day included. With this on the rebuild is allowed through at most once per interval and the list is kept in between, which is what the counter was written to do. 0 restores the stock behaviour of rebuilding every frame.

Do not let a missing player profile take the server down when a tournament ends. The tournament tick runs once a second, and when a tournament runs out of time it looks the winner up in the server's game profile cache and calls get on the Optional without checking whether anything came back, so a winner whose entry is not in the cache, an offline player whose cache entry has expired, a score added by command or a usercache that was deleted between the tournament starting and finishing throws out of the server tick and kills the server. With this on the announcement falls back to the same question marks placeholder the mod already uses when it has no winner uuid at all, and everything else about the tournament ending is unchanged.

Stop rebuilding a structure set's entry list on every read.

Resolve Structurify's per structure set config lookup in one hash lookup.

Replace Structurify's terrain height cache with a primitive keyed one.

Collect overlap check section keys without boxing them.

Skip Structurify's structure check bookkeeping when none of its checks are enabled.

Restore vanilla's plain getStartForStructure while Structurify's checks are idle.

Stop scanning biome particle positions that no setting can spawn at.

Test the firefly light condition before the biome lookup instead of after it.

Skip the geyser scan on blocks no geyser type can spawn on.

Drain the ticker removal queue in one pass instead of one ArrayList#remove each.

Keep the Stardust Dragon's list of body parts for five ticks instead of running a 128 block wide entity scan once or twice per tick per dragon head. The list is refreshed whenever a part spawns or goes away, and rescanned on the same five tick cadence the dragon already uses to repair its body chain.

Remember each player's owned minion list for the rest of the tick. MinionHelper#getOwnedMinions is a 256 block wide entity scan plus a sort, and almost every minion asks for it every tick to work out its formation slot, on top of the per player tick handlers, so ten minions were ten to fifteen of those scans a tick. The list is dropped the moment any minion joins or leaves the level, so summoning, dismissing and slot counting inside the same tick still see the real state.

Answer the Soloist's Seal, Polychromic Necklace and Conductive Battery 'is it equipped' checks from the shared per tick curio presence set when the answer is no. The seal and necklace checks run for every player every tick and the battery check on every minion hit, and each one walked every curio slot and built a list. A curio swapped without firing CurioChangeEvent reads stale for the rest of that tick.

Only let an idle minion scan for a new enemy every this many ticks, staggered per minion. Every minion without a target scans a minion range wide box of mobs every tick and streams for the closest one. A minion can react up to interval minus one ticks later than stock. Set to 1 for stock behaviour.

Remember the Copper Drone's two attribute modifier ids instead of rebuilding them from an MD5 of the entity uuid twice per drone per tick.

Only send the summon slot sync packet when the used slot count actually changed. Stock sends it to every player four times a second forever.

Skip the enderman skull's 64 block look ray when no player is aiming anywhere near it.

Cache the tinted map block lookup instead of walking five tags per map pixel per tick.

Only run Supplementaries' antique ink chunk sync for signs instead of every block entity in every chunk sent.

Cache TerraBlender's per-block namespace lookup for the duration of a biome.

Answer Terra Curio's 'is this accessory equipped' questions from the shared per-tick curio presence set instead of walking every curio slot handler again. CuriosUtils#noSameCurio runs once per living entity per tick out of LivingEntity#getFrictionInfluencedSpeed, and about ten more times per damage event, and almost every one of those is a miss.

Read Terra Curio's custom attribute remap table from a plain map instead of the synchronised Hashtable it lives in. The table is filled once during setup and never written again, but ModAttributes#hasCustomAttribute is called for every living entity every tick on both the client and the server thread, so every one of those calls takes a monitor on the same shared object.

Skip Terra Curio's aggro retarget pass while no online player carries a non zero aggro value. The handler runs on every LivingChangeTargetEvent, and each run streams every player in the dimension with a distance and canAttack check, even though the result can only differ from vanilla when some player has actually modified aggro. The player scan is cached once per dimension per tick.

Only write Terra Curio's onPosIsIce flag when it actually changes. Ice Skates, Frostspark Boots and Terraspark Boots rewrite the flag onto the stack every single tick, which marks the stack dirty, so Curios resyncs the accessory to the client and reapplies its attribute modifiers every tick for as long as the boots are worn.

Keep Terramity's screen shaders to your own player and to shaders Terramity loaded.

Reuse the answer when a Terramity procedure raytraces the same ray twice in a row.

Bail out of Terramity's armour animation handler before it re-reads your equipment.

Skip the four Terramity accessory tick procedures on the client, where they do nothing.

Skip Terramity's entity animation handler for entities that are not Terramity's.

Bail out of Terramity's held item animation handler before it copies your hands.

Skip the typewriter mode lookup for text that has no typewriter on it. The decomposer reads the typewriter mode option at the top of every call, before it has looked at whether the style it was handed even has a typewriter track, and the answer is only ever used when there is one, which is almost never. The lookup itself reaches into the client's option instances, so on a single player world the server thread ends up reading the client's options too. With this on the option is only read when the style actually carries a typewriter track, which is the only case the value could have changed anything in.

Stop every angle bracket in the game's text being parsed as an effect tag and thrown away through an exception. Text Animator replaces the vanilla string decomposer outright, which is the method every single piece of text in the game goes through to be measured, wrapped and drawn, and in its replacement every < it meets starts a scan forward for the matching >, splits whatever is between them and hands the first word to the effect factory. If that word is not one of the fifteen effect names the mod knows, the factory throws, and building that exception walks and copies the whole call stack, which inside the font renderer is dozens of frames deep. Any text with a bracket pair in it, a chat line a mod formatted as one string, a quest description, a book page, an item name, pays that on every measure and every draw and so several times a frame for as long as it is on screen. With this on the first word is checked against the effect names before any of that happens, and a tag that is not an effect is handed back as no tag at all, which is exactly the same result the exception path produced, just without the exception, the split and the string building. Closing tags and effect tags are untouched and still work.

Drop the stack trace from the unknown effect type error. The effect factory throws this exception for every tag name it does not recognise and every caller in the mod catches it and ignores it, so the stack trace it fills in is never read by anything and only ever costs time. With this on the same exception type with the same meaning is thrown without capturing a stack, which is the whole cost of it. This is the backstop for the paths skipUnknownEffectTags does not cover, the typewriter prefix check and the style deserializer.

Read the machine facing from the block entity cached block state instead of asking the world for the block state two to four times per call. getFacingDirection runs on every item and fluid capability query against a Titanium machine, so every adjacent pipe, hopper or machine pays it. The game keeps the cached state in sync whenever the block state changes.

Remember the recipe list RecipeUtil hands out instead of looking the recipe manager map up by reflection and copying every recipe of that type into a fresh list on every call. The Stonework Factory asks for one every tick and the Resourceful Furnace asks for the smelting list three times per setChanged. The cache is keyed on the recipe map itself, which the game replaces on every datapack reload, so a reload is picked up. The returned list is now immutable and shared.

Stop the sided inventory push and pull from scanning every slot of the neighbouring inventory when the slot it tried to take from was empty. The destination scan runs before the empty check, and it calls isItemValid on every target slot, which on filtered or recipe backed inventories is not cheap. The result is unused in that case.

Skip the block entity dirty flag when a machine progress bar is written with the value it already holds. An idle machine re-writes progress zero every tick, and every one of those writes marks the chunk unsaved and runs a comparator neighbour update on four sides. On Industrial Foregoing it also re-runs whatever the machine overrode setChanged with, which for the Resourceful Furnace and the Dissolution Chamber is a full recipe lookup. Progress itself is unchanged, so the bar, the container sync and comparator readings are identical.

Skip the Frostbite entity scan on the client, where it cannot do anything.

Look the attribute up once instead of three times.

Run each of the seventeen PlayerTickEvent listeners once a tick instead of twice.

Stop every player broadcasting a pointless attribute sync packet every tick.

Build a frame's item tag keys once instead of rebuilding the whole list from strings on every tooltip match.

Answer the mega torch and dread lamp spawn block question out of a handle held on the level instead of walking the level's whole capability dispatcher every time it is asked. Torchmaster hooks the spawn finalise event, so every single mob the game is about to place, from natural spawning, from spawners and from structures, goes through it, and the first thing it does is ask the level for its light registry capability, which walks every capability provider any mod has attached to that level, then wraps the answer in a lazy optional map call that allocates a lambda, an Optional and a boxed Boolean before the registry has even looked at a torch. The registry hands itself to the level once per tick from its own cleanup pass, so after the first tick of a dimension the question is one field read and one virtual call. A dimension with no torch or lamp placed in it now answers no without allocating anything at all. The answer is exactly the one the stock lookup produced, and a level whose registry has not introduced itself yet, or whose registry comes from some other mod, still goes down the stock path.

Test the distance to a mega torch before looking the entity up in its block list. The registry asks every torch in the dimension in turn whether it blocks this spawn, and each torch checks the block list first: that is a reverse registry lookup to turn the entity type back into an id and then a hash set lookup, paid for every torch in the dimension on every spawn attempt, only to be thrown away by the distance test right after it when the spawn is nowhere near that torch. The distance test is three subtractions and three compares against the configured radius and it is what rules out almost every torch, so it now runs first. Both tests are unchanged and a spawn is blocked in exactly the same cases as before; a spawn that is actually inside a torch's radius pays the distance test twice, which is the cost of not paying the block list lookup for all the torches that are far away.

Look the transmogged appearance up by the tag it is stored in instead of hashing that tag every time. Transmog keeps the appearance item you picked as a full item stack written into the real item's NBT, and every time anything needs to draw that item it asks the mod to turn that NBT back into an item stack. The mod does cache the result, but it keys the cache on the hash code of the appearance NBT, so every single lookup walks the whole appearance compound, tag by tag, to compute that number, boxes it into an Integer and allocates a lambda, and then does it again for the next lookup. A player wearing transmogged armour pays that for every armour slot on every frame, and the item renderer asks three separate times for every item it draws, so a few people in transmogged gear on screen is thousands of full NBT walks a second. Two smaller problems come with it: the cache is one shared access ordered LinkedHashMap touched from the render thread and the server thread with no locking, which is the kind of map that can corrupt itself or spin forever when two threads read it at once, and because the key is only a hash code, two different appearances that happen to hash the same silently render as each other. With this on the lookup is keyed on the stored NBT compound itself, per thread, so a repeat lookup is a single reference compare with no walking, no boxing and no allocation, nothing is shared across threads, and a hash collision cannot swap two appearances any more. The appearance you see is unchanged. Turn it off for stock behaviour.

Check that the entity is a spell casting mob before reading its effect map in the Blackout and Casting handlers.

Check for the Spider Aspect effect before walking every living entity's curios inventory every tick.

Answer the Waist Warmer curios lookup from the shared per tick curio presence cache instead of walking the inventory for every living entity every tick.

Stop the Suspicious Mushroom and Rose of Temptation handlers from attaching an empty ForgeData tag to every entity in the world.

Answer repeated biome lookups on the render thread from a small per tick cache. Fog and sky colour sample 27 biomes per call, several times a frame.