FreeForm: Reduced-Order Deformable Simulation from Particle-Based Skinning Eigenmodes

Simulating how squishy, deformable objects move and react to force is a fundamental challenge in physics engines. This is vital for robotics and visual effects. Traditionally, this requires high-quality 3D meshes. These are complex geometric structures defining an object's volume. However, modern data often arrives in imprecise, point-based formats like 3D Gaussian Splatting (3DGS). These are difficult to triangulate into usable meshes. While neural fields have attempted to bridge this gap, they require expensive, per-shape optimization.

A new paper, FreeForm, proposes a way to bypass both the meshing bottleneck and the heavy optimization cost. The authors use a mathematical framework called the Reproducing Kernel Particle Method (RKPM). This enables a "reduced-order" model. In these models, we simulate a small set of degrees of freedom (DoFs)—the minimum variables needed to describe motion—instead of millions of particles. These DoFs are controlled by skinning weights (functions that determine how much each basis mode affects a specific point). The result is a massive leap in speed and a significant gain in accuracy.

The Problem

The status quo in elastodynamic simulation—predicting how elastic solids deform over time—generally splits into two camps. Both cause friction in production. The first is the Finite Element Method (FEM), the industry gold standard. FEM relies on high-quality volumetric meshes to calculate internal stresses. If your input is a noisy scan or a cloud of Gaussian splats, generating a valid mesh is a nightmare.

The second camp involves particle-based methods like the Material Point Method (MPM) or Smoothed Particle Hydrodynamics (SPH). These are mesh-free and handle arbitrary shapes well. However, they are notoriously finicky. As seen in, MPM can suffer from "numerical fracturing." This occurs when particles drift too far apart under high strain, causing artificial disintegration.

Recent attempts to use neural fields for reduced-order simulation (like Simplicits) try to learn these deformations. But they require a dedicated training phase for every single new object. For a robotics pipeline simulating thousands of items, this per-shape optimization latency is a non-starter.

How It Works

The core innovation in FreeForm is shifting from learning weights via gradient descent to deriving them via eigenanalysis. The authors use RKPM to parameterize the deformation subspace. Unlike standard Radial Basis Functions (RBFs), which can produce irregular, non-smooth modes [Figure 3b], RKPM uses correction terms. These ensure the kernels accurately reproduce polynomial functions. This creates a smooth, mathematically rigorous foundation for the object's shape.

The workflow follows a distinct two-stage pipeline :

1. Construction Stage: The system takes an input shape and identifies RKPM kernel centers. It then builds a "weight-space Hessian"—a matrix representing the second-order derivatives of the elastic energy. This matrix encodes the energy cost of deforming the object in various directions.
2. Eigenanalysis Stage: Instead of iteratively optimizing a neural network, the authors solve a generalized eigenvalue problem ($H_w v = \lambda M v$). This mathematical operation extracts "skinning eigenmodes." These are the most efficient, natural ways the object can deform. These modes become the basis for the simulation.

Because this is an analytical solution rather than a stochastic optimization, the resulting skinning weights are inherently orthonormal. This provides much better numerical stability during the simulation stage. There, the system solves for the next state of the DoFs using implicit time integration.

Numbers

The headline result is a 40$\times$ training speedup compared to the per-shape optimization used in Simplicits. While Simplicits might take hundreds of seconds to converge, FreeForm completes subspace generation much faster. The authors report just 3.93 seconds for a specific configuration in Table 3.

In terms of accuracy, the authors benchmark against FEM. In a standard cantilever beam test involving bending and twisting, FreeForm consistently achieves lower Mean Squared Error (MSE) than both Simplicits and full-order particle methods like MPM and SPH [Table 1]. On the Thingi10K and Simready datasets, the authors report MSE improvements ranging from roughly 18% to 45% over the Simplicits baseline [Table 2]. For complex, heterogeneous objects—such as a sphere with alternating stiff and soft material layers—the method captures distinct local deformation patterns . Global neural fields tend to smooth these patterns over.

What's Missing

Despite the impressive benchmarks, FreeForm has clear boundaries. First, it is a "reduced-order" model. This means it filters out high-frequency information. The authors admit that capturing fine-grained details like wrinkles is difficult. The global basis is optimized for smooth, low-frequency deformations. If your use case requires high-fidelity cloth or skin simulation, this won't be a drop-in replacement.

Second, the method is fundamentally linearized around the rest state. This makes it ill-suited for extreme nonlinearities. Examples include sharp, high-velocity impacts or complex contact mechanics. Third, the method does not currently account for topology changes. If you need to simulate an object breaking or tearing, you'll need to look elsewhere. FreeForm assumes the object remains a single, continuous entity. Finally, the simulation quality is highly sensitive to the kernel radius and particle distribution. This adds a layer of hyperparameter tuning that could complicate automated pipelines.

Should You Prototype This

Yes, if you are building simulation environments for robotics or high-throughput VFX. The ability to take a 3D Gaussian Splat and turn it into a physically plausible, deformable object in seconds is a massive win for scale. The integration with libraries like NVIDIA's Warp and Kaolin suggests it is ready for engineering workloads. However, if your goal is hyper-realistic character animation with complex wrinkles, wait for the next iteration of reduced-order methods.

Figures from the paper