In this Two Minute Papers‑style video, Dr. Károly Zsolnai‑Fehér explains a recent graphics paper that tackles the long‑standing trade‑off between fast but inaccurate and accurate but slow deformable‑object simulators. The authors introduce a pre‑computed, aco‑rotated local perturbation subspace that predicts how each local change influences the whole object before the change occurs. This enables massively parallel GPU computation without the overshoot and instability that plagued previous slice‑based methods such as Vertex Block Descent (VBD). The presenter showcases real‑time demos—a 100k‑element dragon running at interactive frame rates and a 2.5‑million‑element “barbarian ships” scene achieving 3 fps—highlighting speed‑ups of 30‑170× over VBD and cases where VBD fails to converge. Limitations are acknowledged: a pre‑computation phase that can take from minutes to over an hour per asset, which must be performed offline before deployment. The video also notes the open‑science release of the code and briefly promotes Weights & Biases’ Weave toolkit for LLM debugging. Overall, the method promises real‑time, stable deformable simulations suitable for games and interactive graphics, provided the upfront pre‑computation cost is acceptable.
Chapters
Today we are going to create crazy virtual worlds where we simulate, hmm, squishy things. Yes! Haha! Things that deform. This new method is incredibly impressive. It can do absolutely wonderful things. Elastic barbarian ships and rods, really squishy letters, super detailed cloth wrinkles, and then, whatever the heck this is. Now that's really tough. But I'll try to summarize 30 years of research for you, here goes. We have fast simulations that are wrong. Or, we have accurate ones that are painfully slow. Why? Well, the input is a bunch of shapes and forces that act upon them. And the output is the new positions of every tiny point that describes these objects. This is a really tough problem because these things are squishy. So every tiny point affects every other point, And there are millions of them, so one small mistake can spread everywhere and break the whole simulation. Okay, so what can this new technique do? Well, imagine a tree that you really don't like, and you hope to never see it again. So, what does a computer graphics researcher do? Well, of course, throw jack-o'-lanterns at it until there are enough so we never see it again. Can we do that? Let's see. Oh yes! Kinda crazy. So, what is going on here? Dear Fellow Scholars, this is Two Minute Papers with Dr. Károly Zsolnai-Fehér. So previous techniques had a problem with scenes like this. You see, they split the problem into small pieces and solve them separately. But the problem is that those pieces ignore each other and cause a problem called overshoot. What does that mean? Well, overshoot means that we apply a small fix locally at one part, but it makes the whole other thing worse. Things start to wobble, slow down, maybe even explode. Phew. That is a huge problem. I mean, you can't slice up the problem into many smaller pieces without ruining the thing. Kind of a dealbreaker. But that would be great! Why? Well, that is exactly what GPUs are good for. You don't solve slice 1, and then slice 2, then slice 1000. No! You give it all 1000 slices, and it is going to be solved in one go. But you can't do that. Or, you couldn't. Until now. Because this method predicts how each of these small changes affect the whole project. Okay, how? Well, through precomputed, aco-rotated local perturbation subspace. Whew! What does that mean? That is a very scientific way of saying that each slice is able to tell how its own movements stretch and pull the rest of the object before it even moves. That is magic! Because finally, the simulation can be super fast and remain stable. Now that is remarkable. So this simulation has a dragon given by 100,000 elements, and it is pretty accurate. So, how long do we have to wait? Like overnight? Well, hold on to your papers Fellow Scholars, because this dragon experiment runs easily in real time. Yup, that just happened. But note that this is not quite the whole truth. I'll tell you about it in a moment. And even if you have 5 barbarian shapes, given by 2.5 million elements, I thought surely you'd have to wait overnight for this one, right? It turns out, nope. This can still do 3 frames per second. You can actually see it in motion as you compute it. That— wow. There are previous techniques that did that already, for instance, here is Vertex Block Descent, VBD. It can do that. So, what's new here? Well, for one thing, get this. This is about 30 to 170 times faster than VBD. What? That is insanely fast. For a House of Cards, it can also do 30 frames per second. For a simulation with about 400,000 elements, that is incredible. Wow! But it gets better. The paper says— wait, what? Infinite times faster? Did they just invent a time machine? No, no, no, not quite. You see, there are cases where the previous VBD fails to converge at all. It never finishes the simulation. Okay, so how about this new technique? Oh, look at that! What a beauty! Now, limitations. We said it can run in real time. Yes, that's true. However, before the simulation starts, it has a precomputation step. It has to run some calculations before starting. And for a huge scene, it can take a while. For a quick dragon scene, about 7 minutes, huge scenes, 67 minutes. That kinda sucks. But wait, don't despair. This is my understanding of the paper, you precompute the rest shape Hessian matrix per deformable asset. What does this mean? This means that you can do the whole thing before shipping a game. So, when the user sees it, they won't even know about this part, and it will run super fast. Which is excellent. And this is open science, so we get all this for free. What a time to be alive! And unfortunately, almost nobody is talking about works like this, so I really wanted to share this with you. Thank you! We need new tools for the era of LLMs, and Weights Biases now has Weave, a lightweight toolkit to confidently iterate on LLM applications. Use traces to debug how data flows through each step of your app, and use evaluations to measure your progress. It is the best. Try it out now at wnbi.me/papers or click the link in the description below.
