Engineering-grade physics simulation without compromises

Introducing Anvil

Anvil is our state-of-the-art physics solver for robotics and industrial digital twins. When compared to other physics engines, Anvil achieves best-in-class stability, reliability and accuracy without compromising on real-time performance. It delivers the advantages of a direct solver without the associated performance costs. Across many tests, Anvil approaches or even exceeds the performance of highly optimized iterative Projected Gauss-Seidel (PGS) solvers.

Engineering Grade

Most legacy industrial simulation software uses physics engines that were originally designed for games. These physics engines make many approximations to achieve real-time performance. Such approximations result in what the industry terms “plausible physics”. In other words, the physics behavior appears reasonable to the untrained eye, provided that everything is configured within a fairly narrow range. In practice, this means:

• No large mass ratios
• No small moments of inertia
• No small or thin collision geometry
• No long chains of joints
• No stiff springs

Whilst all of the above are quite severe limitations, the first is particularly problematic. Large mass ratios are extremely common, even in situations where you wouldn’t expect them. For example, a stack of boxes can become unstable because the box at the bottom of the stack experiences the weight of all the boxes stacked on top of it. This means that even if all the boxes in the stack have identical masses, increasing the number of boxes in the stack will quickly cause the stack to collapse.

There are a few commercial physics engines that resolve these issues by using direct solvers. Unlike iterative methods, such as Projected Gauss-Seidel, direct methods solve all the constraint equations simultaneously. This often allows them to resolve the system of equations to near floating point precision. The downside is that you pay for the improved stability and accuracy with an extremely heavy computational cost. Direct solvers can run thousands of times slower than iterative methods, which solve each constraint one at a time. The time complexity for direct solvers is O(n³), meaning that the time taken to solve the system of constraints is proportional to the number of constraints cubed. Worse still, the constant of proportionality is usually very high.

Direct solvers are only capable of achieving real-time performance for scenes consisting of small numbers of interdependent constraints. Anvil has a lower time complexity, much lower constant of proportionality and normally converges using very few iterations. This makes it usable for real-time simulation of contact-rich environments, which can consist of tens of thousands of contact points. Scenes containing pallets of densely stacked boxes, or thousands of totes on conveyors, can be solved both accurately and efficiently by Anvil.

Why this Matters

One of the most common uses for industrial digital twins is testing machine behavior and control logic. Without adequate physics stability, reliability and accuracy, users end up testing the physics engine rather than the virtual prototype of the machine. You detect failures that wouldn’t happen in reality, or even worse, fail to detect failures that would happen in reality. As a result, in just about every digital twin we’ve seen created with the traditional and extremely expensive software options available, you will find many hacks to work around physics issues. This all dramatically slows down the creation of the digital twin, and erodes trust in the data that you collect.

Whenever users begin working with such software, their instinct is to import the CAD unchanged and start adding physics, specifying accurate masses. When running the simulation, they are immediately met with a mess of jittering parts, separating joints and a whole host of other issues. They’re quickly told that they need to “just set all the masses to 1kg and scale up the inertia tensor”. Want to grip things with friction? Sorry, can’t be done. Just reparent the entity. Need to stack boxes? You’ll need to “stick them together and disable physics”. Have small or thin parts with complex collision geometry? You’ll need to “increase the size of the part in the CAD and figure out how to manually decompose the geometry”.

Whilst all of these workarounds may leave you with a barely functioning simulation at the end, you’ll end up asking yourself what you’re really testing. You were sold software that could simulate your machine, but it’s not really your machine anymore. It’s a fuzzy approximation. And can you really trust the results that you’re seeing? Anvil addresses all of this, delivering robust, reliable and analytically validated physics with real-time performance characteristics. All without the need to tweak countless complex settings. In other words, Anvil gets out of your way and just works.

Comparison

Below, we compare Anvil to the most popular alternative physics solvers, including:

• NVIDIA PhysX (PGS)
• MuJoCo (Newton Solver)
• Commercial Sparse Direct Solver

NVIDIA PhysX is used widely across traditional industrial simulation software, including:

• Siemens NX MCD
• Visual Components
• Emulate3D
• ISG-virtuos
• NVIDIA Omniverse (Isaac Sim)
• Unity3D

Both Rockwell Automation’s Emulate3D and ISG-virtuos also support Algoryx AGX Dynamics, a commercial physics engine that includes a sparse direct solver. Others, such as Simumatik and Machineering iPhysics, use the Bullet physics engine, which uses an iterative solver and typically performs and behaves significantly worse than PhysX’s PGS solver. PhysX also includes a Temporal Gauss-Seidel (TGS) solver, but through extensive testing we found that it was much less stable than PGS for all but the most simple tests. It is therefore excluded from this comparison.

These tests were specifically selected to compare behavior and performance across a range of cases where iterative methods struggle, and a few where they excel. They’re not only academic, but rather include representations of common configurations we’ve seen in the wild. Most physics engines have some solver settings. We selected reasonable settings to make the comparisons as fair as possible. It should be noted that no comparison can be completely fair, but we tried our best in all cases.

All Engines: 10ms timestep
NVIDIA PhysX (PGS): 98 position iterations, 2 velocity iterations
MuJoCo (Newton): solref = (0.02, 1), solimp = (0.9999, 0.9999, 0.001, 0.5, 2), 100 maximum iterations
Commercial Sparse Direct Solver: 1E-4 contact regularization
Anvil: 1E-4 contact regularization, 100 maximum iterations

All tests were run on a desktop computer with an Intel i9 13900KS with 32GB of memory and NVIDIA RTX3090 GPU. The number of threads was limited to 8. The latest versions of all physics engines were used at the date of the tests. Specifically, we used MuJoCo 3.14.0 and PhysX 5.11.0.

High Mass Ratio

This scene tests the ability for the physics engine to solve contacts involving high mass ratios. A heavy 10,000kg box is created resting on a 1kg box.

We measure how much the boxes intersect each other, and how much the lower box intersects the floor.

Engine	Overlap Between Boxes	Floor Overlap
Anvil	0.123mm	0.123mm
MuJoCo (Newton)	0.153mm	0.153mm
SDS	0.123mm	0.123mm
PhysX (PGS)	Failed	Failed

PGS fails the test as expected. Iterative impulse solvers like PGS are not able to converge such systems within practical iteration counts for a 10ms fixed timestep. Both Anvil and SDS match the expected value of 0.123mm for the 1E-4 regularization, which was calculated analytically. MuJoCo behaves marginally worse, likely because its stopping criteria allow the solver to exit earlier.

Stiff Cable

We model a stiff cable using 20 links connected by spherical joints with damped springs. The cable is fixed at one end and should deflect downwards slightly due to gravity.

We measure how much the cable deflects from horizontal, comparing to the analytic solution.

Engine	Tip Deflection
Anvil	29.823mm
MuJoCo (Newton)	29.822mm
SDS	29.823mm
PhysX (PGS)	Failed

Anvil and SDS match the expected value of 29.823mm. Again, MuJoCo is marginally worse, likely due to its convergence criteria. PGS fails since the stiff springs cause the system of constraint equations to be poorly conditioned, resulting in slow convergence.

Fixed Joints

A rectangular rigid bar is formed of 20 individual cubes connected by fixed joints. The bar is fixed at one end. Each cube has mass equal to double the previous cube, where the lightest cube is fixed kinematically to the world. The first cube has a mass of 0.1kg and the final cube has a mass of over 52,000kg.

We measure how much the bar deflects from horizontal, comparing to the analytic solution.

Engine	Tip Deflection
Anvil	1.356mm
MuJoCo (Newton)	Failed
SDS	1.376mm
PhysX (PGS)	Failed

Anvil matches the expected value of 1.356mm. SDS is marginally worse, whilst MuJoCo quickly diverges and PGS fails to converge.

Inclined Ramps

To validate static and dynamic friction, we create a series of differently inclined ramps with boxes resting on them.

We measure the velocity of the boxes and compare to the analytically calculated solution.

Engine	RMS Velocity Error
Anvil	0.034mm/s
MuJoCo (Newton)	231.639mm/s
SDS	7.143mm/s
PhysX (PGS)	0.006mm/s

PGS behaves best in this test because it uses hard contact constraints, which it can solve quickly. Anvil also comes very close to the analytic solution. SDS behaves significantly worse for reasons unknown. MuJoCo effectively fails the test. This is due to MuJoCo’s contact formulation, which couples sliding to motion in the normal direction. As a result, the boxes jump upwards as they slide down the ramp.

Gripping with Friction

We model a simple mechanical gripper using two prismatic joints with positional drives. A line of 4 boxes is gripped by fingers pushing inwards with a force of 150N at each end.

The distance and speed at which the boxes slip relative to the mechanical gripper are measured.

Engine	Maximum Slip	Final Slip Speed
Anvil	0.008mm	0.00073mm/s
MuJoCo (Newton)	Failed	Failed
SDS	0.050mm	0.01962mm/s
PhysX (PGS)	0.315mm	0.03662mm/s

Anvil behaves markedly better than the other engines, with just 8µm of slip over the 4.5s simulation. SDS slips over 6X more than Anvil, whilst PGS slips around 40X more. MuJoCo fails the test, likely due to its contact/friction formulation. Both SDS and MuJoCo also result in noticeable intersections as the gripper closes. This is because both engines lack Continuous Collision Detection (CCD), whilst this is supported by both Anvil and PhysX (PGS).

Pallets on Conveyors

Europallets are simulated travelling at 0.2m/s along straight belt conveyors. Each pallet consists of 5 layers of 4x3 boxes, where each box weighs 1kg and each layer is separated by a 1mm thick slipsheet with a mass of 100g.

We measure the performance over the duration of the 50s simulation.

Anvil significantly outperforms all other engines, including PGS. It’s worth noting that PGS fails to prevent the boxes from penetrating completely through the slipsheets due to the relatively high mass ratios. All other engines resolve the overlap to a few microns.

Engine	Mean	Maximum	P99
Anvil	0.95ms	2.90ms	1.65ms
MuJoCo (Newton)	5.23ms	189.74ms	28.40ms
SDS	13.61ms	1,604.62ms	239.41ms
PhysX (PGS)	3.19ms	4.43ms	3.90ms

Anvil performs over 14X faster than the commercial sparse direct solver on average during this test. However, this gap widens to over 550X for the peak frame time, with SDS taking over 1.6 seconds for the maximum frame. Anvil is also over 65X faster than MuJoCo when comparing the maximum frame times. This is despite Anvil behaving favorably when compared to MuJoCo, due to its friction formulation.

Totes on Conveyors

We simulate 2000 thin-walled totes on conveyors. The totes weigh just 200g and contain 4 small boxes weighing 10kg each. The wall thickness of each tote is just 4mm. In total, the scene consists of 10,000 dynamic rigid bodies.

We measure the performance over the 20s simulation.

Anvil once again significantly outperforms all other engines. Just like the pallet conveyor, PGS fails to prevent the boxes from sinking through the bottom of the tote, whilst all other engines resolve the overlap to a few microns.

Engine	Mean	Maximum	P99
Anvil	3.896ms	9.173ms	4.922ms
MuJoCo (Newton)	28.620ms	51.722ms	37.527ms
SDS	30.992ms	68.759ms	42.961ms
PhysX (PGS)	22.050ms	33.047ms	28.061ms

Anvil outperforms MuJoCo by over 7X. No other engine can meet the 10ms frame budget, whilst Anvil averages less than 4ms per frame. The commercial sparse direct solver is comparable in performance to MuJoCo in this scene, since each constraint island is quite small.

Dense Box Grid

This benchmark simulates dense grids of boxes. Each box has a uniform mass of 1kg. We test the ability of the solvers to handle up to tens of thousands of interdependent contact points. Unlike the tote conveyor test, each island can consist of tens of thousands of constraint rows.

We measure the mean step time for each engine for 125, 500 and 1000 box piles.

This is exactly the kind of scene where PGS should excel. The stack height is reasonably small and there are no large mass ratios. However, with a grid of just 125 boxes, Anvil actually outperforms PGS. At 500 boxes, Anvil and PGS perform identically. However, at 1000 boxes PGS pulls ahead of Anvil, although the boxes move around much more in PGS than in Anvil.

The algorithmic time complexity of the SDS solver blows up here, making the engine practically unusable for scenes with medium to large islands. At just 125 boxes, SDS took over 15 seconds per frame, quickly hitting the timeout duration for the test. At 500 boxes, SDS was not able to complete a single frame within an extended 2 hour timeout.

MuJoCo performed significantly worse than Anvil, taking over 22ms per frame for the 125 box scene, over 2 seconds for the 500 box scene and over 7 seconds for the 1,000 box scene. However, the behavior was comparable to both Anvil and the SDS engines.

House of Cards

This test is an adaptation of the card house test from a recent paper, A Splitting Architecture for Exact Reduced Coulomb Friction. We scaled the playing cards such that they are accurately dimensioned and weighted, with a thickness of just 0.3mm and a mass of 1.8g each. This test is particularly difficult, because it requires simulating small paper-thin objects with accurate friction, where even very small errors will cause the structure to collapse.

We measure the average speed at which the cards drift over time after settling.

Engine	Mean Drift Speed
Anvil	0.0025mm/s
MuJoCo (Newton)	0.0450mm/s
SDS	Failed
PhysX (PGS)	1.1749mm/s

Surprisingly, PGS keeps the house of cards stable, at least for several seconds. It later collapses due to the high drift speed. The cards immediately collapse with the SDS solver, although this is likely due to the absence of Continuous Collision Detection (CCD). Reducing the timestep to 1ms does allow the structure to remain stable. MuJoCo performs reasonably well in this test, although it has a drift speed of approximately 18X higher than Anvil.

Masonry Arch

Another adaptation from the above-mentioned paper, with the size scaled down by a factor of 100. Each block uses a single convex collider. The blocks are initialized with a small spacing between them, and they subsequently fall into place.

Only Anvil and PGS keep the arch standing, although the arch noticeably sways and drifts when using PGS. It’s not clear why MuJoCo fails this test, although it may be due to either the absence of CCD or its convex-convex contact generation. SDS also fails, likely for similar reasons.

Engine	Mean Drift Speed
Anvil	0.0010mm/s
MuJoCo (Newton)	Failed
SDS	Failed
PhysX (PGS)	0.8792mm/s

Differential Conveyor

Two conveyors are positioned side-by-side, with a case that straddles both conveyors equally. The surface speeds of the conveyors are set differently, which should cause the case to rotate as it travels along the conveyors.

The observed rotation speed is compared to the analytic result.

Engine	RMS Angular Speed Error	Mean Sideways Drift Speed
Anvil	0.218°/s	0.274mm/s
MuJoCo (Newton)	8.626°/s	20.521mm/s
SDS	Failed	Failed
PhysX (PGS)	Failed	Failed

Both PGS and SDS failed this test, with the case apparently transferring its weight onto only one of the conveyors. This is understandable for the PGS solver, since it models contacts using hard constraints. It’s unclear why SDS fails in this case. The case does rotate when using MuJoCo, but there is a high error in the angular speed and the case quickly drifts sideways. Anvil is the only engine that can simulate this scene to high accuracy.

Paper Stack

100 A4 paper sheets are dropped one at a time every 250ms from a height of 10cm. The sheets are accurately dimensioned, with a thickness of just 100 microns and a mass of 5g.

We compare the number of out of order sheets, the maximum sheet overlap, the maximum sheet tilt angle and the mean step time.

Engine	Order Violations	Maximum Overlap	Maximum Sheet Tilt	Mean Step Time
Anvil	0	12.02µm	0.000°	0.507ms
MuJoCo (Newton)	30	99.48µm	0.025°	21.649ms
SDS	43	100.00µm	0.943°	63.573ms
PhysX (PGS)	33	100.00µm	0.094°	4.870 ms

Anvil is the only engine that has no sheet order violations. PGS fails due to slow convergence for large stacks. MuJoCo likely fails due to its lack of support for CCD. SDS hits a timeout after around 80 sheets, although many sheets were still incorrectly ordered and there was significant overlap observed. Anvil is significantly faster than all other engines, beating MuJoCo by approximately 43X.

Two Axis Arm

This test simulates a simple 2-axis robotic arm, where each revolute joint is powered using direct drives. The drive for the first arm is set to rotate at 2rad/s using velocity control whilst the drive for the second arm is set to hold its relative angle of 60° using positional control.

The PD drives are configured with the following stiffness and damping parameters:

Joint	Stiffness (Kp)	Damping (Kd)
1	0N·m/rad	56.8N·m·s/rad
2	1,000,000N·m/rad	923.76N·m·s/rad

The torque is measured and compared to the analytic result. The separation of the anchor point of the first axis is also measured.

Engine	J1 Torque Error	J2 Torque Error	Maximum Anchor Separation
Anvil	0.01%	0.01%	156.52µm
MuJoCo (Newton)	Failed	Failed	Failed
SDS	0.00%	0.12%	703.54µm
PhysX (PGS)	3.19%	1.01%	157.08µm

MuJoCo becomes unstable in this test at high drive stiffness. This is likely because its default Euler integrator calculates torque from the joint’s angle at the start of each step, whereas the other engines’ joint drives account for how that torque changes as the joint moves during the step. All other engines are reasonably accurate, although the commercial sparse direct solver results in a high anchor separation, which could be problematic when simulating robots that require high precision and accuracy.

We subsequently repeated the test with the second joint set to use a damping coefficient (Kd) of 0.

Engine	J1 Torque Error	J2 Torque Error	J2 RMS Torque Error	Maximum Anchor Separation
Anvil	0.01%	0.01%	0.08%	156.56µm
MuJoCo	Failed	Failed	Failed	Failed
SDS	0.24%	0.67%	55.76%	704.62µm
PGS	3.19%	1.01%	1.01%	157.05µm

SDS developed sustained oscillations, resulting in a very high RMS error for J2’s torque. Anvil remained extremely stable and accurate.

Summary

Anvil sets a new standard for real-time physics simulation, delivering engineering-grade accuracy, exceptional stability and uncompromising performance. Across a comprehensive range of demanding benchmarks, Anvil not only outperforms traditional iterative solvers but also surpasses expensive commercial direct solvers in accuracy, robustness and computational efficiency.

By eliminating the traditional trade-off between physics fidelity and simulation speed, Anvil makes it possible to simulate complex industrial machines and systems with confidence. From precision robotics and friction-based gripping to densely packed conveyors and thousands of interacting bodies, Anvil delivers reliable, physically accurate results at real-time speeds, even in scenarios where competing physics engines fail completely.

For engineers, this means fewer approximations, fewer workarounds and more trustworthy dynamic digital twins. No artificially adjusted masses, oversimplified collision geometry or complex tricks to maintain stability. Just accurate physics that allows engineers to focus on designing, testing and validating real systems rather than fighting the physics engine.

No other industrial digital twin software offers this combination of physics accuracy, stability and real-time performance. Powered by Anvil, ProtoTwin is uniquely positioned to deliver engineering-grade digital twins without compromise.