Stabfish: What It Actually Is and How to Use It
Stabfish is a real-time mesh deformation tool, mostly used in game development and interactive visualization. The idea behind it is to take an object and allow collision-driven or force-driven puncturing, cutting, and reshaping of polygonal geometry on the fly. Think of it as dynamic mesh editing without rebuilding your asset pipeline every time someone or something "pierces" a surface. The core of the system relies on raycasting against the mesh topology, then splitting triangles or quads along the impact vector. Most implementations use a bounding volume hierarchy to cull off-screen or irrelevant hit tests before ever touching the actual vertex data. The new edges created by the cut are then re-tessellated so the mesh stays watertight where possible. Vertices get snapped together, normals are recalculated, and UV seams are either duplicated or unwrapped depending on your setup. It is not magic. There are still places where the algorithm struggles and will leave artifacts that you have to clean up manually. I got my hands on Stabfish a few years back when a client needed a combat system where projectiles could visibly damage environment props in Unity. The download was straightforward. You grab the package from their repository and import it into your project. After that, you attach the Stabfish Collider component to any object that should be destructible and configure your penetration settings. The default collision tolerance was way too aggressive for our scene, so we tuned the Hit Threshold down and set a maximum iteration count of about 8 cuts per frame. Anything higher and the frame budget started to choke on denser meshes.
One morning I was testing a rapid-fire machine gun script and noticed something weird. When bullets hit near existing cut edges, Stabfish would create tiny sliver triangles that collapsed the local mesh and caused the collider to misfire repeatedly. The slivers also triggered ghost intersections that made the target prop vibrate violently. I spent a couple of hours debugging before I realized the issue was the mesh simplification pass running after each cut. The fix was simple enough. I disabled the auto-simplifier for that particular prop and added a small post-processing step that welds vertices within 0.01 world units after every 3 cuts. That kept the geometry clean without eating too much performance. The prop stopped vibrating and the visual feedback looked solid. For all its usefulness, Stabfish has clear limitations. It does not handle non-manifold geometry gracefully. If your base mesh has overlapping faces or non-closed shells, the cuts will produce unpredictable results. I learned that the hard way on a character prop with a badly imported NLA rig layer that had doubled vertices in the arm region. Every strike there produced garbage topology. The workaround was to bake a clean low-poly version and use that as the Stabfish target while keeping the high-res mesh purely cosmetic. Another limitation is memory. Each cut adds vertices and new triangle data to the buffer, and there is no automatic garbage collection for stale geometry beyond what your engine provides. In a long session with repeated destruction, you will see memory climb steadily until you either reload the level or call an explicit mesh rebuild function. We ended up implementing a threshold counter that triggers a full mesh reconstruction every 50 cuts per object, which brought memory back down to stable levels. Keep your base meshes reasonably low-poly before feeding them into Stabfish. A 2,000-triangle plane responds much better than a 50,000-triangle terrain chunk. Use world-space rather than local-space raycasts when the camera moves frequently. Local-space transforms can throw off hit detection if the parent object rotates or scales between frames. Also, disable Stabfish on objects that are off-screen or outside the player's visible area. The overhead adds up even when nothing is happening because the system still runs its broad-phase collision check every frame. Finally, export a baked static copy once you are done playing. It cuts load times and prevents runtime rebuilds from corrupting the scene state.
You can find the official Stabfish package at the usual distribution channels tied to its documentation site. The latest build supports both Unity and Unreal Engine out of the box, though the UE implementation requires a bit more hand-holding with custom shaders. The community forums are active enough that you will find solutions to most edge cases within a day or two if you post a clear reproducible example with screenshots and your configuration values. Stabfish is not the final answer for every destruction need, but for targeted, dynamic mesh modification in real-time applications it is one of the more functional options available. Use it where the geometry is manageable, the cut count is limited, and you are prepared to intervene when the algorithm leaves messy topology behind.
Get the Full Details
