Seeking Double Precision (64-bit) Alternatives for High-Coordinate Large Worlds in Unity

Unity Engine
1

We are encountering the classic issue of 32-bit floating point precision loss in our continuous Runner/Endless Drive project. The resulting micro-jitter becomes noticeable when the player reaches approximately 10,000 units of distance from the world origin.

To address the fundamental cause of the problem—the 32-bit float coordinate representation—we are exclusively looking for technical solutions that enable high-precision physics and camera tracking at high coordinate magnitudes, without relying on the Floating Origin methodology.

The core technology we seek is Double Precision (64-bit double). We are asking the community for practical insights regarding its implementation within the Unity ecosystem:

  1. Unity DOTS / Unity Physics: Is migrating our Rigidbody simulation to Unity Physics (part of the DOTS stack) the most robust, if not the only, native path to utilize 64-bit position precision for physics calculations within Unity’s engine?
  2. Engine Modifications (Non-DOTS): Are there any experimental or advanced settings within the standard engine (e.g., PhysX or the Transform system) that can be configured to use 64-bit double precision for position/translation of key objects (like the player) to mitigate precision loss at runtime?
  3. Specialized Assets: Has the community found or developed any stable Asset Store solutions that inject double precision functionality into the standard Transform system and remain compatible with the traditional GameObject and Rigidbody workflow?

We also note that our custom camera script operates in LateUpdate but uses Time.fixedDeltaTime in its Vector3.Lerp for damping. We are investigating if this specific synchronization conflict contributes to amplifying the visible jitter, but our primary focus remains on 64-bit solutions.

We appreciate any experience or direction regarding truly scalable high-precision world management.

2

This topic comes up regularly. Here are the direct answers to your questions:

  1. No, Unity does not natively support 64-bit precision for physics.
  2. No.
  3. Not to my knowledge. You may hear about experimental or in development projects claiming they will support it eventually, but see below.

Here is the general explanation I give about double-precision calculations in game engines:

Using a double-precision floating-point coordinate system for large worlds is not a viable approach for any serious game project, in Unity or elsewhere. Rendering requires these calculations to run on the GPU, the real problem is vertex processing and GPU-side math, which cannot feasibly run in doubles so double-precision operations on GPUs are extremely slow.

The problem is not bandwidth, it’s raw computation speed. Even in a single-player game, double-precision math for rendering is a major bottleneck. These operations can be 30–60 times slower (or even worse) than single-precision. Engines that truly support double-precision rendering are suited for non performance critical applications. For a game, relying on double precision would effectively drop your rendering performance to what you’d expect from a GPU over a decade old.

I’ve seen articles describing attempts such as one for Godot, to store coordinates using two 32-bit floats instead of a single 64-bit double. This can achieve higher precision, but I’m not sure about the performance characteristics compared to standard single-precision.

Unreal has experimented with similar approaches. But these methods emulate higher precision, they do not provide actual 64-bit GPU operations.

For hardware reference, check the official performance data:

NVIDIA: List of Nvidia graphics processing units here: List of Nvidia graphics processing units - Wikipedia
AMD: List of AMD graphics processing units, here: List of AMD graphics processing units - Wikipedia

Compare the single-precision and double-precision GFLOPS. GPU vendors intentionally optimize for single precision, and the gap is massive.

You may encounter claims, usually from less tech savvy people unfamiliar with GPU architecture, register width, and low-level compute pipelines that 64-bit operations can be done with minimal performance loss, or that a project already supports this. Treat such claims with skepticism and insist on concrete, testable evidence. Measure performance and floating-point precision yourself before investing in something that may exist only as an idea, a misconception, a hallucination, or a non-functional prototype.

In short: true double-precision world coordinates in Unity are not feasible today. Any solution claiming otherwise without major performance penalties is wishful thinking. Approaches that emulate higher precision using paired floats may be theoretically possible but require deep expertise to implement correctly. If you find a third-party solution, test it thoroughly before committing to it.

Instead of chasing 64-bit precision, focus on exploring practical alternatives.

3 Likes
3

As Meredoth stated, genuine double precision on the GPU isn’t feasible. But there are plenty of viable approaches which emulate increased precision.

Unreal engine has one such approach. You may learn more about it here: https://dev.epicgames.com/documentation/en-us/unreal-engine/large-world-coordinates-in-unreal-engine-5

1 Like
4

Thank you mate, I had an insight after reading your explanation! I appreciate it. See ya!

1 Like