large

pistons are laggy as fuc

abt 25uS/block on avg

block arrival is a bit better at 20uS/block

end crystal was on average 10uS/block, not including the vast majority of time spent doing raycasts and hardness calculations and entity damage. to have multiple end crystals worth of glass, we would need to include this time, making the average time much higher

dragon egg is 5uS/block

Open problem: perform a falling block swap in 1.13 remove or add some stained glass in the glass chunk prior to or during tile ticks to start the threads. load a chunk on the main thread to cause a rehash right before the sand tt is executed, and hope the glass thread is doing an access at the same time. if it is, the chunk map will return null to the glass thread and it will start loading the chunk asynchronously. Next the sand tt is run on the main thread. if all goes well, the async chunk loading will finish while the sand is in the middle of its tt code, and when the sand creates its entity it will get the block from the chunk loaded from disk.

solved: impossible bc synchronized 😦

We now have a chunk swap setup in the nether based on rehash method that works in singleplayer and requires no cluster chunks.

Open problem: player head setup coolman demonstrates in this video how the ItemSkull use code has a race condition where it takes the damage value of the shield asynchronously placed into the inventory by the dispenser, turning it into a player head. the challenge in performing this in survival is that the shield dispense code and the ItemSkull onuse code need to be briefly stalled at the correct times in order for the race to become feasible. This involves stalling the shield dispense code as its looking for entities to dispense to via adding more entities to the chunk, and stalling the use skull code when its finding the blockstate at its position to determine if it can be placed there.

Here is the code relevant to the player head: In Item Skull we have

public EnumActionResult onItemUse(EntityPlayer stack, World playerIn, BlockPos worldIn, EnumHand pos, EnumFacing hand, float facing, float hitX, float hitY)
    {
        if (hand == EnumFacing.DOWN)
        {
            return EnumActionResult.FAIL;
        }
        else
        {
            IBlockState iblockstate = playerIn.getBlockState(worldIn); [<-- THIS CAN BE SLOWED DOWN USING CLUSTER CHUNKS OR BY TRIGGERING POPULATION]
            Block block = iblockstate.getBlock(); 
            boolean flag = block.isReplaceable(playerIn, worldIn);

            if (!flag)
            {
                if (!playerIn.getBlockState(worldIn).getMaterial().isSolid())
                {
                    return EnumActionResult.FAIL;
                }

                worldIn = worldIn.offset(hand);
            }

            ItemStack itemstack = stack.getHeldItem(pos); [<-- THIS IS THE END OF THE RACE CONDITION]

In ItemArmor we have

public static ItemStack dispenseArmor(IBlockSource blockSource, ItemStack stack)
    {
        BlockPos blockpos = blockSource.getBlockPos().offset((EnumFacing)blockSource.getBlockState().getValue(BlockDispenser.FACING));
        [THE RACE CONDITION STARTS WHEN THE FOLLOWING LIST GETS CREATED]
    List<EntityLivingBase> list = blockSource.getWorld().<EntityLivingBase>getEntitiesWithinAABB(EntityLivingBase.class, new AxisAlignedBB(blockpos), Predicates.and(EntitySelectors.NOT_SPECTATING, new EntitySelectors.ArmoredMob(stack)));
    [LIST CREATION CAN BE SLOWED DOWN BY HAVING MANY ENTITIES IN THE CHUNK]
        if (list.isEmpty())
        {
            return ItemStack.field_190927_a;
        }
        else
        {
            EntityLivingBase entitylivingbase = (EntityLivingBase)list.get(0);
            EntityEquipmentSlot entityequipmentslot = EntityLiving.getSlotForItemStack(stack);
            ItemStack itemstack = stack.splitStack(1);
            entitylivingbase.setItemStackToSlot(entityequipmentslot, itemstack); [<-- THIS IS THE END OF THE RACE CONDITION]

            if (entitylivingbase instanceof EntityLiving)
            {
                ((EntityLiving)entitylivingbase).setDropChance(entityequipmentslot, 2.0F);
            }

            return stack;
        }
    }

The ItemArmor code gets used by the shield items.

We want to start the ItemArmor code on the async thread. It will create a list of entities to which it can equip the shield. The list should first enter the player into the list, and then the async thread should be lagged out by having many other entities in the chunk that needs to be checked for the list. While the async thread is lagged out, on the main thread the player should switch a skull from the main hand to the off hand, and then use the skull and start the ItemSkull code. The getBlockState call in the ItemSkull code should be lagged out as much as possible, so that the async thread lag stops while the main thread is in the getBlockState call. The async thread will then do the setItemStackToSlot() call and replace the skull items by a shield of damage value 3. Later the main thread will continue the ItemSkull code, but since the item in the players offhand now has damage value 3, that will place a player head.

Open problem: insert a shield into a jukebox If someone wants to try dm me for details, but it's very similar to player head

Open problem: overstacked items in 1.12.2 using async droppers

Solved. It's stupidly easy

How many items can you overstack? This should be the challenge

Difficulty grows exponentially with more items. Not much you can do to better the odds. Putting many nbt tags on the item to make it take longer can help a little bit but with diminishing returns bc its not actually in the critical section of the code.

Open Problem: Falling Block in highly modded 1.12 minecraft I would like to see whether falling block works with large modpacks, and whether word tearing can be used to skip past the long progression systems that modpacks tend to have. For this it would be good to develop one worldfile in which one can efficiently test which various core bugs still work as in vanilla. The worldfile should contain independent contraptions for Update suppression, Terrain population manipulation, Savestates, Instant Tile Ticks, and so on. Once we have such a world we can quickly figure out which mechanics work in which modpacks, by installing the modpack, and then executing the contraptions in the world and seeing whether they work. This allows us to quickly figure out whether falling block can work in the modpack, without having to read the modpack code. Other than that, does anyone have good suggestions for which modpacks would be interesting? Currently I'm considering FTB Ultimate Reloaded ( https://www.feed-the-beast.com/modpacks/36-ftb-ultimate-reloaded ) because it seems the most standard large modpack imaginable, and maybe SevTech: Ages ( https://www.curseforge.com/minecraft/modpacks/sevtech-ages ) because that modpack claims to have a very long progression tree, which we could hopefully skip with word tearing.

Open Problem: 1.13 Falling Block or Word Tearing We need beacon threads to cause an async chunk reload. If it populates an end city we can get async comparator updates from it: https://discord.com/channels/961702940102504518/961715982802501672/1045025872408744078

Open Problem: Byrus 1.14.4 using falling nether portals

Open Problem: 1.12 random seed peaceful speedrun

This thread is about doing falling block in skyblock maps.

This will just be a subthread dedicated to figuring out the details of clustered rehash chunk swaps.

The any% TAS world record uses version 1.8 and uses a Credits Warp: This credits warp could be improved by using permasuppressed redstone dust, similar to how it's used in 1.12 any% speedruns: But nobody has made a setup for 1.8 redstone permasuppression so far. So I am creating this open problem thread for it, until someone makes it. An async line setup for 1.8 is here: However there is one big problem with this setup: It breaks the River Biome Decorator. For speedrunning applications it would be much preferable to have a way to turn on 1.8 permasuppressed dust without destroying any Biome Decorators. This means: We need to make a 1.8 async line setup in the Nether, because there are no decorators there. And that's the whole open problem: Make a 1.8 async line setup in the nether, and point the end of the async line into some redstone dust. If you do this, the world record for any% TAS in minecraft can be improved.

If a chunk with tile ticks in it is saved, and that chunk is loaded on one thread, while another thread is executing tile ticks, the chunk can sometimes be regenerated.

Biome.BIG_TREE_FEATURE is a protetced static final

WorldGenBigTree

shared by every biome in the JVM.

generate

keeps its state in instance fields. if we freeze giant oak tree generation on the async thread, and then populate a chunk chunk with the main thread while stopping a big tree from generating, a failed

validTreeLocation

call overwrites

world

and

basePos

. when

generateLeadNodeBases

runs on the async thread, it re-reads

basePos

, but

foliageCoords

is old position. when the async tree generates,

limb

creates a giant branch from the new position to the old one (confirmed). because it also sets

world

, it should be able to place blocks cross world and could potentially carry the async line across worlds (unconfirmed). credit @Matthew Bolan

A few guys want an open thread here, so they get it. https://cdn.discordapp.com/attachments/1555590693332713513/1555590702660976741/Screenshot_2026-10-02_164135.png?backend=b2&ex=6ac1143c&is=6abfc2bc&hm=5f1938ba09078bec4ee3f0090a4401e32875401da6a5a0dd01482f627a5a9153&