Crashy! is a survival-friendly toolkit for Sable, the sub-level physics library. Sable gives Minecraft real rigid-body physics but deliberately adds no way to use it in-game — Crashy! is that way. Seven items and blocks, one gameplay loop, and a lot of rubble.
Important
Sable is required. Crashy! does nothing on its own. Install Sable and its own dependencies alongside it.
1. Glue it. Hold Construction Glue in your off-hand and build normally — every block you place is bonded to the ones it touches. Glued blocks glow with an outline while the glue is in your hand, so you always see exactly what counts as "the build".
2. Switch on physics. Put a Physics Activator on the build and right-click it with an empty hand, or feed it redstone. The whole glued group becomes one real rigid body: it falls, it tumbles, it collides with the world.
3. Launch it. Right-click the object with the Launcher to pick it up — it floats in front of you. Hold right-click to charge up to power 10, let go, and watch it go.
4. Watch it come apart. Whatever it hits shatters into loose physics blocks, and so does the object itself. The debris carries the momentum of the crash, arcs away from the impact, bounces, and eventually settles back into the world as ordinary blocks.
Bonds blocks into one rigid structure. Glue is stored per-world and survives reloads.
| Action | Result |
|---|---|
| Hold in the off-hand while building | every block you place is glued and merged with the glued blocks it touches |
| Right-click a block | place one corner of an area |
| Right-click a second block | bond everything in the box between the two corners into one group |
| Left-click a glued block | take the glue off that group |
| Sneak + right-click | cancel a selection in progress, or dissolve the group under the cursor |
Glue never breaks blocks. Gluing is a lot of clicking at close range, and a mis-aimed left-click used to take a chunk out of the build you were bonding — a tool for holding things together should not be the fastest way to knock them apart. Left-click undoes the glue instead, which is where a hand goes to undo something. Only the hand holding the glue is stopped, so glue in the off-hand and a pickaxe in the main hand mines exactly as it always did.
The two-click area is Create's Super Glue gesture, deliberately: it is the interaction players coming here already have in their fingers. A green box follows your cursor while you pick the second corner and turns red the moment the selection is one the server would refuse, so you see the limits rather than discovering them after the second click. One point of wear covers the whole area, however big it was.
Blocks standing apart inside one selection still come out as a single group — a selection is a statement that these blocks are one thing, whether or not they touch. Clicking the same block twice glues just that block.
Place it on a finished build and switch it on with an empty-hand right-click or a redstone signal. The glued group it touches becomes a live physics object.
If nothing nearby is glued, the activator falls back to gathering every physically connected block — that can be turned off in the config.
To put an object back into the world, right-click it with the activator item. Physics switches off, the build snaps to the block grid, and it stays glued so you can activate it again.
| Action | Result |
|---|---|
| Right-click a physics object | grab it — the object floats in front of you |
| Hold right-click | charge up, power climbs from 1 to 10 (shown in the action bar) |
| Release | launch along your line of sight |
| Sneak + right-click | put the object down |
Power 10 is roughly 80 m/s by default.
The table opens one of two screens, decided by whether a glued build is touching it.
| Where it stands | What it does |
|---|---|
| Glued to a build | previews it, takes a name for it, and writes it to schematics/ — and onto a blank schematic in the slot |
| On its own | lists the schematics folder; pick a file with the wheel, feed it a blank, press the tick |
Files are ordinary .nbt structures, the same format the vanilla structure block uses, so they are
interchangeable with structure blocks, Create and Litematica's converter. The folder is yours —
next to options.txt in your own game directory, whether you are in single player or on somebody
else's server. Drop your own files in and they show up in the list a moment later.
Sending one back up to a table is what the progress bar measures: bytes delivered, a packet a tick, so a big schematic honestly takes longer than a small one.
A written schematic in hand:
| Action | Result |
|---|---|
| Right-click a block face | pin the hologram there |
| Right-click the air | open the schematic screen — turn it, unpin it, see what it costs, and in creative build it |
| Sneak + right-click | unpin it |
Settings live in two places: F7 for the world's destruction rules, and Mods → Crashy! → Config for the config file. The mods-list one only has values to show once a world is loaded, since the config is per-world.
In survival there is no Build button: the hologram is the plan and you lay the blocks yourself. Blocks you have already placed drop out of the ghost as you go. In creative the button is there and puts the whole build down at once, already glued, skipping any spot that is already occupied.
The Materials page on that screen lists every item the build costs, most first, against how many you are carrying. It counts items rather than blocks — a door is two blocks and one item, a double slab is one block and two.
Scaffolding that glue runs through but physics does not.
It glues to its neighbours like any other block, so one activator still reaches everything standing on it. What it does not do is come along: when you switch the build on, structural blocks stay exactly where they are, and whatever was resting on them lifts off as its own object.
That is what it is for. A platform with four houses on it used to be one enormous rigid body, because glue is what decides what "the build" is and the platform glued them all together. Put structural blocks under the houses, press the activator once, and you get four houses to throw at each other over a platform that stays put — and can be used again, because crashes cannot break it either.
The same trick separates anything: a cube and a sphere side by side become two objects rather than one, as long as the only thing joining them is structural.
Up to 256 objects per activation by default, since each one is a physics body — maxObjectsPerActivation
in the config.
If your builds come alive already leaning, turn on clearStructuralOnActivation. Left standing,
a structural block is something the object it just released is resting on, and the physics resolves
that overlap by pushing. With the option on the scaffolding is taken away the moment the build lifts
off and dropped back to you as items — nothing to lean against, at the cost of laying it again for the
next run.
Builds a schematic for you out of real materials, in survival.
- Pin the schematic where the build should go.
- Drop it into the cannon, along with some gunpowder.
- Put chests, barrels or hoppers anywhere in the 3×3×3 around the cannon and fill them.
- Press the button.
It works up from the bottom row at ten blocks a second, glues everything it places, and steps over anything already standing rather than clearing it. Run out of a material and it stops, shows you the item it wants and says so in the action bar; top the chest up and it carries on. One gunpowder covers 128 blocks. A schematic may be pinned up to 128 blocks away, in the same world. All four numbers are in the config.
F7 (rebindable in the controls menu) opens the world's destruction panel.
| Mode | What happens |
|---|---|
| Instant | Everything inside the blast radius shatters, whatever it is made of. |
| Realistic | Impact force is measured against each block's blast resistance. A power-8 hit scatters planks across the whole crater but only chips cobblestone near the middle, and obsidian shrugs it off entirely. |
| Indestructible | Nothing breaks. Objects still fly and bounce off the world. |
Plus sliders for block toughness, crater size, debris scatter and launch speed, and toggles for world destruction, TNT blasts, debris settling and whether crashes hurt entities.
Bedrock is never destroyed, in any mode, along with anything else that cannot be mined — barriers, command blocks, end portal frames. Obsidian survives Realistic mode but not Instant, which breaks whatever is inside the radius by design.
Vanilla blast resistance is a poor guide on its own — glass and stone are both 6 — so four block tags decide the rest. The shipped defaults are a starting point; a modpack is expected to add to them, which is the whole reason they are tags.
| Tag | Effect | Ships with |
|---|---|---|
#crashy:indestructible |
never breaks, in any mode | spawners, vaults, beacons, reinforced deepslate |
#crashy:fragile |
comes apart at a quarter of its blast resistance | glass, leaves, pots, banners, carpets |
#crashy:reinforced |
holds together at three times it | obsidian, netherite, anvils, enchanting tables |
#crashy:explosive |
goes off when a crash reaches it | TNT |
#crashy:indestructible is checked before the mode, so a spawner survives Instant too.
Server spawn protection is respected, and protectedSpawnRadius adds a flat no-crash zone
around world spawn that applies in single player as well.
Two game rules sit on top of the F7 settings and always win, because a rule can differ between dimensions and be flipped by a datapack without anyone opening a screen:
crashyDestruction— may crashes break blocks herecrashyEntityDamage— may crashes hurt entities here
A crash damages the mobs and players caught in it, scaled off the same blast force blocks are weighed against — so it already accounts for how heavy the object was and how fast it was going. At full launch speed, at the centre, before armour:
| Object | Damage |
|---|---|
| 1 block | ~10 |
| 20 blocks | ~27 |
| 400 blocks | ~49 |
| a TNT charge in your face | ~32 |
It falls off with distance and throws you clear. Fast-moving debris hurts on the way past too. It goes through an ordinary damage source, so armour, resistance and invulnerability all work.
This is deliberately independent of the destruction mode: Indestructible is a promise about the
world's blocks, not about you. Turn it off on F7, with hurtEntities in the config, or per
dimension with crashyEntityDamage. For a build server, hurtPlayers = false leaves mobs breakable
and players safe.
Cobweb stops a physics object the way it stops you: a quarter of the horizontal speed and a twentieth of the vertical, every tick it is in one, spin included. Objects bigger than a 4096-block box are skipped, since a cobweb does not plausibly stop a cathedral.
A crash into water makes a very large splash rather than a crater, and sounds like it — water
carries a hit far better than air does. A crash into lava sets fire to what it splashed over. Both
are under [fluids]; waterDamping = 1.0 turns the first off.
For operators — most of what goes wrong with a big crash is a question of numbers.
| Command | What it does |
|---|---|
/crashy stats |
live debris, blocks queued to shatter, support checks waiting, objects being watched, physics bodies per dimension |
/crashy debris settle |
turn every shard back into a block right now |
/crashy queue clear |
drop pending shatter work |
Settings live in the world and are shared by everyone on the server. Only operators — or the host of a single-player world — can change them; everyone else sees the panel greyed out.
When a launched object ploughs into ordinary blocks:
- the object itself breaks apart — each shard becomes its own physics body and carries the momentum of the crash;
- the blocks it hit break the same way — crater size scales with speed and launch power;
- a custom impact sound plays, and real block shrapnel, a ground-hugging dust ring and sparks come with it;
- once the debris comes to rest it turns back into ordinary world blocks, because otherwise every shard would stay a live rigid body forever and the server would grind to a halt.
An object too big to disintegrate does not explode into confetti — only the region that actually took the hit breaks off. That is both cheaper and more convincing.
Fly an object into TNT and the charge goes off instead of a vanilla explosion. The block is removed by hand, so nothing gets deleted: the surrounding blocks survive and are thrown much further instead. Nearby TNT chains, up to 24 charges per crash.
A charge that goes off leaves the ground burning — spots around it that could hold a fire catch, a
third of them by default, sharing one budget across the whole crash. Never next to a charge that
survived the sweep, since fire would prime it into a vanilla explosion. blastFireChance, 0 to turn
it off.
A charge needs a real hit, not any hit: below 24 m/s — roughly a power-3 launch — nothing goes off, however close it is. Brushing past a stack of TNT while parking an airship should scuff it, not level the area. The threshold is minDetonationSpeed in the config.
TNT you light yourself never goes near a crash, so it used to behave exactly like vanilla: the blocks in range simply stopped existing. Now any explosion — lit TNT, a creeper, an end crystal — throws what it breaks. Those blocks come off vanilla's demolition list before it acts on them, fly as debris and settle back into the world where they land, so the blast rearranges the place instead of deleting it. Nothing drops as an item, because the block itself survives.
Some of it is still left to vanilla, on purpose: anything with a block entity, so a chest spills its
contents properly; torches, grass and other flimsy things, which look right breaking the way they
always have; and anything explosive, which the blast has to prime for a chain of TNT to stay a
chain. Past explosionDebrisMax (64) blocks the rest of a big blast breaks the plain way too,
nearest the centre flying first, so the crater is always the part that flies.
explosionDebris turns the whole thing off. explosionDebrisSpeed is how hard a TNT-sized blast
throws; bigger explosions throw harder and smaller ones softer, in proportion to their radius. It is
also off whenever the world's own rules say the ground is not to be rearranged — Indestructible
mode, the world destruction toggle, the TNT toggle, or crashyDestruction off in that dimension. In
every one of those cases the explosion still happens, vanilla just handles the blocks.
A crash used to break exactly what its radius covered, so a shot through a building's pillars left the building hanging over the hole. Once the dust settles, the blocks bordering the crater are asked what they are still connected to. Anything standing on the ground reaches the terrain and is left alone; a piece that runs out of neighbours first is touching nothing, and it falls.
It falls as debris rather than as a permanent object: it hurts what it lands on and settles back into blocks where it comes to rest, and it does not break more blocks on impact — which is what stops one collapse from starting the next.
The walk is what keeps this cheap, and maxCollapseBlocks (256) is both how much may come down as
one piece and how far the walk looks before deciding a piece is simply part of the world. One walk
remembers what it proved anchored for the rest of the tick, and at most one piece is assembled per
tick, however many walks collapseChecksPerTick allows. Unloaded chunks, protected ground,
unbreakable blocks and anything already being simulated all count as anchors.
Every block a crash breaks becomes a rigid body, and a rigid body costs a Sable plot, a chunk and an
entry in the physics pipeline — which is why the ceiling on live debris is counted in bodies. Blocks
broken next to each other are welded into one piece of up to debrisClusterSize (4) blocks, so the
same ceiling buys four times the destruction and a wall comes off in slabs instead of in identical
cubes. Set it to 1 for one body per block.
A crash landing near you moves the camera, scaled by how big it was and how close you are. Only the
camera: aim, hits and everything the server sees are untouched. Servers can stop sending it with
screenShake; players decide how much of it they want with screenShakeScale in
config/crashy-client.toml, 0 for none.
maxObjectsPerPlayer (12) and maxBlocksPerPlayer (4096) are what one person may keep in the air
at once, counted both ways because twelve cabins are not twelve airships. Every other budget in the
mod belongs to the world and is shared; without these, one player activating airships all afternoon
spends everybody's. 0 removes either limit. Redstone-driven activation has nobody to charge and
falls under the world's own limits, and so does single player, LAN worlds included: the allowance
divides a server between the people on it, and there nobody is sharing.
Ground somebody else owns is left alone. Before breaking a block of the world, the mod checks its
own spawn protection, then fires CrashyBreakEvent for addons, then — when the crash traces back to
a player who is online — NeoForge's own block break event, which is the hook claim mods already
listen to. Land protected from a pickaxe is protected from a falling airship, with no dependency
between the mods in either direction. respectClaims turns that last step off.
Glue is repaired with slime and the launcher with iron, on an anvil.
- Minecraft 1.21.1 with NeoForge 21.1.0+
- Sable 2.0.0+ and its dependencies (Veil, Forge Config API Port)
- Drop
crashy-1.21.1-1.3+neoforge.jarintomods
Sable is an intrusive, mixin-heavy mod and can conflict with other mods that touch world rendering or chunk handling. If something breaks, check whether Sable alone reproduces it before opening an issue here.
./gradlew buildThe jar lands in build/libs/. Needs JDK 21 — Gradle provisions one automatically if the system
does not have it — and roughly 5 GB of free disk for the Minecraft/NeoForge cache.
Most settings live on F7, alongside the destruction mode. The file
config/crashy-server.toml holds the hard limits and the starting values for new worlds, and
config/crashy-client.toml holds the one thing that is nobody's business but the player's: how hard
a nearby crash shakes their view.
| Section | Controls |
|---|---|
glue |
maximum size of a glued group, and the reach and volume of one area selection |
damage |
whether crashes hurt entities and players, the damage multiplier, debris damage |
materials |
the #crashy:fragile and #crashy:reinforced multipliers |
protection |
spawn protection, and an extra no-crash radius around world spawn |
fluids |
how much water dampens a crash, and whether lava sets the crater alight |
activator |
block limit per object, fallback to connected blocks |
blueprint |
block limit per schematic |
launcher |
hold distance, speed per power level, charge rate |
destruction |
minimum impact speed, maximum crater radius, debris limits |
tnt |
radius, scatter and breaking force of a TNT blast; whether an ordinary explosion throws its blocks |
performance |
shatter budget per tick, the ceiling on live debris, and how many blocks make one piece |
collapse |
whether what loses its support falls, how much may come down at once, checks per tick |
players |
how many objects and blocks one player may keep in the air |
feel |
whether the server sends the camera shake at all |
debris |
whether debris settles back into blocks, and how long it lies there first |
If shards look like they "snap back" a second after the crash, raise debrisScatter: a shard that
never moves counts as settled and gets written straight back where it broke off.
The limits (maxWorldBlocksDestroyed, maxDebrisPerImpact) are there for a reason — every shard is
a separate rigid body in Sable's physics pipeline.
dev.pycodder.crashy
├── Crashy entry point, registration
├── CrashyConfig server-side config
├── CrashyClientConfig the settings that are the player's own
├── CrashyGameRules crashyDestruction, crashyEntityDamage
├── glue/ glue item, area selections, and the per-world SavedData behind it
├── block/ physics activator block, plus the item that switches physics off
├── launcher/ launcher item and the grab/charge/launch controller
├── schematic/ schematic item, materials list, the machine menus, the chunked transfer
├── structure/ schematic table, schematic cannon, StructureData, StructureScanner
├── settings/ destruction modes and world-owned settings
├── network/ glue highlight, area selection and settings sync payloads
├── command/ /crashy stats and the debris broom
├── api/ CrashyBreakEvent, the hook other mods cancel
├── advancement/ the crash trigger advancements listen to
├── client/ outlines, previews, holograms, F7 screen, keybinds, the schematics folder
├── physics/
│ ├── SableBridge the only place that talks to Sable's API
│ ├── PhysicsActivation assembling a build into an object, and back
│ ├── ImpactTracker tracking launched objects and detecting the hit
│ ├── Destruction shattering the object and the world, setting off charges
│ ├── CrashDamage what a crash does to whoever is standing in it
│ ├── Blast one centre things are thrown away from
│ ├── CrashyEffects every particle, and the camera shake
│ ├── ShatterQueue breaking blocks into clumps, a few per tick
│ ├── ExplosionDebris ordinary explosions throwing what they break
│ ├── StructuralCollapse bringing down what lost its support
│ ├── Protection the one question asked before a block of the world is taken
│ ├── PlayerObjects what each player is holding up
│ └── DebrisManager returning debris to the world
└── registry/ items, blocks, block entities, sounds, components, tags, damage types, tab
MIT — see LICENSE.
Made by pycodder · Physics by Sable from RyanHCode