float sinAlt = sinLat * sinDec
+ cosLat * cosDec * cosHA;
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:
The app has two views, and you switch between them with one button.
| View | What you see | What it suggests |
|---|---|---|
| Map view | A 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 view | The 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.
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 code | What it is |
|---|---|
| 6378.14 km | The Earth's radius at the equator |
| 0.99664719 | How much shorter the Earth is pole to pole than across the equator |
| About 150 million km | The 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).
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.
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.
Pressing the sky button looks like flying down into the map. In the code it is three steps:
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.
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.
| Test | Globe astronomy | The app's map, taken literally |
|---|---|---|
| Sunrise in Sydney, 21 December | 29° south of east, on the horizon | 56° north of east, 8–16° above the horizon |
| Centre of the night sky's rotation, from Sydney | Due south, 34° up | Due north, 12–24° up |
| Direction to the south pole star, Sydney vs Cape Town, same moment | Both look due south (1.6° apart) | They look 175° apart |
| Lowest the Sun gets in a day | Far below the horizon | Never lower than 6° up, anywhere |
| Sun's size at Sydney sunrise compared with noon, 21 December | The same | Less than a quarter |
| McMurdo (Antarctica) and Tokyo at McMurdo's midnight in December | McMurdo in sunlight, Tokyo in night | McMurdo is 31,300 km from the Sun's marker and Tokyo 18,200 km, so the nearer place is the dark one |
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.
| Finding | Confidence | Why |
|---|---|---|
| Sky view stars, day and night shading, map projection, eclipse numbers | High | Read directly from the app's drawing code, which is plain text in the package |
| Rotation direction and the fly-in sequence | High, with one caveat | Read 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 positions | Medium | The 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 version | Not examined | They 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.