acceptodds
Withdrawn from ICLR 2027

DiffGIPC: Differentiable Mixed-Coordinate Contact Dynamics on GPU

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Contact-rich design and control in robotics require efficient gradients through interactions between deformable and nearly rigid bodies. Representing all components with full-space finite elements (FEM) introduces unnecessary motion degrees of freedom for nearly rigid bodies, while high stiffness makes repeated forward and backward solves costly. We present DiffGIPC, a GPU-accelerated framework for differentiable simulation and gradient-based optimization that couples affine body dynamics (ABD) with FEM-based deformable bodies under Incremental Potential Contact (IPC). We derive gradients for affine rest shapes, initial states, and joint controls while retaining only twelve motion DoFs per affine body in each backward system. The formulation differentiates shape-dependent mass and surface-point maps and retains collision, friction, and joint coupling, allowing one body's parameters to be optimized for their effects on other objects. GPU-parallel derivative evaluation, device-controlled adjoint solves, and local gradient accumulation accelerate the backward pass. A reusable PyTorch interface connects supported physical parameters to user-defined parameter maps and losses across design, identification, motion, placement, and articulated control. Experiments demonstrate peak speedups over DiffIPC of approximately 150x with full-space FEM and over 2900x with affine bodies for combined simulation and gradient evaluation.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Differentiable Optimization, Physical Simulation, Adjoint Methods, GPU Acceleration, Robot Control

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_dVWpOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper introduces DiffGIPC, a GPU-accelerated framework for differentiable physics simulation that couples Affine Body Dynamics (ABD) for nearly rigid bodies with Finite Element Method (FEM) deformable models under Incremental Potential Contact (IPC). By representing nearly rigid bodies using affine coordinates, the framework reduces the system size to only twelve degrees of freedom per body during backward adjoint solves while preserving full surface collision, friction, and joint coupling. DiffGIPC derives analytical gradients for shape-dependent mass distributions, affine rest shapes, initial states, and articulated joint controls without omitting crucial interaction terms.

Critical strengths
  • Massive Computational Acceleration: By coupling Affine Body Dynamics (ABD) with FEM, DiffGIPC reduces nearly rigid bodies to just 12 motion degrees of freedom per body during backward solves, yielding GPU-accelerated speedups of up to 150×150\times over DiffIPC for full-space FEM models and over 2900×2900\times when utilizing affine body representations.

  • Exact and Complete Coupled Differentiation: The framework derives explicit analytical gradients for affine rest shapes, shape-dependent mass distributions, initial states, and joint controls. It does so while maintaining full physical coupling—including IPC barrier collisions, friction history, and articulated joint constraints—across deformable and rigid interactions.

  • GPU-Optimized Backward Execution: DiffGIPC minimizes CPU-GPU synchronization and host-side overhead during adjoint Preconditioned Conjugate Gradient (PCG) solves by implementing conditional CUDA Graphs and parallel local gradient accumulation directly on the GPU.

Critical weaknesses
  • Inability to Model Local Deformation on Affine Bodies: Affine bodies are restricted to linear spatial transformations and cannot resolve local, non-affine deformations. Any component that requires localized structural flexing or complex shape deformation must be modeled using full-space FEM, which reintroduces higher computational overhead.
  • Optimization Limitations with Contact Barriers and Non-Differentiated Operations: Gradients only flow through active, recorded contact and control branches; inactive barriers offer zero gradient guidance toward establishing new, uninitiated contacts. Additionally, discrete operations such as mesh remeshing (used during rest-shape design to fix degraded elements) are not differentiated, causing abrupt jumps in the objective function during optimization.
  • Restricted Parameter Support and High Memory Growth: The framework does not support all physical parameter combinations—for example, it cannot differentiate FEM rest shapes in systems containing affine DoFs, nor can it handle active friction in static equilibrium modes. Furthermore, because full frame state data must be saved to perform reverse-pass adjoint solves, memory storage scales linearly with trajectory length and can become a bottleneck for long simulation horizons

Overall, the key issues are: (a) Zero-Gradient Contact Barriers; (b) Non-Differentiable Remeshing; (c) Linear Memory Scale with Trajectory; (d) incremental novelty.

Questions for authors

Can you please address the following issues & concerns:

  1. Zero-Gradient Barriers & Contact Discovery -- Since IPC relies on a localized activation distance threshold (d^\hat{d}), non-interacting bodies yield zero gradients. In tasks where initial parameters place objects completely out of range, how do you handle contact discovery, and have you considered pairing DiffGIPC with randomized smoothing or long-range contact potentials?

  2. Discontinuities from Remeshing -- In shape design tasks like Loaded Support, periodic remeshing is used to prevent element degeneration, which introduces abrupt jumps in the discrete loss curve. How do these non-differentiable remeshing events affect optimizer convergence (e.g., Adam or L-BFGS step sizes), and are there plans to incorporate differentiable remeshing or adaptive mesh integration?

  3. GPU Memory Bottlenecks & Checkpointing -- The reverse pass requires saving the full converged state for every simulation frame, causing memory storage to scale linearly with trajectory length. What is the peak VRAM usage for your largest benchmarks, and what strategy or checkpointing scheme (e.g., selective recomputation) do you plan to implement for long-horizon tasks?

  4. Convergence & Failures in CUDA Graph PCG Solvers -- Algorithm 2 specifies that if the adjoint PCG solve fails its true-residual check after two restarts, the backward pass terminates and stops the iteration. How frequently do these linear solver failures occur during deep optimization rollouts, and how does the optimizer handle an unreturned parameter gradient?

  5. Kinematic Singularities & Derivative Boundaries -- For joint controls, the revolute angle derivative floors denominators at 10−2010^{-20} to prevent division by zero near singularities, and joint limiters use a saturated step-function convention. Have you observed any gradient instability or zero-gradient trapping around these saturation boundaries during articulated robot tasks?

  6. Isolating Algorithmic Acceleration vs. Representation Reduction -- The peak speedup of >2900×>2900\times over DiffIPC combines GPU optimizations with a change in physical representation (ABD vs. full-space FEM). What fraction of that speedup is purely due to the GPU adjoint solver architecture (CUDA Graphs, parallel local accumulation) versus the reduction in degrees of freedom from affine coordinates?

Reviewer_KSoNOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The paper contributes DiffGIPC, a GPU system that computes gradients for incremental-potential contact simulation with objects in mixed coordinates: deformable parts keep free FEM vertices, and stiff or rigid-like parts use affine bodies with twelve motion degrees of freedom each. Compared with DiffIPC, which derives FEM adjoints on the CPU for a full-space model, the paper couples the FEM and affine adjoints on the GPU and adds the derivatives that affine shape optimization requires, namely the rest-dependent mass matrix and the surface point maps, together with initial-state and joint differentiation. The stated contribution list therefore contains the differentiation formulation, the GPU-parallel backward computation that turns each converged time-step equation into a coupled FEM-affine adjoint system solved with a device-controlled iterative method on top of the inherited StiffGIPC forward solver, and a reusable PyTorch interface that connects supported parameters to user-defined losses without task-specific backward code. The supported parameter combinations are restricted, as Appendix D.4.3 states.

The evaluation compares DiffGIPC with DiffIPC, the CPU differentiable solver for the same model, on five shared FEM tasks. Terminal losses come out comparable or lower for DiffGIPC in Figure 3, and Table 5 reports 9.09 to 25.75 times lower backward cost and 10.61 to 49.45 times lower combined cost, measured on an RTX 4090 against DiffIPC's 32 CPU threads. A bunny resolution study reports 151.14 times at the densest resolution when both systems keep FEM, and 2970.31 times when affine coordinates replace FEM on both bodies, which the authors state mixes GPU optimizations with a representation change. Five further tasks, plus grasp-angle control reported only in the appendix, run from stone placement to dual-arm grasping and take 1.32 to 406.77 seconds per optimization on one GPU. The authors also state that affine bodies cannot resolve local deformation and that gradients follow recorded contact branches.

Critical strengths
  1. The coupled FEM-affine adjoint is complete, and the new derivative content is derived rather than skipped. Differentiating the incremental potential with respect to affine rest shapes requires the shape-dependent mass matrix and surface point map derivatives, which Section C provides, and the paper derives the velocity-reset and static-equilibrium cases separately in Equations 18 and 19. The appendices give the coordinate order, the local collision and friction laws, and the coupled matrix blocks, so a reader can reimplement from the manuscript.

  2. The timing reporting is careful and the task coverage is wide. The authors disclose that the largest ratios mix hardware, implementation, and representation changes, that the Other timing categories are residuals from subtraction, and that the Garment Hanger progress curve truncates rollouts and adds an offset that is not a zero physical loss. Table 1 shows ten complete optimizations on one GPU, from 1.32 seconds for material fitting to 406.77 seconds for Loaded Support design, and Appendix Table 7 adds grasp-angle control as an eleventh. Because Figure 3 also compares terminal losses with DiffIPC, the speed numbers are not presented without an optimization-quality anchor.

Critical weaknesses
  1. The technical core is narrow for what the system framing promises. The related work itself states that DiffIPC derives the FEM contact and friction adjoints and that DiffGIPC retains this equation-level approach, and the forward solver and global Hessian assembly are inherited from StiffGIPC. What remains new is therefore the GPU assembly and solution of the coupled FEM-affine adjoints, the rest-dependent mass and point-map derivatives, and the initial-state and joint differentiation. That is a solid but moderate increment. Since my direct research experience in this area is limited, I present the following judgment as informed but unverified: the paper reads more as a systems and engineering advance on an established graphics model than as a new formulation or insight, and I would welcome the authors' arguments to the contrary.

  2. The efficiency evidence rests on one baseline and cannot be checked or reused. DiffIPC runs on 32 CPU threads while DiffGIPC uses one RTX 4090, so the ratios in Figure 4 and Table 5 measure hardware together with implementation and cannot isolate the backward algorithm. The paper places DiffPhD (Lai et al., 2026) in the projective-dynamics family and cites the long-range influence contacts of Ye et al. (2026) among approaches that change the contact model or search direction, but no experiment shows why a shared quantitative comparison is infeasible, for example a task on which the systems produce different gradients. The code is not released and no reproducibility statement is given, the supported parameter combinations are restricted, and the tasks are custom scenes that depend on hand-set details, such as the stone-placement loss that relaxes a centroid tolerance from 0.01 to 0.15 after 50 updates and the truncated-rollout accounting for the Garment Hanger. Because of this, the efficiency claims and the engineering decisions behind the settings cannot be verified or reused, which lowers the value of the paper beyond its reported numbers.

Questions for authors
  1. The paper cites DiffPhD and Ye et al. 2026 but does not compare with them. If the tasks reported in the paper cannot serve for such a comparison, are there other tasks on which the proposed method and these GPU methods can be compared, and what would a fair comparison on such a task require?

  2. Have the newly derived gradients for affine rest shapes, the mass matrix, the point maps, and initial states been validated against finite differences or an independent autodiff reference, beyond the indirect check that the two systems reach comparable terminal losses in Figure 3? When the active contact set changes during an optimization, inactive barriers provide no interaction gradient, so how often did the reported optimizations stall or need the kind of staged tolerances seen in stone placement, and is such staging a general requirement for contact-changing problems?

Reviewer_4iYtOpenReview ↗
Rating
3
Confidence
1
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

This paper presents DiffGIPC, a GPU-based differentiable simulator that combines FEM for deformable objects with affine-body dynamics for nearly rigid objects under IPC contact and friction.

The main idea is to keep detailed surface geometry while using only 12 motion DoFs for each affine body, and to derive gradients for shape, initial states, and joint controls in this mixed-coordinate system.

The paper reports large speedups over DiffIPC and demonstrates the framework on several design, identification, placement, and robot-control tasks.

Critical strengths

The paper addresses an important practical problem: differentiable contact simulation can be very expensive, especially when stiff or nearly rigid objects are represented with full FEM.

The framework seems quite complete. It supports mixed FEM/affine objects, contact, friction, shape optimization, initial-state optimization, and articulated control in one system.

The implementation appears efficient, and the reported runtime improvements are large across several examples.

Critical weaknesses
  1. I could not find a clear numerical gradient validation for the newly derived gradients. Since the paper introduces several non-trivial derivatives, especially for affine rest shapes, mass, collision, friction, and joint controls, I think finite-difference checks would be useful to verify correctness.

  2. The main speed comparison is between DiffGIPC on an RTX 4090 GPU and DiffIPC on a 32-thread CPU. Therefore, the reported speedups mix together hardware differences, GPU implementation, solver changes, and the new method itself. It is difficult to understand how much improvement comes from each contribution.

  3. Some of the largest speedups also change the physical representation from full FEM to affine bodies. Since the affine and FEM versions can produce different physical behavior, I would like to see a clearer accuracy-versus-efficiency comparison between the two representations.

Questions for authors
  1. Could the authors provide finite-difference gradient checks for the main newly supported parameters, especially affine rest shape, friction, initial states, and joint controls?

  2. Could the authors provide an ablation of the runtime improvements, for example CUDA Graph on/off and GPU backward with/without the proposed optimizations? This would help separate the contribution of the new backward method from the GPU/implementation advantage.

  3. For the FEM-to-affine comparisons, could the authors quantify the difference in physical trajectories or optimization results? This would make the very large speedups easier to interpret.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Discussion (0)

Sign in to comment.