Simulating Orbital Mechanics in Unity for AR Apps

Orbital mechanics can be simulated in the Unity game engine by replacing its built-in single-planet gravity with a custom force calculation applied to each Rigidbody every update, then scaling both the visual model and its physics mass together so the simulation still behaves correctly when resized for Augmented Reality (AR) viewing.

Key Takeaways

• Unity’s default gravity system applies a constant downward acceleration and cannot handle multi-body orbital physics without custom code.
• A custom force script uses the formula force = GFactor * (SunMass * SatelliteMass / distance²) * directionForce, applied via Rigidbody.AddForce().
• When resizing objects for AR, Rigidbody mass must scale by the cube of the scale factor, not linearly with the visual size.
• The author has worked as a game developer for over 30 years and used this orbital mechanics technique in an AR game prototype.
• Unity’s “Gravity and Orbits — Solar System” package is a usable starting point for building an animated solar system.
• Initial velocity and position offsets need their own scaling step; scaling only the direction vector will distort the resulting force magnitude.

Why does orbital mechanics matter for AR applications?

In a standard, non-AR application, a developer can fix the scale of a scene and move the camera to frame it correctly. AR removes that option because the user’s own movement acts as the camera. A virtual object placed in a large room can look too small from the user’s starting position, while the same object in a tight space can appear oversized and spill past the edges of the display. Because the user physically walks closer or farther away, both the visual scale and the underlying physics have to adjust in real time rather than being set once at the start.

I recently built an AR game prototype that used orbital mechanics as its core gameplay mechanic, and solving this scale problem was the main technical challenge.

How do you simulate multi-body gravity in Unity?

Unity’s built-in gravity module is designed for a single gravitational source, such as a character falling toward the ground, not for multiple orbiting bodies pulling on each other. To simulate that, each object’s force has to be calculated manually and handed to Unity’s physics engine every frame. The approach used in this prototype follows three steps:

1. Calculate a direction vector and force magnitude for each planet or satellite: directionForce = (SunPosition − PlanetPosition) / distance, and forceValue = (SunMass × SatelliteMass) / distance².
2. Combine these into a single force: force = GFactor × forceValue × directionForce.
3. Apply that force to the object’s Rigidbody component using Rigidbody.AddForce(), then let Unity’s physics engine handle the resulting movement and position updates.

// Example C# sketch: apply computed force to a Rigidbody
void ApplyGravitationalForce(Rigidbody rb, Vector3 force)
{
    if (rb != null)
        rb.AddForce(force);
}

Unity’s “Gravity and Orbits — Solar System” package can serve as a starting point for an animated solar system built around this same force-calculation loop.

How do you scale a solar system simulation for AR?

Scaling only the visual size of each planet is not enough for AR, because distance, mass, and initial velocity all have to scale together or the orbits will break. Relying on a single parent “universe scaler” GameObject only changes transform inheritance; it does not touch the physics values driving the simulation. Instead, each planet GameObject needs its own scaling script that adjusts both its visual transform and its Rigidbody mass.

Physics mass scaling formula

Rigidbody mass must scale by the cube of the scale factor, since mass is a volumetric property: newMass = originalMass × scaleFactor³.

// scale the model's transform (appearance) and its mass
void UpdateScale(float scaleFactor)
{
    transform.localScale = originalScale * scaleFactor;

    // scale the mass using the original mass stored at initialization
    Rigidbody rb = this.GetComponent<Rigidbody>();
    if (rb != null)
    {
        // Use stored originalMass (must be saved when object initialized)
        rb.mass = originalMass * Mathf.Pow(scaleFactor, 3);
    }
}

Initial speed and position offsets need the same treatment, applied separately from mass:

satellite.GetComponent<InitialSpeed>().speed = InitialSpeedConstant * scaleFactor;
Vector3 position = centerPlanet.transform.position + positionOffset * scaleFactor;

If you are building on the Gravity and Orbits Solar System package, avoid scaling the initial direction vector on its own. Doing so scales the initial force magnitude incorrectly, since direction and force magnitude need to stay proportionally linked.

There are multiple valid ways to implement runtime scaling in Unity; the transform-plus-mass approach described above worked well for this AR prototype.

Is Unity a good tool for physics simulation projects?

Unity is well suited to prototyping and animating physics models because it lets a developer watch interactions unfold over time and see formulas play out visually rather than as static numbers. Adding an animated orbital simulation to a Unity project, whether targeting PC, Mac, iOS, or Android, makes the underlying system easier to visualize and more engaging for players. Unity is free to start with and runs across a wide range of platforms, which makes it a practical choice for this kind of modeling work.

Frequently Asked Questions

What is the Unity Game Engine?

Unity is a cross-platform game engine developed by Unity Technologies. It is used to create games and interactive content for web, desktop, consoles, and mobile devices.

What platforms does Unity support?

Unity supports a wide range of platforms including Windows, macOS, iOS, Android, Xbox, PlayStation, and Nintendo Switch.

How much does Unity cost?

Unity is available in several tiers. The Personal (free) plan is available for individuals and small businesses that meet the revenue limits. Pro and other paid tiers require a subscription fee.

What programming languages does Unity use?

Unity primarily uses C#. Older Unity versions supported UnityScript, which resembled JavaScript, and Boo, but modern Unity development should be done in C#.

What types of games can I create with Unity?

Unity can create many types of 2D and 3D games, including role-playing games (RPGs), first-person shooters (FPSs), platformers, and more.

Why can’t I just use Unity’s built-in gravity for a solar system simulation?

Unity’s built-in gravity applies a single constant downward force meant for scenarios like a character falling to the ground. Orbital mechanics requires multiple bodies exerting force on each other based on mass and distance, which means the forces must be calculated manually in code and applied to each Rigidbody rather than relying on Unity’s default gravity setting.

Why does mass need to scale by the cube of the scale factor rather than linearly?

Mass corresponds to volume, and volume scales with the cube of a linear dimension. If an object’s visual size doubles in each direction, its volume, and therefore its mass, increases eightfold. Scaling mass linearly instead of by the cube would make the physics simulation behave inconsistently after resizing.