Computational form-finding is the inverse problem of choosing a shape for a vault, dome or shell so that its own weight flows to the supports in pure compression. Current methods are fast, differentiable and produce shapes that are in equilibrium by construction. That guarantee holds only for an idealized material: blocks that never slide, never crush, and carry any thrust. Real dry-joint and weak-mortar masonry mostly fails by blocks sliding or pivoting at their joints when the load tilts away from the design case, for example under ground acceleration or support movement. We propose to make that failure margin the design objective. The form-finder would choose a shape to match an architect's target and, at the same time, to maximize the largest lateral tilt the segmented block assembly can resist while every joint stays in compression, inside its Coulomb friction cone (the limit where shear force exceeds friction times normal force), and below a crushing stress.
The core move is to treat "can the blocks still carry this load?" as a small convex feasibility problem at each design step. We then differentiate the largest feasible tilt with respect to the shape parameters. The result is a form-finder whose gradients point toward shapes that stay standing when blocks can slip. Designing for slip is qualitatively different from designing for strength, because the friction condition depends on joint angles and not on size. Making the shell thicker or adding a safety factor cannot fix it.
Core Claim
Existing inverse form-finding certifies equilibrium under one load case for an idealized material. Several papers state this limit themselves. On the equilibrium of simplicial masonry structures optimizes compressive reciprocal duals on triangle meshes and assumes infinite compressive strength with no slip between blocks. Design of self-supporting surfaces with isogeometric analysis tunes smooth Airy stress functions and lists cracking and plasticity as future work. JAX FDM differentiates the force density method, which turns nonlinear bar-network equilibrium into a linear system in edge force-to-length ratios. It lets bars take arbitrary thrust. Real-time design of architectural structures with differentiable mechanics and neural networks puts that solver inside a neural decoder and claims "integrity by construction." Object-Field makes a similar claim that closed force polyhedra remove the need for structural verification.
Forward discontinuum analysis contradicts the spirit of these claims. Breaking boundaries uses the PyBullet physics engine to simulate dry-joint masonry and shows that collapse is governed by sliding, rocking and joint opening under tilting and settlement. That paper is forward-only.
Our claim is that the collapse tilt of a block assembly can be made a differentiable function of the form-finding variables. Optimizing it moves designs to substantially higher collapse tilts than equilibrium-only form-finding does, at near-equal target-shape error. Uniform thickening cannot reach the same gains for the sliding-governed part of the margin.
Mechanism
The force densities $q$ come from the force density method. They define a thrust network. We give that network a thickness and cut it into voussoirs (wedge-shaped blocks) along a fixed segmentation, which yields a set of joint interfaces with known normals and areas.
For a lateral load factor $\lambda$, the load is gravity plus $\lambda$ times self-weight acting horizontally, which is equivalent to tilting the assembly by $\arctan\lambda$. We define the margin as
$$ \lambda^*(q) = \max_{\lambda,\,f} \ \lambda \quad \text{s.t.} \quad A(q)\,f = w_g + \lambda\, w_h,\quad f_j \in \mathcal{K}_j(\mu, \sigma_c), $$
where $f$ stacks the joint forces, $A(q)$ is the equilibrium matrix of the segmented assembly, and $w_g, w_h$ are the gravity and horizontal weight vectors. Each $\mathcal{K}_j$ is a convex set for joint $j$. It requires compressive normal force, shear force at most $\mu$ times the normal force (friction coefficient $\mu$), a resultant inside the contact face so the joint does not hinge open, and mean normal stress below the crushing strength $\sigma_c$. Together these conditions make a second-order cone program.
The design objective trades target-shape error against margin:
$$ \min_q \ \|x(q) - x^{\text{target}}\|^2 - \beta\, \lambda^*(q). $$
Here $x(q)$ are the equilibrium node positions and $\beta$ sets the tradeoff. We obtain gradients of $\lambda^*$ from the optimality conditions of the cone program, using the envelope theorem through its dual variables. We chain these through the implicit differentiation that JAX FDM already provides. The margin is nonsmooth when the set of binding joints changes, so we smooth it with a log-barrier relaxation that we anneal to zero.
This static check has a known caveat. With non-associative friction, a statically admissible force state does not strictly guarantee safety. The model is therefore a design proxy and not a certificate, and all claims are validated by dynamic simulation and physical tilt tests.
Research Program
We build the margin layer as a JAX module on top of the open-source JAX FDM code. We then study three questions.
The first is how much margin equilibrium-only designs leave on the table on standard shells. The second is whether the gradient-based design moves collapse modes from sliding to rocking. The third is whether the gains survive a forward discontinuum simulator and physical specimens.
We also test an amortized version that places the margin in the training loss of the encoder–solver architecture from Real-time design of architectural structures with differentiable mechanics and neural networks. That paper's hard sign constraint $q \le 0$ leaves compressive force unbounded. We keep that constraint and add the crushing and friction terms only through the margin.
Baselines
The naive reference is equilibrium-only inverse form-finding with JAX FDM on the same target shapes, segmentation, thickness and $\mu$. We report its $\lambda^*$ and PyBullet collapse tilt. The JAX FDM paper reports a four-orders-of-magnitude reduction in target-shape distance. It reports no collapse margin, so our comparison is at matched shape error.
The strongest existing competitor is the decoupled workflow of idealized design followed by discontinuum screening, upgraded into black-box search. CMA-ES, a standard gradient-free evolutionary optimizer, runs over $q$ and uses the PyBullet collapse tilt from Breaking boundaries as its objective. It gets the same wall-clock budget and the same shape-error penalty. It is strong because it optimizes the dynamic failure measure directly and needs no convex relaxation.
The third baseline is the safety-factor route: equilibrium-only designs uniformly thickened until they match our design's material volume.
Ablations remove the friction cone, leaving only no-tension, no-hinging and crushing, and separately remove the crushing term. These isolate which ingredient produces the gains.
We count a result as beating the baselines if our method raises the PyBullet collapse tilt over equilibrium-only designs at matched shape error and over thickened designs at matched volume. It must also match or exceed CMA-ES at equal compute. No reported result found on Lacuna for collapse tilt of form-found shells, so every baseline number is produced here.
Why not just…?
Why not just thicken the shell or apply a safety factor? Rocking resistance grows with thickness relative to span. Sliding under tilt does not. A joint slips when the tilted resultant leans past the friction angle measured from the joint normal, and that angle depends on joint orientation, not on scale. The volume-matched thickening baseline tests this directly. We expect it to recover rocking-governed margin but not sliding-governed margin. If thickening matches us across the board, the proposal's premise is wrong, and that is a publishable negative result.
Why not just generate idealized designs and screen or search them in PyBullet? Screening alone cannot correct a failing design. Search with dozens to hundreds of force-density variables is the real threat, because each PyBullet run takes minutes (under 5 minutes per wall in Breaking boundaries). That same paper reports collapse angles underestimated by up to 32%, caused by premature slip from coupling between contact stiffness and friction. A black-box search could therefore learn to exploit simulator artifacts. The equal-budget CMA-ES comparison settles the efficiency question, and physical tests settle the artifact question.
Why not just add a stress cap to the force densities? This is a few lines in JAX FDM and fills the crushing gap. Stresses in small masonry shells are usually far below crushing, though. The crushing-only ablation measures whether this cheap fix explains any of the gain, and we expect it explains little of it.
Why not just train a surrogate or physics-informed network on collapse data? The authors of Real-time design of architectural structures report that physics-informed networks break equilibrium softly and generalize poorly out of distribution. Surrogates of nonlinear mechanics in Neural Metamaterial Networks needed 900,000 to 4,500,000 simulations per family. Our margin layer needs no training data.
Proposed Experiments
We use the shell benchmarks from the file: the Lilium Tower, groin vault, dome with circular oculus, and oval dome from the simplicial and isogeometric papers, plus the creased shell from JAX FDM. Each is segmented at two block counts and swept over $\mu$ from 0.4 to 0.8.
The metrics are target-shape error, static margin $\lambda^*$, PyBullet collapse tilt and failure mode, and runtime. As a sanity check, we first reproduce the Restrepo Vélez tilting assemblies used in Breaking boundaries with our static margin. We report its gap from experiment next to PyBullet's.
The first decisive check is rank correlation between $\lambda^*$ and the PyBullet collapse tilt across all designs. Without it, the proxy is useless.
The second decisive check is physical. We 3D-print blocks for three shells, each in two versions: equilibrium-only and margin-optimized at matched shape error. We measure their collapse angles on a tilt table in five repeats. The proposal succeeds if the margin-optimized shells fail at consistently higher tilts, and if the failure modes shift from sliding toward rocking as the method predicts.
A secondary check applies incremental support settlement in PyBullet. It tests whether tilt-optimized designs also tolerate settlement or whether the two margins trade off.
References
- On the equilibrium of simplicial masonry structures
- Design of self-supporting surfaces with isogeometric analysis
- JAX FDM: A differentiable solver for inverse form-finding
- Real-time design of architectural structures with differentiable mechanics and neural networks
- Object-Field
- Breaking boundaries: discontinuum failure analysis of dry-joint masonry using physics engine models
- Neural Metamaterial Networks for Nonlinear Material Design