GPU deformable body simulation has long forced creators to choose between speed and believable physics. JGS2, a research solver highlighted by Two Minute Papers, points to a more useful compromise: GPU-scale parallelism with convergence behavior closer to costly global Newton solvers.
The headline numbers are eye-catching, but the more important idea is architectural. Instead of making every local solver act as though it is alone, JGS2 gives local updates a precomputed approximation of how their movement will affect the rest of a deformable object. That tackles a fundamental reason why soft-body simulations wobble, lag, or fail under heavy contact.
The bottleneck in GPU deformable body simulation
Simulating elastic objects means repeatedly calculating how thousands—or millions—of connected points should move under forces, collisions, and material constraints. A local adjustment to one vertex can change stress throughout the mesh, particularly for stiff materials, dense meshes, and contact-rich scenes.
That global coupling is awkward for GPUs. GPUs excel when many small tasks can run in parallel, while highly accurate physics solvers often rely on global calculations that are comparatively expensive and difficult to parallelize.
Methods such as Vertex Block Descent (VBD) make the problem more GPU-friendly by solving many vertex-level subproblems in parallel. VBD remains relevant: NVIDIA’s open-source Newton physics engine includes it for cables, cloth, and volumetric deformables. But local parallel solves can suffer from overshoot—a local correction lowers energy in one area while increasing it elsewhere, slowing or preventing overall convergence. (developer.nvidia.com)
How JGS2 addresses overshoot
The underlying paper, “JGS2: Near Second-order Converging Jacobi/Gauss-Seidel for GPU Elastodynamics,” was published in ACM Transactions on Graphics as part of SIGGRAPH 2025. Its core claim is unusually ambitious: retain the high parallelism associated with Jacobi-style methods while approaching the fast convergence associated with full-space Newton methods. (arxiv.org)
In practical terms, JGS2 does not simply make each local solve more aggressive. It estimates the global consequences of a local displacement through a precomputed, co-rotated local perturbation subspace. That information lets each local update account for neighboring and longer-range coupling rather than blindly optimizing its own tiny patch of the object.
The workflow has two phases:
- Offline preprocessing: The system computes data from an asset’s rest shape, including local perturbation information derived from the simulation’s stiffness structure.
- Runtime simulation: The solver uses that precomputed information to apply richer local corrections at GPU speed.
This is why the technique is especially interesting for games, interactive visual effects, digital twins, and robotics datasets. An asset can be prepared before shipping or before a batch job begins, then benefit from lower-latency simulation during the experience users actually see.
What the performance claims really mean
Two Minute Papers presented JGS2 through striking examples: soft puffer balls, a dragon, deforming ships, dense contact scenes, and a collapsing house of cards. The video describes roughly 30× to more than 170× improvements over VBD in selected examples, including cases where VBD does not converge at all.
The research paper uses a more conservative broad summary, reporting 50× to 100× better convergence than state-of-the-art GPU methods, with larger advantages in stiff simulations. In one featured 3.5-million-tetrahedron puffer-ball scene, VBD fails to converge at the stated time step when soft and stiff balls are mixed; in an all-soft version of that setup, the paper reports JGS2 as 122× faster than VBD. (arxiv.org)
That distinction matters for marketers, technical artists, and founders evaluating simulation claims. “170× faster” should not be read as a universal frame-rate multiplier for every scene, GPU, material model, or collision setup. It is a benchmark-specific comparison. The stronger takeaway is that JGS2 changes the solver’s convergence profile, which can turn formerly impractical scenes into interactive ones.
The preprocessing trade-off creators should understand
JGS2 is not magic real-time physics with zero setup cost. The precomputation step can take meaningful time for complex assets, and the source video cites examples ranging from minutes to more than an hour.
For a one-off procedural shot, that upfront cost may erase some of the benefit. For reusable game assets, simulation-heavy product configurators, virtual training environments, or repeated robotics rollouts, the trade-off is more favorable: pay once per rest-shape asset, then reduce the runtime cost across many simulations.
Teams should also verify how closely their production case matches the paper’s assumptions. Material behavior, mesh changes, topology changes, contacts, hardware, time-step requirements, and integration with an existing physics stack all affect whether a research result transfers cleanly.
Why this matters beyond graphics demos
Fast, stable deformable physics is not only about making squishy characters look better. It can improve creator workflows in several areas:
- Games and XR: More convincing cloth, rubber, soft props, destruction, and contact without hiding physics behind canned animations.
- Film and advertising: Faster iteration for physically based motion, especially when artists need to review changes interactively.
- Robotics: Better throughput for training policies that manipulate deformable materials such as fabric, cables, packaging, and flexible components.
- Industrial digital twins: More responsive testing of soft parts, packed objects, and collision-heavy processes.
The robotics angle is particularly timely. Modern open-source simulation stacks are increasingly GPU-oriented and modular, with Newton positioning deformable simulation alongside systems for contact-rich manipulation and reinforcement-learning workflows. (developer.nvidia.com)
Still, JGS2 should be viewed as an important research direction rather than an automatic replacement for every solver. A later research preprint, Coordinate Condensation, explicitly builds on JGS2’s perturbation-subspace idea while arguing that JGS2’s damping can limit convergence in some settings. That is how healthy graphics research progresses: a compelling method exposes a new design pattern, then subsequent work tests its limits and improves it. (arxiv.org)
The real takeaway for builders
JGS2’s biggest contribution is not a viral speedup figure. It is the demonstration that the old choice between fully local GPU solvers and globally aware, expensive solvers may be less fixed than it appeared.
For teams building GPU deformable body simulation into interactive products, the lesson is clear: preprocessing is becoming a strategic tool. When global physical context can be compressed into reusable asset-side data, runtime simulation can become both more stable and more responsive. That is a meaningful shift—and one worth tracking as the method moves from SIGGRAPH research into real-world engines and pipelines.