---
title: "How Google Earth Shows the Whole Planet: The Engineering Behind Every Pixel"
url: https://nayansukhadiya.in/blog/how-google-earth-shows-the-whole-planet-the-engineering-behind-every-pixel
published: 2026-10-04T19:19:27.446+00:00
updated: 2026-10-06T17:18:47.072213+00:00
---

# How Google Earth Shows the Whole Planet: The Engineering Behind Every Pixel

> Satellites, aircraft, photogrammetry, a trillion-tile pyramid and a 16 ms render loop: an engineer's teardown of how Google Earth turns raw photos into a planet you can fly through.

Since childhood I have watched engineering shows. Every machine raised the same question: how does this actually work? When I saw a rocket, I wanted to know how it was built and what crucial engineering sat behind it. Software is not just a career for me; it is that same curiosity, pointed at systems. So when I spun the globe in Google Earth and flew down to a single rooftop, the question came back: how does a program show the whole planet, this close to real life, on an ordinary laptop?

This is my teardown. No marketing, just the engineering: where the pixels come from, how they become one seamless planet, and how your screen decides what to draw sixty times a second.

## The short answer

Google Earth is not a live camera. It is a giant, precomputed, multi-resolution mosaic of photos from satellites, aircraft and street-level cameras, corrected so every pixel sits at its true position, cut into a pyramid of tiles, and streamed to your device only where and only as sharp as you are looking.

> **The one idea behind it all** Your screen never needs the whole planet, only a few dozen tiles at the right sharpness. Everything else in this post is how Google makes those few tiles cheap to find and fast to deliver.

## 1. Where the pixels come from

![Where the pixels come from: satellites, aircraft and Street View, with altitude and resolution](https://mexaodmkighignihrsab.supabase.co/storage/v1/object/public/blog-images/posts/2026/10/02292bd0-7dc2-4542-a29d-53f5dec32a5c.webp#1600x900#1600x900)
*Where the pixels come from: satellites, aircraft and Street View, with altitude and resolution*

No single sensor can photograph the whole planet sharply. So Google Earth blends sources that trade coverage for detail. The lower the camera, the sharper the pixel and the smaller the area it can cover.

| ferf |  |  |  |
| --- | --- | --- | --- |
|  | erger | ergerger | g |
| ergerg | erg |  |  |
|  |  | ergergerg |  |
| ergerger | ergerg |  |  |
|  |  |  |  |

Look at the bottom of the Google Earth view and you will see the imagery credits change as you move. That is the mosaic showing its seams: different providers, different years, stitched into one surface.

## 2. Is it really "near 100% accurate"?

It feels exact, but an engineer should know where the edges are:

- **It is not live.** Each area is a snapshot. Imagery dates vary from place to place, from months to years old. Google Earth Pro has a historical imagery slider that shows exactly this.
- **Clouds are edited out.** The global layer is a mosaic that picks the clearest observation for each spot. That is why the planet looks permanently sunny.
- **Position accuracy is engineered, not free.** A raw satellite photo is tilted and warped by terrain. The pixels only land in the right place after orthorectification, which is the next section.

So the honest version: it is extremely accurate _as a map of where things are_, and only as current as the last capture of that area.

## 3. From photo to planet: the pipeline

![The imagery pipeline from capture to your screen](https://mexaodmkighignihrsab.supabase.co/storage/v1/object/public/blog-images/posts/2026/10/f587c166-fe3f-4251-a06c-c035cb82f5fc.webp#1600x900#1600x900)
*The imagery pipeline from capture to your screen*

1. **Capture.** Satellites and aircraft photograph the ground, each with a known orbit or flight path and camera model.
1. **Orthorectify.** Correct each photo for camera tilt and terrain height, so every pixel moves to its true map position. This needs an elevation model of the ground; a famous global one came from the Space Shuttle Radar Topography Mission (SRTM), flown in 2000, at about 30 m spacing.
1. **Colour-balance.** Photos taken on different days and by different sensors are matched so neighbouring tiles do not look like a patchwork.
1. **Mosaic.** For every location, keep the best pixel: sharpest, newest, cloud-free.
1. **Tile.** Cut the result into a pyramid of small square tiles (section 4).
1. **Distribute.** Push tiles to servers close to users so they load fast.
1. **Stream.** Your device downloads only the tiles it needs right now.

The scale is the real engineering story. For Timelapse in Google Earth, Google compiled **24 million satellite photos** from 37 years, **20 petabytes** of imagery, into a single **4.4-terapixel** video mosaic. It took **more than two million processing hours** across thousands of machines in Google Cloud.

## 4. The tile pyramid: how a planet fits in a browser

![The tile pyramid: each zoom level splits every tile into four](https://mexaodmkighignihrsab.supabase.co/storage/v1/object/public/blog-images/posts/2026/10/5fe54378-12b3-4eaa-a58f-bd87e453202a.webp#1600x900#1600x900)
*The tile pyramid: each zoom level splits every tile into four*

You can never download the whole planet at full resolution. The trick is a **quadtree**: at zoom 0 the entire world is one tile. Every zoom level splits each tile into four. A tile's address is just its path down the tree (0 to 3 at each level), which is why a tile key looks like "0231".

The numbers below use the standard Web Mercator scheme behind Google Maps (256 px tiles). Google Earth's 3D globe uses its own tiling, but the idea of a pyramid of ever-finer tiles is the same.

About **1.1 trillion tiles** at zoom 20, and your screen only ever needs a few dozen. That ratio is the whole design. Here is the maths a map client runs to find which tile covers a point:

```ts
// Web Mercator: which tile contains (lat, lon) at zoom z?
function tileFor(lat: number, lon: number, z: number) {
  const n = 2 ** z; // tiles per side
  const x = Math.floor(((lon + 180) / 360) * n);
  const latRad = (lat * Math.PI) / 180;
  const y = Math.floor(((1 - Math.log(Math.tan(latRad) + 1 / Math.cos(latRad)) / Math.PI) / 2) * n);
  return { x, y, z };
}

// How many metres one pixel covers at this latitude and zoom.
const metresPerPixel = (lat: number, z: number) =>
  (156543.03 * Math.cos((lat * Math.PI) / 180)) / 2 ** z;
```

## 5. From flat photos to 3D cities: photogrammetry

![Photogrammetry: several aerial views of one building become a 3D model](https://mexaodmkighignihrsab.supabase.co/storage/v1/object/public/blog-images/posts/2026/10/cd6f999e-003b-4503-837f-f1d59e0024a7.webp#1600x900#1600x900)
*Photogrammetry: several aerial views of one building become a 3D model*

The 3D buildings are not modelled by hand. Aircraft photograph each block from several angles. Software finds the same feature (a roof corner, a window) in different photos, and because the camera positions are known, it can triangulate how far away that feature is. Millions of those points become a point cloud, the point cloud becomes a mesh, and the mesh is painted with the original photos.

Google now offers this dataset to developers as **Photorealistic 3D Tiles**: over **2,500 cities in 49 countries**, published in the open **OGC 3D Tiles** standard created by Cesium. Choosing an open standard means any compatible renderer can stream Google's 3D world, not only Google's own apps.

## 6. The render loop: 16 milliseconds to decide

![The render loop that runs every frame](https://mexaodmkighignihrsab.supabase.co/storage/v1/object/public/blog-images/posts/2026/10/ba77b0d7-ea2b-44d8-8dbe-b12bdbcb2c56.webp#1600x900#1600x900)
*The render loop that runs every frame*

At 60 frames per second, the client has about 16 ms per frame. Every frame it:

1. Reads where the camera is.
1. **Culls** every tile outside the view.
1. Picks a **level of detail** per tile by screen-space error: a tile is refined only if its error would be visible in pixels.
1. **Fetches** missing tiles, showing the blurrier parent tile until the sharp one arrives. This is why the world sharpens as you zoom instead of going blank.
1. **Decodes and caches** tiles as GPU textures, evicting the least recently used ones.
1. Draws.

## 7. Running a C++ globe inside a browser

Google Earth's engine is C++. In 2017 Google launched Earth on the web using Native Client, which ran that C++ inside Chrome only. Native Client never spread to other browsers, so the team rebuilt the delivery on **WebAssembly**, and in 2019 released a WebAssembly version that runs in Firefox, Edge and Opera too. Same engine, compiled for a new target, without a rewrite.

## The design decisions, side by side

|  |  |  |
| --- | --- | --- |
|  |  |  |
|  |  |  |
|  |  |  |
|  |  |  |
|  |  |  |
|  |  |  |

## A short history

- **October 2004:** Google buys Keyhole, whose EarthViewer was partly funded through In-Q-Tel.
- **28 June 2005:** Google Earth is released.
- **April 2008:** KML, Keyhole's file format, becomes an official OGC standard.
- **2017:** Google Earth comes to the web on Chrome via Native Client.
- **2019:** A WebAssembly version opens it to other browsers.
- **2021:** Timelapse brings 37 years of planetary change into Earth.
- **2023:** Photorealistic 3D Tiles open the 3D world to developers.

## What I take from it as an engineer

The lesson I keep is not about maps. It is a pattern for any system under load: **do the heavy work once, offline; split the data so the client only fetches what it can show; show something good immediately and refine it; cache close to the user.** Early in my career I shipped a site that worked locally and fell over under real traffic. Google Earth is the opposite of that failure: a system designed from the start for the whole planet hitting it at once.

## Sources

- [Google: Time flies in Google Earth's biggest update in years](https://blog.google/products/earth/timelapse-in-google-earth/)
- [web.dev: How we're bringing Google Earth to the web](https://web.dev/case-studies/earth-webassembly)
- [Google Maps Platform: Photorealistic 3D Tiles](https://mapsplatform.google.com/resources/blog/create-immersive-3d-map-experiences-photorealistic-3d-tiles/)
- [NASA Earthdata: OGC KML standard](https://www.earthdata.nasa.gov/esdis/esco/standards-and-practices/ogc-kml)
- [Wikipedia: Google Earth](https://en.wikipedia.org/wiki/Google_Earth)

### Is Google Earth imagery live?
No. It is a mosaic of snapshots, and each area can be months or years old. The historical imagery slider in Google Earth Pro shows the capture dates.