pith. sign in

arxiv: 2605.23088 · v1 · pith:IXYC2S4Unew · submitted 2026-05-21 · 💻 cs.GR · cs.PL· cs.SC

YASPS: A Symbolic Framework for Extensible, High-Performance IPC Simulation

Xuan Tang , Kemeng Huang , Gilbert Bernstein , Minchen LI , Tzumao Li This is my paper

Pith reviewed 2026-05-25 04:52 UTC · model grok-4.3

classification 💻 cs.GR cs.PLcs.SC
keywords Incremental Potential ContactIPC simulationsymbolic differentiationrelational operatorsGPU kernelsHessian compressionextensible frameworkcontact-rich simulation
0
0 comments X

The pith

YASPS uses explicit JOIN and UNION relational operators in a differentiable program to support rapid IPC extensions while preserving competitive GPU performance.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper introduces YASPS as a GPU-oriented symbolic framework that represents IPC energy minimization using first-class relational operators. JOIN composes dependent quantities across declared relations such as element-to-vertex connectivity, while UNION handles alternative parameterizations like mixing free vertices with affine bodies. Dedicated differentiation rules and a second-order procedure that reuses Jacobians allow automatic derivation of gradients, Hessians, and sparsity patterns. From this single description the system generates block-sparse storage, compressed Hessians, and JIT-compiled CUDA kernels for evaluation and solving. Benchmarks on layered cloth, mixed rigid-deformable scenes, and caged deformation show that front-end changes require minimal back-end updates yet deliver end-to-end performance comparable to specialized code, with Hessian compression producing roughly 10x faster CG iterations.

Core claim

YASPS makes the relational structure of IPC energies first-class by introducing JOIN and UNION operators into a differentiable intermediate representation; dedicated differentiation rules together with Jacobian reuse in the second-order procedure then enable automatic global sparsity derivation, block-sparse assembly, and JIT compilation of CUDA kernels, so that the same high-level description supports both rapid extensibility and competitive performance.

What carries the argument

The JOIN and UNION first-class relational operators, which compose quantities across user-declared relations and represent alternative parameterizations, allowing symbolic differentiation, sparsity extraction, and structure-aware kernel generation.

If this is right

  • Adding new energies, primitive types, or parameterizations requires only front-end changes with minimal back-end modification.
  • Hessian compression derived from the relational description yields near 10x faster conjugate-gradient iterations.
  • Global gradient and Hessian sparsity patterns and block layouts are derived automatically from the same relational program.
  • The framework produces complete JIT-compiled CUDA kernels for energy evaluation, derivatives, assembly, and solving across mixed rigid-deformable and layered-contact examples.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The same relational representation could be applied to other energy-minimization simulators that currently rely on hand-specialized kernels.
  • Automatic derivation of sparsity and block layout may reduce the engineering cost of porting new contact models to GPU.
  • Reusing intermediate Jacobians across the second-order procedure could be generalized to additional higher-order quantities if needed.

Load-bearing premise

The overhead of the dedicated differentiation rules for JOIN and UNION plus the Jacobian-reusing second-order procedure stays low enough to remain competitive with hand-written specialized kernels.

What would settle it

A direct comparison in which, for an identical new energy or parameterization, the automatically generated YASPS kernels take more than a small constant factor longer per iteration than an equivalent hand-written CUDA implementation on the same hardware.

Figures

Figures reproduced from arXiv: 2605.23088 by Gilbert Bernstein, Kemeng Huang, Minchen Li, Tzumao Li, Xuan Tang.

Figure 1
Figure 1. Figure 1: We introduce YASPS, an IPC [Li et al. 2020]-based simulation framework that is both extensible and performant. Users define parameterizations, shape primitives, and energies in Python, from which YASPS automatically generates and compiles GPU code for first- and second-order differentiation. YASPS also assembles the global gradient and Hessian and efficiently solves the resulting linear systems on the GPU.… view at source ↗
Figure 2
Figure 2. Figure 2: The energy in Eq. (1) can be decomposed into different layers. The structural information in [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: An overview of how the YASPS’ backend works once user has specified the energies in the scene and the attributes to minimize against. The symbolic [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figure 5
Figure 5. Figure 5: Attributes. When attribute rest_position is added to the primitive type vertices, YASPS initializes an array of size NUM_BUNNY_VERTEX ×3×1, and saves it under the rest_position attribute, whose reference pointer is then saved under the vertices primitive type. When the user updates the values of this attribute, the new values will be copied into this array. 4.2 Attributes In YASPS, scene, mesh and primitiv… view at source ↗
Figure 7
Figure 7. Figure 7: Lineage of attributes. A simple scene hierarchy illustrating an affine￾body mesh. Attributes that share the same lineage (within the same box) can participate in the same computation. By contrast, attributes from different hierarchies cannot be directly combined until their relationship is made explicit through a relational operator. simplicity, YASPS enforces a key rule: all attributes participating in th… view at source ↗
Figure 8
Figure 8. Figure 8: Connectivities. When connectivity is added to a primitive type, we create a connectivity object and put it in the list of connectivities under the corresponding primitive type. The connectivity object simply contains a list, which indicates the relation between two primitive types, and the target, which points to the other primitive type. where each 𝑗ℓ (𝑖) ∈ 𝐼𝐵 is the index of the ℓ-th instance of 𝐵 refere… view at source ↗
Figure 9
Figure 9. Figure 9: Joins. Illustration of how tets.position is computed using JOIN operators. The JOIN operator uses the connectivity (e.g., tet2v) to gather the corresponding entries from the target attribute vertices.position. Intermediate attributes, such as vertices.position, vertices.affine_matrix, and vertices.translation, are not materialized during this computation. Instead, when a required attribute is itself define… view at source ↗
Figure 10
Figure 10. Figure 10: Unions. The UNION attribute, if materialized, stacks the materialized values of the children being unioned. Just like JOIN, this operator can be performed on attributes across different primitive types, or even different meshes, making this operator, in combination of JOIN, particularly suitable for describing computations involving collisions. ACM Trans. Graph., Vol. 45, No. 4, Article 142. Publication d… view at source ↗
Figure 11
Figure 11. Figure 11: Illustration of the compilation pipeline for a Hessian computation into a final linkable dynamic library. When the Hessian computation has a structure [PITH_FULL_IMAGE:figures/full_fig_p015_11.png] view at source ↗
Figure 12
Figure 12. Figure 12: A small example of collision energy involving two types of vertices. [PITH_FULL_IMAGE:figures/full_fig_p016_12.png] view at source ↗
Figure 14
Figure 14. Figure 14: A soft bunny is dropped onto a cloth sheet whose four corner [PITH_FULL_IMAGE:figures/full_fig_p016_14.png] view at source ↗
Figure 16
Figure 16. Figure 16: We additionally drop a bunny controlled by a cage deformation. [PITH_FULL_IMAGE:figures/full_fig_p017_16.png] view at source ↗
Figure 19
Figure 19. Figure 19: The total lines of code (LOC) for each part of the first three simu [PITH_FULL_IMAGE:figures/full_fig_p018_19.png] view at source ↗
Figure 20
Figure 20. Figure 20: Runtime distribution for the cloths-on-bunny simulation (Sec. [PITH_FULL_IMAGE:figures/full_fig_p019_20.png] view at source ↗
Figure 22
Figure 22. Figure 22: Scalability with respect to the number of bunnies for the simula [PITH_FULL_IMAGE:figures/full_fig_p020_22.png] view at source ↗
Figure 23
Figure 23. Figure 23: Time comparison for PSD projection with and without YASPS opti [PITH_FULL_IMAGE:figures/full_fig_p020_23.png] view at source ↗
Figure 24
Figure 24. Figure 24: We compute the Hessian and its projection of the Baraff-Witkin [PITH_FULL_IMAGE:figures/full_fig_p021_24.png] view at source ↗
Figure 26
Figure 26. Figure 26: Overhead of computing the Hessian of the determinant operator for [PITH_FULL_IMAGE:figures/full_fig_p021_26.png] view at source ↗
Figure 25
Figure 25. Figure 25: Average time required by PyTorch, JAX, and SymPy to compute the gradient and Hessian of a single instance, normalized by the runtime of YASPS. YASPS exhibits increasing performance advantages as the energy formulation becomes more complex. The x-axis is on a log scale. we match and in some cases outperform all baseline methods, as shown in [PITH_FULL_IMAGE:figures/full_fig_p021_25.png] view at source ↗
Figure 28
Figure 28. Figure 28: Compilation time under different compilation strategies (in sec [PITH_FULL_IMAGE:figures/full_fig_p022_28.png] view at source ↗
Figure 29
Figure 29. Figure 29: A textbook mass-spring system implemented in YASPS. Color in [PITH_FULL_IMAGE:figures/full_fig_p023_29.png] view at source ↗
Figure 30
Figure 30. Figure 30: Time comparison for a single SpMV operation using different stor [PITH_FULL_IMAGE:figures/full_fig_p023_30.png] view at source ↗
Figure 31
Figure 31. Figure 31: At the beginning of differentiation, YASPS fixes the layout of the [PITH_FULL_IMAGE:figures/full_fig_p025_31.png] view at source ↗
Figure 32
Figure 32. Figure 32: We continuously twist a piece of cloth for 2 seconds, with a time [PITH_FULL_IMAGE:figures/full_fig_p027_32.png] view at source ↗
Figure 33
Figure 33. Figure 33: The two metrics defined in Eq. (11) and Eq. (12) for the simulation shown in [PITH_FULL_IMAGE:figures/full_fig_p027_33.png] view at source ↗
Figure 34
Figure 34. Figure 34: We drop 10 bunnies in a container with different settings to show [PITH_FULL_IMAGE:figures/full_fig_p028_34.png] view at source ↗
Figure 35
Figure 35. Figure 35: Core YASPS syntax. The left grammar defines declarations for scenes, meshes, primitives, connectivity relations. The right grammars define attribute [PITH_FULL_IMAGE:figures/full_fig_p030_35.png] view at source ↗
Figure 36
Figure 36. Figure 36: Results after 1.5 seconds of simulation. Left: each cage is treated as [PITH_FULL_IMAGE:figures/full_fig_p031_36.png] view at source ↗
read the original abstract

Incremental Potential Contact (IPC) enables robust, contact-rich simulation by casting elasticity and contact as a single energy minimization problem, but high-performance IPC pipelines are typically built from specialized kernels and assembly logic tied to fixed energies, primitive types, and parameterizations, making extensions costly and combinatorial. We present YASPS, a GPU-oriented framework that removes this extensibility bottleneck by making structure explicit in a differentiable intermediate representation. YASPS introduces two first-class relational operators: JOIN, which composes dependent quantities across user-declared relations (e.g., element-to-vertex connectivity), and UNION, which represents alternative parameterizations within a relation (e.g., mixing free vertices with affine-body or other parameterizations without fragmenting the program). Because JOIN and UNION are part of the symbolic program, YASPS differentiates through them using dedicated rules and an efficient second-order procedure that reuses intermediate Jacobians and reduces Hessian-projection cost. From the same relational description, YASPS derives the global gradient/Hessian sparsity and block layout, enabling structure-aware block-sparse storage and compression, and JIT-compiles CUDA kernels for evaluation, derivatives, assembly, and solving. Across IPC-style examples, including layered cloth-on-bunny, mixed rigid/deformable bunnies, and a caged deformation model, YASPS supports rapid front-end extensions with minimal back-end changes while achieving competitive end-to-end performance; its Hessian compression yields near 10x faster CG iterations in our benchmarks.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 1 minor

Summary. The paper introduces YASPS, a GPU-oriented symbolic framework for Incremental Potential Contact (IPC) simulation. It makes relational structure explicit via two first-class operators—JOIN (for composing dependent quantities across user-declared relations such as element-to-vertex connectivity) and UNION (for alternative parameterizations within a relation)—and supplies dedicated first-order differentiation rules together with an efficient second-order procedure that reuses intermediate Jacobians to reduce Hessian-projection cost. From the same relational description the framework derives global gradient/Hessian sparsity and block layout, enables structure-aware block-sparse storage and compression, and JIT-compiles CUDA kernels for evaluation, derivatives, assembly and solving. Across IPC-style examples the authors claim that YASPS supports rapid front-end extensions with minimal back-end changes while delivering competitive end-to-end performance, with Hessian compression yielding near 10× faster CG iterations.

Significance. If the performance claims hold, the work would meaningfully lower the engineering cost of extending high-performance IPC pipelines by decoupling relational structure from hand-written kernels while preserving efficiency through symbolic differentiation and structure-aware compilation. Such a framework could accelerate research on contact-rich simulation in graphics.

major comments (2)
  1. [Abstract] Abstract: the central claim that the dedicated first-order rules for JOIN/UNION together with the second-order Jacobian-reuse procedure produce end-to-end runtimes competitive with specialized kernels is load-bearing, yet the manuscript supplies no per-component timing breakdown (symbolic traversal cost, Jacobian-reuse savings, projection cost, assembly overhead) that would confirm the net overhead remains modest.
  2. [Abstract] Abstract: the reported “near 10× faster CG iterations” from Hessian compression is presented without a description of the compression algorithm, the baseline solver configuration, or the precise benchmark conditions, preventing assessment of whether the speedup is attributable to the relational representation or to other implementation choices.
minor comments (1)
  1. [Abstract] The abstract refers to “our benchmarks” without stating the hardware platform, problem sizes, or exact comparison baselines used for the end-to-end timing and CG measurements.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for the detailed and constructive report. The two major comments correctly identify that the abstract's performance claims would benefit from additional supporting details to allow readers to fully assess the contributions. We address each point below and commit to revisions that strengthen the manuscript without altering its core claims.

read point-by-point responses

  1. Referee: [Abstract] Abstract: the central claim that the dedicated first-order rules for JOIN/UNION together with the second-order Jacobian-reuse procedure produce end-to-end runtimes competitive with specialized kernels is load-bearing, yet the manuscript supplies no per-component timing breakdown (symbolic traversal cost, Jacobian-reuse savings, projection cost, assembly overhead) that would confirm the net overhead remains modest.

    Authors: We agree that isolating the costs of symbolic traversal, Jacobian reuse, Hessian projection, and assembly would make the competitiveness claim more transparent. The current manuscript reports aggregate end-to-end timings and overall speedups relative to hand-written baselines, but does not decompose the symbolic overheads. In the revised version we will add a dedicated timing table (likely in Section 5 or a new subsection) that breaks down these components across the reported benchmarks, allowing readers to verify that the net overhead of the relational representation remains modest. revision: yes

  2. Referee: [Abstract] Abstract: the reported “near 10× faster CG iterations” from Hessian compression is presented without a description of the compression algorithm, the baseline solver configuration, or the precise benchmark conditions, preventing assessment of whether the speedup is attributable to the relational representation or to other implementation choices.

    Authors: The referee is right that the abstract alone does not supply enough context for the 10× CG claim. The manuscript body (Section 4.3) describes the block-sparse compression derived from the relational structure and compares against an uncompressed block-sparse CG baseline on the same scenes; however, these details are not summarized in the abstract. We will revise the abstract to briefly indicate the compression method, the baseline (uncompressed block-sparse CG with identical solver tolerances), and the benchmark conditions (specific IPC examples and iteration counts), while keeping the abstract concise. This change will make the attribution to the relational representation clearer. revision: yes

Circularity Check

0 steps flagged

No circularity; framework presented as implementation technique without self-referential derivations

full rationale

The paper introduces a GPU-oriented symbolic framework using relational operators JOIN and UNION, dedicated differentiation rules, Jacobian reuse for second-order derivatives, and structure-aware Hessian compression. No equations, fitted parameters, or predictions are shown that reduce to their own inputs by construction. Performance claims rest on benchmark results rather than any derivation chain that loops back to fitted quantities or self-citations. The work is self-contained as an engineering contribution with no load-bearing self-citation or ansatz smuggling identified in the provided text.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

Abstract supplies no concrete free parameters, axioms, or invented entities; the framework description does not introduce fitted constants or new physical postulates.

pith-pipeline@v0.9.0 · 5811 in / 1107 out tokens · 22547 ms · 2026-05-25T04:52:29.981644+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

30 extracted references · 30 canonical work pages

  1. [1]

    Teseo Schneider and Jérémie Dumas and Xifeng Gao and Denis Zorin and Daniele Panozzo , title =

    work page

  2. [2]

    and Lin, Huancheng and Komura, Taku , year=

    Huang, Kemeng and Chitalu, Floyd M. and Lin, Huancheng and Komura, Taku , year=. GIPC: Fast and Stable Gauss-Newton Optimization of IPC Barrier Energy , volume=. ACM Transactions on Graphics , publisher=. doi:10.1145/3643028 , number=

    work page doi:10.1145/3643028

  3. [3]

    2025 , publisher =

    Huang, Kemeng and Lu, Xinyu and Lin, Huancheng and Komura, Taku and Li, Minchen , title =. 2025 , publisher =. doi:10.1145/3735126 , journal =

    work page doi:10.1145/3735126 2025

  4. [4]

    and Bender, Jan , booktitle=

    Fernández-Fernández, José Antonio and Lange, Ralph and Laible, Stefan and Arras, Kai O. and Bender, Jan , booktitle=. STARK: A Unified Framework for Strongly Coupled Simulation of Rigid and Deformable Bodies with Frictional Contact , year=

    work page

  5. [5]

    SymX: Energy-based Simulation from Symbolic Expressions , year =

    Fern\'. SymX: Energy-based Simulation from Symbolic Expressions , year =. ACM Trans. Graph. , month = oct, articleno =. doi:10.1145/3764928 , abstract =

    work page doi:10.1145/3764928

  6. [6]

    ACM Trans

    Herholz, Philipp and Stuyck, Tuur and Kavan, Ladislav , title =. ACM Trans. Graph. , month = nov, articleno =. 2024 , issue_date =. doi:10.1145/3687986 , abstract =

    work page doi:10.1145/3687986 2024

  7. [7]

    and Born, J

    Schmidt, P. and Born, J. and Bommes, D. and Campen, M. and Kobbelt, L. , title =. Computer Graphics Forum , volume =. doi:https://doi.org/10.1111/cgf.14607 , url =. https://onlinelibrary.wiley.com/doi/pdf/10.1111/cgf.14607 , abstract =

    work page doi:10.1111/cgf.14607

  8. [8]

    ACM Trans

    Yu, Chang and Xu, Yi and Kuang, Ye and Hu, Yuanming and Liu, Tiantian , title =. ACM Trans. Graph. , month = nov, articleno =. 2022 , issue_date =. doi:10.1145/3550454.3555430 , abstract =

    work page doi:10.1145/3550454.3555430 2022

  9. [9]

    2020 , eprint=

    DiffTaichi: Differentiable Programming for Physical Simulation , author=. 2020 , eprint=

    work page 2020

  10. [10]

    2019 , eprint=

    PyTorch: An Imperative Style, High-Performance Deep Learning Library , author=. 2019 , eprint=

    work page 2019

  11. [11]

    2016 , pages =

    Bernstein, Gilbert Louis and Shah, Chinmayee and Lemire, Crystal and Devito, Zachary and Fisher, Matthew and Levis, Philip and Hanrahan, Pat , title =. 2016 , pages =

    work page 2016

  12. [12]

    ACM Transactions on Graphics (TOG) , volume=

    Simit: A language for physical simulation , author=. ACM Transactions on Graphics (TOG) , volume=. 2016 , publisher=

    work page 2016

  13. [13]

    , title =

    Li, Minchen and Ferguson, Zachary and Schneider, Teseo and Langlois, Timothy and Zorin, Denis and Panozzo, Daniele and Jiang, Chenfanfu and Kaufman, Danny M. , title =. ACM Trans. Graph. , month = aug, articleno =. 2020 , issue_date =. doi:10.1145/3386569.3392425 , abstract =

    work page doi:10.1145/3386569.3392425 2020

  14. [14]

    2022 , eprint=

    Affine Body Dynamics: Fast, Stable & Intersection-free Simulation of Stiff Materials , author=. 2022 , eprint=

    work page 2022

  15. [15]

    ACM Transactions on Graphics (TOG) , volume=

    Codimensional incremental potential contact , author=. ACM Transactions on Graphics (TOG) , volume=. 2021 , publisher=

    work page 2021

  16. [16]

    ACM Transactions on Graphics , volume=

    Intersection-free rigid body dynamics , author=. ACM Transactions on Graphics , volume=

    work page

  17. [17]

    ACM Transactions on Graphics (TOG) , volume=

    A unified newton barrier method for multibody dynamics , author=. ACM Transactions on Graphics (TOG) , volume=. 2022 , publisher=

    work page 2022

  18. [18]

    Acta Geotechnica , volume=

    Hybrid continuum--discrete simulation of granular impact dynamics , author=. Acta Geotechnica , volume=. 2022 , publisher=

    work page 2022

  19. [19]

    ACM SIGGRAPH 2024 Conference Papers , pages=

    A dynamic duo of finite elements and material points , author=. ACM SIGGRAPH 2024 Conference Papers , pages=

    work page 2024

  20. [20]

    Computer Methods in Applied Mechanics and Engineering , volume=

    BFEMP: Interpenetration-free MPM--FEM coupling with barrier contact , author=. Computer Methods in Applied Mechanics and Engineering , volume=. 2022 , publisher=

    work page 2022

  21. [21]

    ACM Transactions on Graphics (TOG) , volume=

    A contact proxy splitting method for Lagrangian solid-fluid coupling , author=. ACM Transactions on Graphics (TOG) , volume=. 2023 , publisher=

    work page 2023

  22. [22]

    1998 , isbn =

    Baraff, David and Witkin, Andrew , title =. 1998 , isbn =. doi:10.1145/280814.280821 , booktitle =

    work page doi:10.1145/280814.280821 1998

  23. [23]

    2015 , publisher=

    Numerical algorithms: methods for computer vision, machine learning, and graphics , author=. 2015 , publisher=

    work page 2015

  24. [24]

    ACM Transactions on Graphics (TOG) , volume=

    A GPU-based multilevel additive schwarz preconditioner for cloth and deformable body simulation , author=. ACM Transactions on Graphics (TOG) , volume=. 2022 , publisher=

    work page 2022

  25. [25]

    Surface-Filling Curve Flows via Implicit Medial Axes , year =

    Noma, Yuta and Sell\'. Surface-Filling Curve Flows via Implicit Medial Axes , year =. ACM Trans. Graph. , month = jul, articleno =. doi:10.1145/3658158 , abstract =

    work page doi:10.1145/3658158

  26. [26]

    2008 , doi =

    Griewank, Andreas and Walther, Andrea , title =. 2008 , doi =

    work page 2008

  27. [27]

    , journal =

    Logg, Anders and Mardal, Kent-Andre and Wells, Garth N. , journal =. Automated solution of differential equations by the. 2012 , pages =

    work page 2012

  28. [28]

    ACM Transactions on Mathematical Software , volume =

    Unified Form Language: A domain-specific language for weak formulations of partial differential equations , author =. ACM Transactions on Mathematical Software , volume =. 2014 , pages =

    work page 2014

  29. [29]

    2022 , note =

    Warp: A High-Performance Python Framework for GPU Simulation and Graphics , author =. 2022 , note =

    work page 2022

  30. [30]

    ACM Trans

    Herholz, Philipp and Tang, Xuan and Schneider, Teseo and Kamil, Shoaib and Panozzo, Daniele and Sorkine-Hornung, Olga , title =. ACM Trans. Graph. , month = may, articleno =. 2022 , issue_date =. doi:10.1145/3520484 , abstract =

    work page doi:10.1145/3520484 2022