Fun With Science

Inside the Flat Earth app: what the code does

Published 18 November 2026. Based on the free Android version, build 250004, installed from Google Play the same day.

float sinAlt = sinLat * sinDec
    + cosLat * cosDec * cosHA;
This line of spherical trigonometry appears twice in the app, character for character (shown here on two lines). In the sky view it places every star. On the flat map it decides where day ends and night begins.

The short version

The Flat Earth app contains no flat-Earth model. Every view in it is calculated with standard globe astronomy, and the flat map is one of several ways the app can draw the same globe data.

We installed the free Android version and read how it works. Three things stand out:

What the app shows you

The app has two views, and you switch between them with one button.

ViewWhat you seeWhat it suggests
Map viewA flat, circular map with the North Pole at the centre. The Sun, Moon and stars sit over it and circle the pole.The Sun and stars move in circles above a flat Earth.
Sky viewThe sky from a place you choose, at a time you choose, with a horizon and a landscape.You have flown in and are now looking up from the map.

The question we asked: is the sky view what you would see from inside the map view? It is not. They are two separate programs that share a clock and your location.

What is inside

Four parts of the app do the work, and all four use a round Earth.

Each excerpt below is marked by where it runs: sky view, map view, or shared by both.

1. The stars in the sky view. For each star the app takes its catalogue position, your latitude and the time, and works out how high it is and in which direction. This is the textbook conversion used by every planetarium. Nothing from the flat map goes into it: no map position, no height above a plane, no distance across the map.

float ha = lst - mra;
...
float sinAlt = sinLat * sinDec + cosLat * cosDec * cosHA;
...
float az = atan(-cosDec * sinHA, (sinDec - sinLat * sinAlt) / cosLat);
AzimAlt=raDecl_to_AltAz(mra,mdec,LatLonPresTemp.x,LST).yx;

Sky view. From Shader/StarMesh3D.gdshader. mra and mdec are the star's catalogue position, LatLonPresTemp.x is your latitude and LST is local star time. Those four values are everything the star's position depends on.

2. Day and night on the flat map. For every point on the map, the app works out how high the Sun is at that latitude and longitude on a sphere. Above the horizon is drawn as day, below as night. The lit shape on the map is a globe's day side, drawn flat.

//x: Greenwich Hour Angle, y: sun decl
uniform vec2 sun_data;

float GetAlt(vec2 LonLat) {
    float HA = sun_data.x + LonLat.x;
    ...
    float sinAlt = sinLat * sinDec + cosLat * cosDec * cosHA;
    return asind(sinAlt);
}

Map view. From Shader/include/sun.gdshaderinc. This runs for every point on the map. The script that feeds it passes the Sun as two angles and nothing else:

var GHA = (TimeEngine.GST - Astronomy.Sun.ApparentGeocentricRA) * 15.0
fe_mesh_mat.set_shader_parameter("sun_data", Vector2(GHA, Astronomy.Sun.ApparentGeocentricDeclination))

Map view. From Script/MapView.gd (recovered script). The map's Sun has a direction but no height and no distance. The icon on the map marks where that direction is straight overhead.

3. The map itself. The Earth picture is an ordinary latitude and longitude image. The app pushes it through a projection, the same kind of maths an atlas uses to flatten a globe onto a page. The flat circular map is one setting. The app's own list of projections also includes “orthographic”, which is the Earth drawn as a ball.

vec2 UV_to_spherical(vec2 uv) {
    ...
    float lon = x * PI;        // Longitude from -PI to PI
    float lat = y * PI*0.5;  // Latitude from -PI/2 to PI/2
    return vec2(lon, lat);
}

Map view. From Shader/include/commons.gdshaderinc: every point of the map picture is first turned back into longitude and latitude. The projection names stored in Script/data/ProjData.gd are: Azimuthal Equidistant, Equirectangular, Extrapolated Equidistant, Extrapolated Equidistant2, Azimuthal EqualArea, orthographic, Cassini.

4. Eclipses. To shade an eclipse on the map, the code uses three numbers:

Number in the codeWhat it is
6378.14 kmThe Earth's radius at the equator
0.99664719How much shorter the Earth is pole to pole than across the equator
About 150 million kmThe distance to the Sun
const highp float FLATTENING    = 0.99664719;
const highp float EARTH_RADIUS_M  = 6378140.0; // meters — for the Height ratio
const highp float EARTH_RADIUS_KM = 6378.14;   // km — for the parallax (sin pi) term
const highp float AU2KM = 1.496e+8;

Map view. From Shader/Projection.gdshader, the shader that draws the flat map. The comments are the developer's.

The star catalogue it ships (83,500 stars) is the standard HYG catalogue, which lists each star's distance. The scripts ask the planet engine for Sun-centred positions and convert between kilometres and astronomical units.

const AU2KM: float = 149597870.691

var HeliocentricRectangularEcliptical: Vector3:
    get: return _pe[&"TrueHeliocentricRectangularEcliptical"]

Shared. From Script/Astronomy/Astronomy.gd and Script/Astronomy/SSBody.gd (recovered scripts).

Why the stars turn the other way in the south

The app never sets a direction of rotation. There is no “clockwise” or “counter-clockwise” in it, and no rule for the southern hemisphere. The direction falls out of the geometry, and the two views use different geometry.

Shared by both views Star catalogue: where each star is Clock: how far the sky has turned Sky view only: your latitude Sets how the axis of the sky is tilted against your horizon Map view Each star drawn over the place where it is overhead. One centre, one direction for everyone Sky view Each star drawn at its height and direction from where you stand. Centre and direction depend on latitude
Both views read the same star catalogue and the same clock. The sky view takes one more input, your latitude, and that single input is what reverses the turning in the south.

On the map, each star is drawn over the spot on Earth where it is directly overhead. As the clock runs, every star's spot slides west by the same amount. On the flat circular map that looks like one disc of stars turning around the North Pole. One centre, one direction, the same for everybody.

ra_n=repeat(ra_n+GST-12.0,24.0);
...
VERTEX = VERTEX * (quad_scale * local_quad_scale) + fe_mesh_project(uv,transition);

Map view. From Shader/StarMesh2D.gdshader. GST is Greenwich star time. It is added to every star's position alike, then the star is placed with fe_mesh_project, the same function that places the land. Latitude does not appear.

In the sky view, the app adds one thing the map never uses: your latitude. Latitude sets how the sky's turning axis is tilted against your horizon.

GST = Astronify.GreenwitchSiderealtime(JD_TT, true)
...
RenderingServer.global_shader_parameter_set("LST", Astronomy.astro.LocalSiderealTime(TimeEngine.GST, User.Location.LONGITUDE))

Shared. From Script/TimeEngine.gd (recovered script): the clock both views share. The sky view then combines it with latitude in the formula shown earlier, and the Milky Way background does the same:

vec3 eq_dir = eyedir_to_equatorial(eyedir, LatLonPresTemp.x, -LST);

Sky view. From Shader/sky.gdshader. A search of every script and shader for “hemisphere”, “clockwise” or a test on the sign of latitude finds nothing that sets a direction.

So the southern rotation is not programmed in. It is what a round-Earth formula gives when the latitude is negative.

This is the part a flat Earth cannot supply. Latitude can only tilt the sky's axis if “up” points in a different direction at each latitude. On a flat surface everyone's “up” is parallel. A flat Earth could put the centre of rotation farther away, but could not tilt it, and could never bring a second centre into view in the south.

The fly-in is a zoom and a cut

Pressing the sky button looks like flying down into the map. In the code it is three steps:

  1. The flat map zooms toward your location.
  2. While that plays, a separate 3D sky scene loads in the background.
  3. When the zoom ends, the map is hidden and the sky scene is shown.
var gpos = MapProjection.instance.Project(uv)
...
var tn: = MainCam2D.instance.move_to_object(gpos, 30.0, cd)
Utility.load_scene_SkyView()
if tn != null and tn.is_valid() and tn.is_running():
    await tn.finished
    MapView.instance.visible = false
    Ui.sky_view_ui_enable(true)

Shared. From Script/bottom_bar.gd (recovered script), the handler for the sky button: zoom the 2D camera, load the sky scene, wait for the zoom, hide the map.

The two scenes have different cameras. Only the clock and your latitude and longitude pass from one to the other. Nothing on the map, including the Sun and star positions drawn over it, is carried into the sky.

What the flat map cannot reproduce

If the flat map were a real place, with the Sun and stars a few thousand kilometres above it, the sky would look different from what the app's own sky view shows. These figures compare standard globe astronomy with the app's map taken literally.

TestGlobe astronomyThe app's map, taken literally
Sunrise in Sydney, 21 December29° south of east, on the horizon56° north of east, 8–16° above the horizon
Centre of the night sky's rotation, from SydneyDue south, 34° upDue north, 12–24° up
Direction to the south pole star, Sydney vs Cape Town, same momentBoth look due south (1.6° apart)They look 175° apart
Lowest the Sun gets in a dayFar below the horizonNever lower than 6° up, anywhere
Sun's size at Sydney sunrise compared with noon, 21 DecemberThe sameLess than a quarter
McMurdo (Antarctica) and Tokyo at McMurdo's midnight in DecemberMcMurdo in sunlight, Tokyo in nightMcMurdo is 31,300 km from the Sun's marker and Tokyo 18,200 km, so the nearer place is the dark one
The left column is checked against an independent astronomy library to within 0.007 degrees. The right column depends on how high you place the Sun, so it is shown as a range for 3,000 to 6,000 km. Neither column has been measured in the app yet. The code says the sky view will match the left column; screen recordings to confirm it are in progress and will be added here.

What this does and does not show

It shows that the app has no flat model inside it. Every view is globe astronomy. The flat look comes from the choice of map projection.

It does not show that the developer is hiding this. The evidence points the other way:

The criticism that holds is narrower. The app is named Flat Earth and sold to a flat-Earth audience, and reviews on the App Store show users taking it as confirmation. Nothing in the listings tells them that the sky view cannot come from the map.

It does not, by itself, prove the shape of the Earth. A flat-Earth reply is that the formulas are only patterns fitted to what we observe. The answer to that is the table above: no single flat layout reproduces what the sky view shows, which is why the app has to use the globe formulas to get the sky right.

How sure we are

FindingConfidenceWhy
Sky view stars, day and night shading, map projection, eclipse numbersHighRead directly from the app's drawing code, which is plain text in the package
Rotation direction and the fly-in sequenceHigh, with one caveatRead from the app's scripts, recovered with our own decoder and not yet cross-checked with the standard tool (GDRE Tools)
The engine that computes Sun, Moon and planet positionsMediumThe scripts show what the app asks it to compute and how the answers are used. The engine itself is compiled, so its internal formulas were not read
The paid Pro version and the iPhone versionNot examinedThey may be older or different code

Excerpts labelled “Shader” are copied from plain-text files in the app package. Excerpts labelled “recovered script” come from our decoder: names and values are as stored in the app, but spacing may differ from the developer's original. ... marks lines left out. Only short excerpts are shown, for the purpose of comment; the app's files are not redistributed here.

The app was installed from Google Play in the normal way. If you are the developer, or you find an error on this page, corrections are welcome.