All Mods Resource Packs Data Packs Shaders Modpacks Plugins
Sable: Destructive

Sable: Destructive

by Xylos_Official • Downloads: 0 • Followers: 0
Description
Gallery
Changelog
Versions

Sable: Destructive

Turn Sable physics into physical destruction.

Sable: Destructive is a server-and-client addon for Sable on Minecraft 1.21.1. It makes moving Sable structures respond to collisions and explosions with material-aware block failure, flying physics fragments, world craters, debris and cinematic impact effects.

Build a vehicle, aircraft, ship or moving base and crash it into the world. Weak contact blocks crush first, hard materials resist longer, detached pieces preserve their motion, and a sufficiently large body can create a radial crater with a visible pressure wave and rising column of dust.

Physical block damage

Every meaningful contact is evaluated using relative speed, reduced contact mass, kinetic energy, block mass, material toughness and the hardness of the attacking surface.

  • Block-by-block damage by default: ordinary collisions remove the actual contact block instead of carving long layers through the world.
  • Material compatibility: soft grass, leaves or dirt cannot destroy obsidian simply because more soft blocks are attached behind them.
  • Capped mass leverage: large structures hit harder, but mass cannot provide infinite strength to a weak contact face.
  • Attacker self-damage: when a soft projectile hits a hard wall, the projectile can erode while the wall survives.
  • Low-speed protection: a single stone block dropped from approximately two blocks will bounce or stop instead of drilling downward indefinitely.
  • Finite ordinary materials: stone, metals, obsidian, netherite and reinforced blocks are resistant, not immortal. A proportionate high-energy collision can still break them.
  • Protected infrastructure: bedrock, barriers, command blocks, structure blocks and portal infrastructure remain intentionally unbreakable.

Optional penetration and cluster detachment can be enabled for more destructive servers. Penetration is energy-limited, requires extreme speed and is capped to prevent tunnelling.

Two destruction outcomes

When a block fails, Sable: Destructive chooses a result appropriate to the material and impact:

  • VANISH: brittle or heavily overloaded blocks pulverize into textured dust, grit and fragments without filling the world with dropped block items.
  • DETACH: suitable blocks peel away as independent Sable physics bodies that keep their inertia, tumble and collide with the environment.

Container contents can still be released, while unsafe block-entity detachment paths use the safer destruction outcome.

Giant landings

Large falling Sable bodies produce a multi-stage impact only after the system confirms real terrain contact:

  1. A bright contact flash marks the instant of collision.
  2. A dusty shock ring and a faster translucent pressure front expand across the ground.
  3. Physical rock and soil fragments launch upward, fall under gravity and bounce off terrain.
  4. A turbulent dust column rises above the crater and expands as it loses opacity.
  5. Delayed skirt dust and secondary rubble settle around the impact site.
  6. Layered boom, ground rumble and cracking sounds communicate the scale of the hit.
  7. Distance-scaled camera and FOV vibration deliver a sharp kick followed by a slower tremor.

Crater radius, depth, entity knockback, effect density and camera movement scale with the impact and remain bounded for gameplay stability.

Custom visual pipeline

The addon contains nine dedicated particle shaders:

  • Structural shatter
  • Textured dust
  • Ground shockwave
  • Sparks
  • Contact flash
  • Boundary grit
  • Volumetric impact plume
  • Pressure wave
  • Faceted rubble

Dust and debris use Minecraft world collision. Effects attached to moving Sable sub-levels are simulated in local space so they travel with the structure instead of appearing at an unrelated point in the sky.

Built for multiplayer

Heavy impacts use a compact event packet. The server sends impact position, radius, severity and a deterministic seed once; each nearby client builds the full visual sequence locally.

Performance protection includes:

  • Distance-based visual LOD
  • Respect for Minecraft's All, Decreased and Minimal particle settings
  • Shared per-tick client particle budgets
  • A limit on concurrent impact sequences
  • Server-side effect and destruction budgets
  • Spatial and temporal effect deduplication
  • Deferred Sable mutations at safe tick boundaries

Client-only screens and shaders are isolated from dedicated-server code.

Configuration and commands

Operators can open the live configuration screen with:

/sable-dv config panel

The alias /sable config panel is also available.

Other commands:

/sable-dv on
/sable-dv off
/sable-dv config reset

The panel controls damage gates, self-damage, penetration, detach behaviour, shockwave radius, crater depth, knockback, epic impact effects, camera shake and particle density. Settings persist in config/sabledestructive-common.toml.

Commands and server-side panel changes require operator permission level 2.

Requirements

  • Minecraft 1.21.1
  • NeoForge 21.1.235+
  • Sable 2.0.3+
  • Java 21

Install the mod on both the client and server. Sable and its own required dependencies must also be installed.

Compatibility notes

  • Designed for Sable 2.x physics sub-levels.
  • Vanilla TNT, creepers, end crystals and other explosions can damage Sable structures through the same protected destruction pipeline.
  • Unknown modded blocks receive conservative finite defaults so they do not become accidentally immortal.
  • World terrain damage can be disabled if a server wants destruction restricted to Sable structures.
  • Replace old versions completely and restart Minecraft after updating; do not hot-swap the JAR.

Credits

  • Code: Xylos_Official
  • Visuals: Viaquelt
  • Sable physics engine and API: ryanhcode

Licensed under the MIT License.

How to Install Sable: Destructive (Mod)

Sable: Destructive by Xylos_Official is verified for Neoforge across Minecraft versions 1.21.1 (latest release: 2.2.0, file size: 571 KB). Follow the steps below to install it safely from ModCraft.tv:

  1. Click the Download button above and select your Minecraft version (1.21.1) and platform (Neoforge).
  2. Make sure you have the compatible loader or environment installed for Neoforge.
  3. Move the downloaded Sable: Destructive file into your Minecraft .minecraft/mods folder and launch the game.

All Versions

+ Add Version
Name Game version Platforms Published Downloads Actions
1.21.1
Neoforge
3mo ago 1
1.21.1
Neoforge
3mo ago 1
1.21.1
Neoforge
3mo ago 1
1.21.1
Neoforge
4mo ago 1
1.21.1
Neoforge
4mo ago 1
1.21.1
Neoforge
5mo ago 1
1.21.1
Neoforge
5mo ago 1
1.21.1
Neoforge
5mo ago 1
1.21.1
Neoforge
5mo ago 1
1.21.1
Neoforge
5mo ago 1
1.21.1
Neoforge
6mo ago 1
1.21.1
Neoforge
6mo ago 1
1.21.1
Neoforge
6mo ago 1
1.21.1
Neoforge
6mo ago 1
# Sable: Destructive 2.2.0 — Destruction, Compatibility & Safety

Version 2.2.0 is a large stability, compatibility, balance and visual-effects update for Sable: Destructive. It completes the impact-system overhaul, makes explosions and collisions safer around Sable sub-levels, fixes snow-covered terrain, improves hard-material destruction, prevents several Sable lifecycle crashes and adds a supported API for other mod authors.

The result is a destruction system that is more physical and more spectacular under heavy impacts, while being substantially safer during ordinary gameplay, large explosions, level unloading and repeated collision events.

## Major highlights

  • Fixed explosions and mine-triggered explosions crashing while scanning Sable plots.
  • Fixed explosions producing sound while destruction of affected Sable blocks was skipped after an unsafe plot access.
  • Fixed thin snow remaining suspended after the dirt, grass or other supporting terrain below it was destroyed.
  • Fixed collision dust being spawned in Sable's hidden plot-storage space instead of the visible parent world.
  • Fixed removed sub-levels continuing heat-map splitting and attempting to assemble blocks inside an already removed plot.
  • Rebalanced high-toughness finite blocks so the 20–30 toughness range is no longer effectively immortal.
  • Preserved meaningful armour behaviour for obsidian, netherite and reinforced materials.
  • Improved heavy-impact flash, shockwave, debris, dust-plume, sound and camera feedback.
  • Added strict server and client budgets so large destruction events scale down safely instead of flooding the tick or render loop.
  • Added the public SableDestructiveApi integration surface for weapons, vehicles, explosives and other addons.
  • Removed normal-shutdown diagnostic spam and filtered harmless Modrinth App launcher disconnects.

## Collision destruction and impact physics

  • Rebuilt the break decision around a deterministic kinetic-energy and fracture-cost model.
  • Impact calculations now account for:
  • defender block mass;
  • defender material strength and fracture toughness;
  • real Sable body mass;
  • attacker contact hardness;
  • relative impact speed;
  • reduced contact mass;
  • impact-energy retention;
  • the difference between known and unknown attacker materials.
  • Fixed inconsistent Sable mass conversion and removed the former second application of massScale.
  • Added a capped mass advantage. A huge construction still hits harder, but additional soft blocks cannot provide unlimited armour penetration.
  • Added a physical low-speed safety floor. Small blocks dropped from ordinary heights bounce or stop instead of repeatedly drilling through terrain.
  • Unknown contact materials are treated conservatively as ordinary material instead of inheriting the defender's hardness.
  • Invalid or missing mass, speed and direction values are sanitized before entering the destruction queue.
  • Soft attacking faces can damage themselves when they str
...
[2.1.1] HOTFIX - 2.1.1 by Xylos_Official on Jul 24, 2026
Download
fixed crash
[2.1.0] Impact Overhaul - 2.1.0 by Xylos_Official on Jul 20, 2026
Download
Version 2.1.0 rebuilds collision damage, heavy landings and destruction effects around a safer material-and-energy model. Small accidents remain small, while genuinely massive impacts can tear structures apart, fracture ordinary hard materials and leave a convincing crater.

## Highlights

  • Reworked damage into block-by-block structural failure instead of long layer-shaped trenches.
  • Added cinematic giant-impact sequences with a contact flash, expanding shock fronts, ballistic rubble, an upward dust plume and delayed settling dust.
  • Added three new custom shaders for pressure waves, volumetric dust plumes and faceted rubble. The mod now uses nine dedicated particle shaders.
  • Added distance-attenuated camera and FOV shake with a fast impact kick followed by a slower ground rumble.
  • Added circular, severity-scaled craters and stronger heavy-impact pressure damage to world terrain.
  • Added client-side LOD and compact event networking to keep large effects practical in multiplayer.

## Damage and material balance

  • Replaced the previous mass heuristic with a deterministic kinetic-energy, reduced-mass and material-toughness model.
  • Added a low-speed safety floor: dropping a normal stone block from roughly two blocks no longer makes it drill toward the bottom of the world.
  • Disabled layer penetration by default. Optional extreme-impact penetration requires at least 20 m/s and is capped at two additional blocks.
  • Disabled multi-block cluster detach by default so normal damage progresses one contact block at a time.
  • Added a capped mass advantage. Adding more grass or another soft material no longer turns it into an armour-piercing projectile.
  • Added attacker self-damage when a soft contact face hits a much harder defender.
  • Rebalanced every finite ordinary toughness tier. Stone, metal, obsidian, netherite and reinforced blocks can fail under a proportionate impact instead of behaving as immortal blocks.
  • Bedrock, barriers, command/structure blocks and portal infrastructure remain intentionally protected.
  • Fixed Sable body-mass conversion and removed an accidental second application of massScale.
  • Fixed explosion DETACH so it creates an actual physics fragment instead of silently deleting the block.

## Giant-impact effects

  • Heavy landings now require confirmed contact with solid world terrain.
  • Impact origin is calculated from the transformed bottom centre of the falling Sable body.
  • Added a fast dusty shock ring and a separate translucent pressure front.
  • Added physical rubble with gravity, world collision and damped ground bounces.
  • Added a long-lived rising plume with turbulent drift, expansion and gradual opacity loss.
  • Added delayed skirt dust and secondary fragments after the initial collision.
  • Added severity-scaled boom, low rumble and crater-crack sound layers.
  • Fixed shader atlas handling that could make dust and shockwave sprites appear square, clipped or incorrectly centred.
  • Dust and grit now collide and settle in
...
[2.0.1] Hot Fix - 2.0.1 by Xylos_Official on Jul 14, 2026
Download
### Fixes
  • Crash:** Sub-level assembly attempted inside plot of already removed sub-level — despawn now clears the plot with destroyAllBlocks() then removes via the container; detach refuses break-immune / already-removed parents and vanishes leftover blocks instead of restoring into a dying plot
  • Dust / grit:** particles no longer appear as a speck in the sky or vanish instantly — plot-local coords are sent over the wire, the client embeds them into the live sub-level pose, and sim runs in local space with visible alpha
  • Falling-dust rim sampling uses center-of-mass instead of the empty plot AABB

### Changes
  • Version bumped to **2.0.1**
  • Full Modrinth / README description restored and updated for 2.0.x (commands, Sable 2.0.3+ requirement)

### Notes
  • Replace the old jar completely and restart the game (hot-swap is not enough after the despawn path change)
  • Requires **Sable 2.0.3+** on NeoForge **21.1.235+** / Minecraft **1.21.1**
[2.0.0] Global Update - 2.0.0 by Xylos_Official on Jul 14, 2026
Download
Major release for Sable: Destructive — operator controls, denser boundary debris, and safer particle interaction with Sable sub-worlds.

Author / credits
  • Mod & integration: DestrouNautics (Sable: Destructive addon)
  • Physics engine API: Sable by ryanhcode (NeoForge 1.21.1, Sable 2.0.3)
  • Built on NeoForge packet payloads, custom core shaders, and Sable HELPER projection/collision helpers

What's new
  • /sable-dv on|off — toggle all destruction systems (operator)
  • /sable-dv config reset — restore shipping 2.0.0 balance defaults
  • /sable config panel (also /sable-dv config panel) — interactive brass “Flight Deck” operator panel (Create Aeronautics inspired): toggles, sliders, animations, UI sounds; APPLY syncs to the server
  • New boundary grit particle + custom grit shader — dirt chunks fan outward from sub-level rims in mixed directions
  • Dust/grit particles no longer tunnel through sub-worlds (client project-out + bounce against Sable volumes)
  • Impact break still never drops block items; container contents (chests, etc.) still spill
  • Version bumped to 2.0.0

Notes
  • Panel edits require operator permission (permission level 2+)
  • Dedicated-server safe: client panel/shaders load only on the client
Built against Sable 1.2.2 (the API surface we use is stable from
1.1.3 → 1.2.2 — no source changes required, this is a recompile +
diagnostics release).

What's new

  • Startup self-check. The very first INFO line in the log now reads
[Sable: Destructive] addon=1.7.2 sable=1.2.2 (or sable=NOT LOADED
with a loud warning if Sable is missing). Future API-mismatch
reports become a two-line paste instead of a full log dump.

  • /sable-dv diag — live counters for "is the shockwave alive?":
  • Server waves emitted + packets actually sent
  • BreakQueue throughput (offered / processed / pending / dropped
by capacity vs. dedup)
  • SubLevelMassResolver cache hit/miss/fallback rates
  • Detected Sable runtime version

The command also prints a hint based on what it sees:
  • Zero waves → magnitude / mass gate is filtering everything.
Lower shockwaveMinMagnitude or shockwaveMinAttackerMassUnits.
  • Waves but zero packets → no players inside
shockwaveClientHorizonBlocks. Stand closer or raise it.
  • Both non-zero → server is healthy; if the client sees nothing,
install the addon CLIENT-side too.

  • Compiled against Sable 1.2.2 (libs/sable-neoforge-1.21.1-1.2.2.jar).
The 1.1.3-only compileOnly/localRuntime entries in build.gradle
were swapped over so the IDE dev-runtime now matches the version
most users have installed via Modrinth.

Crash report note (NOT Sable: Destructive)

  • The Create / Registrate chocolate_bucket NPE crash users have
been seeing is a known Create 6.0.10 bootstrap-ordering bug. Our
mod is not in that stack trace — we don't subscribe to
RegisterEvent or touch Create, Registrate, items, fluids, or
advancements. Typical fix: remove duplicate Aeronautics jars
(bundled + standalone), or redownload the Create jar if corrupt.

Requirements

  • Minecraft 1.21.1, NeoForge 21.1.227+, Sable 1.1.3 or newer (tested
on 1.2.2 — earlier 1.1.x still loads at runtime, only the
registered Sable APIs we use need to exist).

## MIT License

Hotfix for "модовые блоки не ломаются" — the callback was silently
skipping every block with an attached BlockEntity, which is the
overwhelming majority of modded machinery (Create cogwheels and
shafts, Mekanism cables, Applied Energistics buses, every chest /
furnace / hopper, etc.). That made the addon visually a no-op
against most non-vanilla builds.

Why it was skipped originally

  • Pre-1.6.1 the callback assumed BE teardown was always fragile —
Sable's sub-level assembler doesn't preserve BE NBT cleanly, and
peeling a half-built contraption can corrupt its kinetic-network
state on the modded side.

What changed

  • allowBlockEntityBreaks (new, default true). BE-bearing blocks
ARE now broken on contact. The block is removed via an explicit
level.removeBlockEntity(pos) BEFORE the setBlock(AIR), so the
BE's saved NBT is discarded cleanly and no vanilla on-remove
side-effect can throw out of the callback.

  • allowBlockEntityDetach (new, default false). Even when BE
breaks are allowed, the outcome is forced to VANISH — never
DETACH. Reason: Sable's assembler doesn't carry BE NBT into the
new sub-level, so peeling a Create gearbox would instantly
desync its kinetic network. VANISH discards the BE cleanly. Set
to true if you want the experimental "peel BEs too" behaviour
(expect cosmetic issues on Create/Mekanism).

  • safeSetAir now explicitly removes any attached BlockEntity
before airing the cell. Catches any throwable from the BE's own
remove handler (Create kinetic teardown, Mekanism cable rebuild,
etc.) so a third-party mod's on-remove bug can never escape into
Sable's native bridge.

Compatibility

  • Set allowBlockEntityBreaks=false in
config/sabledestructive-common.toml to restore the pre-1.6.1
"skip every BE block" behaviour.
  • All other 1.6.0 knobs and behaviour unchanged.

Requirements

  • Minecraft 1.21.1, NeoForge 21.1.227+, Sable 1.1.3+

MIT License
[1.6.0] Real Sub-Level Mass by Xylos_Official on May 19, 2026
Download
The whole break/shockwave pipeline now reads each Sable sub-level's
ACTUAL mass (in kg) from Sable's own MassData tracker instead of
treating every attacker as a hard-coded 2000 kg "default ship". Per
the Sable wiki, every block carries a sable:mass property (kpg);
ServerSubLevel#getMassTracker().getMass() returns the sum that the
physics pipeline itself uses for Rapier. We just read it.

This single change fixes the long-standing complaint that "a tiny
flying chunk feels exactly as heavy as a 5000-block ship": below,
the same 12 m/s impact now produces three very different outcomes
depending on the attacker's real mass.

What is new

  • SubLevelMassResolver — single source of truth for per-sub-level
mass. O(1) per call (queries ServerSubLevel#getMassTracker()),
per-tick identity-keyed cache, defensive fallback to
defaultAttackerMassKg on any Sable-side failure. Hard-capped at
subLevelMassHardCapKg = 1e8 kg to prevent a corrupted physics
tick from making the energy budget infinite.

  • Mass-aware kinetic-energy budget. BreakResolver.shouldBreakState
was already a kinetic-energy formula, but it was always fed 2000
kg. Now it sees the real attacker mass, so:
  • A 100 kg flying cobblestone at 12 m/s = 7 200 J → bounces off
stone (budget 18 kJ).
  • A 50 t small ship at 12 m/s = 3.6 MJ → punches stone wide open.
  • A 500 t fortress at 6 m/s = 9 MJ → grinds through obsidian.
The reduced-mass term µ = m1·m2/(m1+m2) means a feather-light
attacker still cannot pulverize a heavy defender — the math
collapses to the attacker's own KE budget.

  • Mass-aware structural-toughness gate. The "soft attacker can't
pierce hard defender" rule (attackerToughnessRatio) now has a
  • mass relief** factor: the required attacker toughness is scaled
by sqrt(massToughnessReferenceKg / realMass), floored at
massToughnessReliefFloor. A 100 t crusher made of packed dirt
WILL pulverize stone purely from inertia; a thrown dirt clump
won't. Defaults: massToughnessReferenceKg = 4000,
massToughnessReliefFloor = 0.1 (so at most a 10× relief — a
fully soft Jell-O sub-level can never bypass the gate entirely).

  • Shockwave magnitude now uses the same real mass. The bespoke
flood-fill (computeAttackerMassUnits, O(N) up to 1500 blocks per
emit) is no longer the primary path — when useSubLevelMass=true
we feed Sable's mass tracker × shockwaveAvgToughnessUnits (= 120,
i.e. V_STONE × 10) so all existing magnitude thresholds keep their
meaning. Flood-fill remains as the fallback for the unlikely case
where the mass tracker has not been built yet. Net result:
shockwave emission is now O(1) per impact and reflects the real
ship size, not a 6-neighbour sample of it.

  • New persistent config knobs (TOML hot-reload as usual):
  • useSubLevelMass (bool, default true)
  • subLevelMassHardCapKg (kg, default 1e8)
  • massToughnessReferenceKg (kg, default 4000)

...

A major rework of the damage pipeline and the shockwave effect.
This release responds to two specific 1.4.0 reports:

1. "блоки АБСОЛЮТНО все пропадают" — in DETACHING mode (the
default), a routing bug silently turned almost every
contact into a VANISH instead of a real sub-level peel.
2. "звуковые волны после 1.4.0 пропали" — the shockwave was
gated behind mode != DETACHING, so with the default mode
it never fired at all.

Both are fixed, and the underlying systems were reworked rather
than patched.

What is new

  • DETACH-FIRST damage. Block contacts now peel from the parent
sub-level into a fresh physics body by default. VANISH is
reserved for genuinely tiny debris (and for the explicit
/sable-dv mode delete). The chanceDetach default is now
0.92 / chanceVanish 0.08.

  • World terrain is no longer touched in DETACHING mode. In 1.4.0
a routing bug sent the world side of every contact pair down a
branch that VANISH'd the terrain — that was the "all blocks
disappear" report. The actual mechanic:
  • Sable invokes BlockSubLevelCollisionCallback ONLY for
sub-level blocks (never for world terrain), so there is no
world-side classification to do. The earlier 1.5.0 attempt
added an explicit getContaining(level, plotPos) check
that always returned null because plot-region coords are
disjoint from world coords — that mis-classified 100% of
contacts as "world terrain" and silently skipped them, so
destruction stopped happening altogether. Removed.
  • DETACHING mode now reliably peels every qualifying contact.
  • DELETE / DELETE_DETACHING are unchanged.

  • Real shockwave model. Triggered only when a BIG, HEAVY object
lands at speed — not by small bumps. Three independent gates:
  • Approach speed ≥ shockwaveMinApproachSpeed (default 12 m/s)
  • Impact energy ≥ shockwaveMinEnergy (default 2 MJ)
  • Attacker mass ≥ shockwaveMinAttackerMassUnits (default
400 000 — equivalent to ~200 stone blocks of summed
mass × toughness around the contact point)
  • Combined magnitude ≥ shockwaveMinMagnitude (default 1.5 MJ)
A single cobble flying around can never produce a wave. A
five-thousand-block stone ship hitting the ground at 6 m/s does.

  • Shockwave fires in EVERY mode. In 1.4.0 it was buried inside
the inertial-penetration block, which itself ran only when
mode != DETACHING. The emission is now outside that gate so
big landings produce dust + a heavy thud regardless of mode.

  • Shockwave visuals/audio optimized. One radial dust burst
(replacing three expanding rings), a rising dust column at
the impact point, a single heavy "thud" sound — instead of
three layered sand/wool/explosion sounds. Per-source dedup
window, per-second global rate-limit, and a per-tick particle
budget so back-to-back impacts cannot tank FPS.

  • Magnitude drives radius AND ceiling. Radius scales as
`cbrt(magnitude / referen
...
[1.4.0] Collision Modes (revised) by Xylos_Official on May 19, 2026
Download
The command /sable-dv mode <name> switches the behavior of the collision system as a whole. The default mode is now **detaching**.

What is there
  • /sable-dv mode delete - blocks only break (VANISH). No new sub-levels. The inertial chain works, and the world breaks through VANISH.
  • /sable-dv mode default — alias to detaching (new default).
  • /sable-dv mode detaching — **new default behavior**.
The hit detaches the block from the parent sub-level and spawns
a separate sub-world that inherits the speed and flies apart
in different directions. **Nothing is destroyed** — the pieces are physically
detached. Self-damage and inertial chain are disabled.
The world (terrain) breaks through VANISH (the world cannot be torn off as a sub-level).
  • /sable-dv mode delete-detaching — combo: the starting block
detaches, the inertial chain additionally breaks the blocks deeper. Maximum chaos.

What is fixed
  • Shockwaves (shockwave)** no longer trigger at every sneeze. Now there are two independent thresholds:
  • Minimum approach speed (shockwaveMinApproachSpeed,
default **18 m/s**) - cuts off settle/jitter contacts.
  • Minimum energy (shockwaveMinEnergy, default
  • 8 MJ** instead of 250 kJ) - cuts off light impacts.
  • The shockwave system itself is now **disabled by default**
(shockwaveEnabled = false). To enable it, use /sable-dv set
shockwaveEnabled true
.
  • Epic Shatter on Impact** - A boulder thrown into a mountain now really shatters:
  • On a hard impact, the cluster collapses to single blocks
(small pieces instead of a single large brick).
  • Each broken piece has a random spread along
all axes + a random rotation, scaled by the
approach velocity.
  • Kick limits raised: detachKickScale 0.4 → 1.5,
detachMaxKickSpeed 6.0 → 25.0.
  • New parameters detachShatterScatter (default 6.0) and
detachSpinScatter (default 6.0) - adjustable scatter
and spin.

What is removed
  • The typo delete-detachingg is no longer accepted. Only
canonical names: delete, default, detaching,
delete-detaching.

Compatibility
  • Old 1.3.0 worlds are loaded as is. If TOML had
collisionMode = "default" — behavior is now detaching
(by new default).
  • Mod API (Addon API) has not changed, API_VERSION remains 1.

Requirements
  • Minecraft 1.21.1
  • NeoForge 21.1.227+
  • Sable 1.1.3+

Authors
  • Code: Xylos_Official
  • Visual part: Viaquelt
  • Based on Sable by ryanhcode

# License MIT
[1.3.0] Shockwave by Xylos_Official on Apr 25, 2026
Download
Heavy hits now radiate. When a big sub-level slams the ground hard
enough, a stylised shockwave rolls outward from the contact point —
dust ring, "пшшш" sweep sound, then graded damage by distance.

What changed
  • New: Shockwave effect. Triggered when total impact kinetic energy
passes shockwaveMinEnergy (default 250 kJ ≈ 4000 kg @ 11 m/s).
Bigger impacts produce bigger waves — radius scales as
sqrt(E / shockwaveReferenceEnergy) × shockwaveRadiusMultiplier,
hard-capped at shockwaveMaxRadius.

  • 3-tier graded damage:
  • Plants & flowers: trampled out to the full radius. Tall grass,
saplings, ferns, mushrooms, sugar cane, lily pads, sweet berry
bushes, glow lichen, moss carpets, nether sprouts, roots — all
of these get flattened.
  • Leaves: 35% per-block break chance inside the inner 70%
of the radius (linear falloff with distance).
  • Weak blocks: only on really heavy hits (≥ 5 MJ by default).
60% chance per block inside the inner 35%, restricted to
structurally weak blocks (snow, fire, carpets, candles, redstone
wire, vines, wool, hay, cobwebs, torches, ladders) AND capped
at shockwaveBlockToughnessCeiling. Nothing serious gets griefed.

  • Visual: 3 expanding rings of POOF + CLOUD particles plus a single
block-dust burst sampled from the actual ground colour underneath
the impact, so a wave on grass looks green-brown and a wave on
sand looks tan.

  • Audio: layered SAND_BREAK + WOOL_BREAK + low-pitched explosion for
the satisfying "пшшш … thump" sweep.

  • Crash-safety: shockwave never spawns sub-levels, never touches
tile entities, never breaks bedrock-class blocks, all mutations
wrapped in try/catch. Failure of the visual pipeline never blocks
the destruction pipeline.

New tuning knobs (all auto-persisted to
config/sabledestructive-common.toml, all live-reloadable):
  • shockwaveEnabled (default true)
  • shockwaveMinEnergy (default 250000.0)
  • shockwaveReferenceEnergy (default 1000000.0)
  • shockwaveRadiusMultiplier (default 6.0)
  • shockwaveMaxRadius (default 32)
  • shockwaveVerticalRange (default 3)
  • shockwavePlantChance (default 1.0)
  • shockwavePlantRadiusFraction (default 1.0)
  • shockwaveLeafChance (default 0.35)
  • shockwaveLeafRadiusFraction (default 0.7)
  • shockwaveBlockChance (default 0.6)
  • shockwaveBlockRadiusFraction (default 0.35)
  • shockwaveBlockEnergyThreshold (default 5000000.0)
  • shockwaveBlockToughnessCeiling (default 30.0)
  • shockwaveParticlesPerBlock (default 18)
  • shockwaveMaxParticles (default 800)
  • shockwaveSoundVolume (default 1.0)

Compatibility
  • No breaking changes for end users. Existing 1.2.0 worlds load
as-is. The Addon API is unchanged (API_VERSION still 1).
  • To completely disable: /sable-dv set shockwaveEnabled false
  • To raise the threshold so only enormous hits trigger:
/sable-dv set shockwaveMinEnergy 5000000.0

Requirements
  • Minecraft 1.21.1
  • NeoForge 21.1.227+
  • Sable 1.1.3+

Credits
  • Code: Xylos_Official
  • Visuals: Viaquelt
  • Built on top of Sable by
...
[1.2.0] Real Damage by Xylos_Official on Apr 25, 2026
Download
1.1.0 introduced inertial penetration but kept the per-block thresholds
conservative — collisions still felt cosmetic. 1.2.0 retunes the
damage model from the ground up so impacts feel like impacts.

What changed
  • Default damage is roughly doubled across the board.
  • collisionEnergyMultiplier 1.0 → 2.0
  • collisionStrengthMultiplier 1.0 → 1.5
  • penetrationEnergyMultiplier 1.0 → 0.6 (each consumed block costs
less, so chains run further on the same energy)
  • maxPenetrationDepth 16 → 32
  • defaultAttackerMassKg 2000 → 4000

  • Speed actually matters now. Two new knobs scale the penetration
walk by approach speed:
  • penetrationSpeedEnergyBonus = 0.02 → +2% kinetic-energy budget
per m/s above minBreakSpeed. At 50 m/s above the gate that's
+100% budget — fast hits chain dramatically further.
  • penetrationDepthPerMs = 0.25 → each m/s above minBreakSpeed
extends the depth cap by 0.25 blocks. At 80 m/s a hammer can
chain ~18 blocks past the static cap.

  • Density actually matters now. The callback no longer hands
attackerHardness=0 to BreakResolver — it now passes V_WOOD as a
sensible default sub-level toughness plus the configured
defaultAttackerMassKg. The asymmetry rule (attackerToughnessRatio)
finally engages: a wooden cog smacked into stone won't shatter
the stone, an iron block into wood will.

  • Self-damage. New: when the attacker is much softer than the
defender (attacker toughness < defender · selfDamageThreshold,
default 0.6), the defender survives AND the attacker erodes its
own contact face for up to selfDamageMaxBlocks (default 4) blocks.
A copper hammer slamming an obsidian wall now sheds copper from
itself instead of the wall doing nothing — finally that "soft
bounces off hard" feel.

  • All chain-broken AND self-damage blocks always VANISH (never
DETACH) — same crash-safety rule as 1.1.0.

New tuning knobs (all auto-persisted to
config/sabledestructive-common.toml, all live-reloadable):
  • selfDamageThreshold (default 0.6)
  • selfDamageMaxBlocks (default 4)
  • penetrationSpeedEnergyBonus (default 0.02)
  • penetrationDepthPerMs (default 0.25)

Tweaked defaults (existing knobs):
  • collisionEnergyMultiplier 1.0 → 2.0
  • collisionStrengthMultiplier 1.0 → 1.5
  • penetrationEnergyMultiplier 1.0 → 0.6
  • maxPenetrationDepth 16 → 32
  • defaultAttackerMassKg 2000.0 → 4000.0

Compatibility
  • No breaking changes for end users. Existing 1.1.0 worlds load
as-is. The Addon API is unchanged (API_VERSION still 1).
  • To restore 1.1.0 feel exactly, set the five "tweaked defaults"
above back to their previous values via /sable-dv set.
  • To completely disable inertial chains and self-damage:
/sable-dv set inertialPenetrationEnabled false
/sable-dv set selfDamageMaxBlocks 0

Requirements
  • Minecraft 1.21.1
  • NeoForge 21.1.227+
  • Sable 1.1.3+

Credits
  • Code: Xylos_Official
  • Visuals: Viaquelt
  • Built on top of Sable by ryanhcode

License
  • MIT

This is a big quality-of-life pass on top of 1.0.0. The destruction
system now feels meaningful instead of cosmetic: a heavy hammer
actually digs into the ground, dirt yields deeper craters than stone,
modded blocks have a clean integration path, and every tunable you
change at runtime survives a server restart.

New — Inertial Penetration
  • Impacts no longer stop at the first block. The attacker's kinetic
energy is drained block-by-block along the motion direction by each
consumed block's break cost (0.5 · m_def · v_threshold²).
  • An obsidian hammer punches a deep crater into dirt and only chips
the surface of stone — automatically, no per-block scripting.
  • Chain-broken blocks always VANISH. Only the FIRST contact block may
DETACH, because spawning new sub-levels mid-walk is the historic
native-crash trigger and is intentionally forbidden here.
  • Stops on tile entities, indestructible blocks, world bounds, energy
exhaustion, or maxPenetrationDepth.
  • New knobs: inertialPenetrationEnabled (default true),
maxPenetrationDepth (16), penetrationEnergyMultiplier (1.0),
defaultAttackerMassKg (2000.0).

New — Public Addon API
  • com.destroynautics.sabledestructive.api.SableDestructiveAPI lets other
mods register their own blocks into the destruction system with
custom mass and toughness — no more falling back to the fragile
clay-tier default for unknown modded blocks.
  • Register by Block instance (type-safe) or by ResourceLocation (works
even if the target Block class isn't loaded — ideal for optional
cross-mod compat).
  • Tier presets matching the internal scale: PAPER, LEAF, EARTH, CLOTH,
SOFT, CLAY, WOOD, STONE, HARD_STONE, METAL_SOFT, METAL, GEM,
OBSIDIAN, NETHERITE, REINFORCED, UNBREAKABLE.
  • registerUnbreakable(Block / ResourceLocation) — bedrock-equivalent
shortcut.
  • Read-only queries: getMassKg, getBreakSpeedMs, getToughnessUnits —
useful for your own tooltips or ballistics.
  • isRegistered / unregister for runtime control.
  • Thread-safe, idempotent, last-write-wins.
  • API_VERSION = 1, covered by SemVer. Anything outside the api package
is internal and may change without notice.

New — Persistent Config
  • Tunables now live in config/sabledestructive-common.toml. Every
value set via /sable-dv set … survives server restarts.
  • Live auto-reload: edit the TOML on disk and the change applies
within ~250 ms — no restart, no command, no reconnect.
  • /sable-dv config reset now actually restores defaults (was a no-op
in 1.0.0).
  • Config writes are debounced and the watcher ignores its own writes,
so toggling values from chat doesn't trigger a redundant reload.

New — Hand-Tuned Block Table
  • ~70 of the most relevant 1.21.1 blocks — every wood species and the
full stone family — carry their own hand-tuned mass and toughness
rather than being lumped into a generic "wood" or "stone" bucket.
  • Cherry is softer than oak. Mangrove is denser than spruce. Mossy
bricks crack a hair sooner than fresh ones. Slabs, st
...
[1.0.0] Initial Release by Xylos_Official on Apr 25, 2026
Download
First public release of Sable: Destructive — a NeoForge 1.21.1 add-on for Sable that finally lets physics blocks break.

Core mechanics
  • Universal collision callback wired into every Sable physics block.
  • Real kinetic-energy model (mass × v²) decides the outcome of every impact.
  • Two destruction modes:
  • DETACH (~90%) — affected blocks break off as a smaller independent physics sub-level and keep flying.
  • VANISH (~10%) — blocks pulverize into particles + sound when energy exceeds the material's pulverize threshold.
  • Outcome is biased by physics: energy ratio, brittleness, and a safety speed ceiling — chances only set the baseline tendency.
  • Cluster detach: blocks can break off in chunks, not strictly one at a time.

Block data
  • Full mass + toughness table for all 1.21.1 vanilla blocks.
  • Modded blocks default to a fragile clay-tier (clamped to 80–1500 kg, ≤6 m/s break speed) so unknown blocks never become indestructible bricks.
  • F3 + H tooltip shows "Mass: X kg" and "Impact strength: Y m/s".

Explosions and terrain
  • TNT, creepers, end crystals and other vanilla explosions now damage Sable sub-levels through the same path.
  • World terrain is also affected, but only via VANISH (never DETACH), so the world never turns into a runaway physics sim.
  • Bedrock, barriers, unbreakable blocks and block entities are skipped on the terrain path.
  • Toggle terrain damage with the affectOnlySubLevelBlocks config flag.

Visual + audio (fancy VANISH effect)
  • 3-layer particles: block-dust with the actual block texture, POOF, and CRIT chips.
  • Block break sound + soft "whump".
  • Per-tick budgets: 600 particles, 32 effects.
  • Spatial + temporal dedup so big simultaneous breaks don't audio-clip.
  • Auto-scaling under backpressure; falls back to vanilla levelEvent(2001) if overloaded.
  • Toggle with effects and fancyVanishEffect config flags.

Stability and crash safety
  • Lock-free offer queue with atomic size counter and epoch-XOR dedup ring (8192 entries).
  • Per-tick offer cap (1024) to keep the hot path bounded.
  • DETACH is always deferred to a safe inter-tick window — never executed while Sable's physics system is mid-step (this was the historic native-crash trigger).
  • Snapshot + rollback, global crash guard, shutdown hook, emergency disable.
  • NaN / Inf sanitisation on all impact data and kick velocities.
  • Cluster BFS strictly stays within one parent sub-level — no cross-boundary clusters.
  • Lifecycle reset on server start / stop / level unload.

Runtime control (op level 2)
  • /sable-dv on | off | toggle | status
  • /sable-dv config list
  • /sable-dv config get <name>
  • /sable-dv config set <name> <value>
  • /sable-dv config reset <name>
  • All tunables are reflected automatically with type coercion and tab-suggest.

Defaults
  • enabled = true
  • chanceDetach = 0.90, chanceVanish = 0.10, physicsBiasStrength = 0.6
  • pulverizeEnergyRatio = 6.0, cleanDetachEnergyRatio = 1.5
  • minBreakSpeed = 6.0, absoluteMaxSpeed = 350, detachSafeSpeedCeiling = 100
  • maxDetac
...
Sable: Destructive Icon
Download Sable: Destructive
Select game version
Select platform