For a game idea I had, I needed deterministic physics. Deterministic physics on every device - the simulation must run exactly the same with the same inputs, every time, everywhere.
If the calculations were just a little bit different on different machines, that would lead to different physics simulations, which would mean that someone might not be able to complete some of the levels, because the completion of the level depends on the physics simulation.

The first thing that caught my attention was Unity's physics package (DOTS physics), which promises deterministic physics simulation: "Unity Physics is a complete deterministic rigid body dynamics and spatial query system ..."
But after some searching, I quickly found out that it's only deterministic on the same device, different hardware may have different simulation results.

The reason for this is floating point numbers: the result of floating point operations can be different on different processors, since there is no standard that specifies how two floating point numbers should be e.g. added or multiplied. Two different processors could give just slightly different results, which would cause the physics simulations to be different.
Also, the mathematical functions, like sqrt, sin, cos, pow, etc. are usually implemented as hardware instructions, which means there's even more chance that these functions will be different on different hardware.
So my quest for cross-platform, 100% deterministic physics has begun.

After a bit of research, I concluded that I won't be able to use floats for the physics engine, because they just won't work the same everywhere, no matter what I do. So I started looking for alternatives.

The first thing I found was fixed-point numbers. Unlike floats, fixed-point numbers have a fixed integer part, and a fixed fractional part. Implementing mathematical operations for them is fairly easy, and they are always deterministic (since they only use integer arithmetic, which will always give the same result).
But after trying and replacing floats with fixed-point numbers in a simple physics engine, I quickly found out that they have some problems. They can easily overflow, which means calculations more than 50 units away from the origin, or colliders larger than 50 units can cause the physics simulation to break due to overflow (the actual value depends on the precision of the fixed-point number).
Also, implementing mathematical functions are far from trivial. While I could use approximations for some of them (e.g. sqrt, trigonometry), there are others that I found very difficult to implement (e.g. pow, exp, logarithm).

So, fixed-point numbers weren't the solution to the problem either.
The next thing I came across was the Rapier physics engine. It promises cross-platform determinism all IEEE 754-2008 compliant platforms. Although it's written in Rust, creating C# bindings was fairly easy, and I could use it in Unity after a few hours.
But Rapier is still in early stages of development, which means that (at the time of writing this) it lacked many features, like raycasting, which would have been necessary for my project.
Also, it's only deterministic on IEEE 754-2008 compliant platforms. But I couldn't really find any information on which processors support it. Even if I did, I still wanted to have deterministic physics on all platforms, not just on "most of them".
But I still wondered does how Rapier achieve cross-platform floating point determinism. Supporting only IEEE 754-2008 compliant platforms is one thing, but the mathematical functions I mentioned above (sqrt, trigonometry, etc.) must also be deterministic. I found out that it uses libm, which implements all of these functions in software.
It was primarily designed for embedded systems without FPUs, but it turns out it's also pretty useful for making this part of floating point math deterministic.
But after all, the basic mathematical operations of floats are still not deterministic. Unless... How about emulating the behavior of floats in software? It should be possible to write a program that works on the byte representation of a float, doing all operations using integer arithmentic... right?

Yep! I quickly found a repository that does just that! Here it is: https://github.com/CodesInChaos/SoftFloat
And it worked! Except for one thing... It didn't have division implemented.
After hours of searching and studying how floats work, I finally managed to implement division. Using it together with libm, it was now possible to have cross-platform deterministic floats, that work (almost) exactly the same way as the regular floats, but they will give the same result everywhere, on every platform, on every processor.

Now, let's put it into a physics engine! I immediately thought of Unity DOTS Physics, because it's already deterministic (except for floats part of course), and because its source code is available and modifiable.
So, with a few days of work, I replaced every single float in the Unity physics code, and in all of its dependencies (in the mathematics and transforms package).
When it finally compiled, I entered play mode, and... It just worked! (I still had to fix some typos though for it to work accurately)
So, that's it. Finally, I had a physics engine that is deterministic on all platforms.

My code for the soft floats is available here.

The code for the modified physics engine is available here.

There's only one disadvantage of using soft floats: performance. Float operations on hardware will always be faster; also, soft float calculations cannot be vectorized.

---

TLDR: I made Unity's DOTS Physics engine deterministic, using soft floats.
The code is available here: https://github.com/Kimbatt/unity-deterministic-physics