Meridian

An interactive 3D globe for keeping track of where you've been. Mark the countries, states and cities you've visited and when, put your visits and flights together into trips, look back on each year, replay your trips flight by flight, keep a wishlist, compare your travels with a friend's, and test your geography with fourteen games.

Try it at https://simongsk.github.io/meridian-track-your-travels/. It runs in any browser, on a phone too, can be installed as an app, and works offline. Everything you add stays in your browser.

• Your travels: countries out of the world's 197, states and provinces (USA, Canada, Australia, Brazil), cities with pins, each visit by month with a note, a heat map by visits, a wishlist, and 62 achievements to earn.
• Trips: your visits and the flights between them, in the order you went, named, rearranged by dragging; flights between 3,244 airports, drawn as arcs with little planes.
• Years: a review of each year, the globe showing just that year, and its trips replayed.
• With a friend: your places and a friend's on one globe, from a link, with nothing going through a server.
• Games: a daily challenge, finding countries and cities on the globe, naming neighbours, flags, shapes, capitals, higher or lower, and more, with best scores and time records.
• The globe: seven designs, one of them the Earth as seen from space, day and night from where the sun really is, city lights, and your Mac's screensaver.

What's in it

Spin the globe, hover a country to see its name and flag, and click it to fly there and see its capital, inhabitants and area, the time there, what its money is worth in yours, and the languages spoken.

The design (navy and amber, after a mock-up made in Lovable) has a top bar with the four tabs, where the globe is looking and how many places you've visited. The selected country shows on the left: its ISO code, capital, inhabitants and area, its local time, currency and languages, the cities you've visited there, its states, and a button to put it in your visited atlas. The open tab's cards are on the right. On phones the tabs move to the bottom and panels open as sheets (Explore's two buttons stay in the top corner), with the tab's name and a close button above the cards, which scroll under them. A sheet, a tab's or a country's, opens midway and can be swiped: up, it goes all the way up, from just under the top bar, to see more; down from there, it goes back to midway (or closes, swiped far); down from midway, it closes. Swipe from its top (the little bar), or from anywhere in it: down once what's in it is scrolled to the top, and up while it's midway (all the way up, swiping up scrolls). It follows the finger, and goes where it's let go a quarter of the way, or flicked; otherwise it springs back.

• Explore: two round buttons in the corner, on phones too, so the globe has the room. There's always a tab open: the app opens in Explore, and closing another panel (×, Escape, or swiping its sheet down) goes back to it. The magnifying glass opens a search of the whole atlas, countries by any name and cities. The layers button opens the designs and the layers.

  Designs: switch the globe between Midnight (the default), Classic, Vintage, Political (neighbors always in different colors), Night, Minimal and Realistic. Realistic shows the Earth as seen from space, with its oceans, forests, deserts, ice and snow, the sea shining in the light, and mountains in relief (zoom in on the Himalayas or the Andes). With Day and night on, its night side is dark as from space, the lights bright on it, and your places glow faintly in their colors through the dark, so they still show there. Only your places (and whatever else is colored, like the wishlist or a game's answers) are painted over it, see-through, so the land still shows under them. Each design is a tiny globe in its colors, all in a row, with the one chosen named under them. Under them are the layers to show or hide: city pins, visited countries and their heat map by visits, visited states, flights (and under them, replaying your trips in the screensaver), future flights (those booked for trips to come, dashed), future visits (the places of trips to come, tinted and outlined in dashes), the wishlist, day and night, and rings around small islands. Each has a dot in the color it is on the globe in the design chosen, and they're listed by color, then by name.

  Day and night (off until switched on) darkens the side of the globe where the sun has set, as it is right now, fading through twilight down to 18° below the horizon, and lights it with the Earth's lights at night as seen from space, from NASA's picture of them, in every design: whole regions as they glow, not just their cities (the US East Coast, the Nile, dark central Africa). Should the picture not load (offline before it was kept), each city is a dot of light instead, bigger for more people. City lights shows under it while it's on, to have night without the lights. It moves on every minute, and is hidden during games. Where the sun is overhead comes from the Astronomical Almanac's low-precision formulas (src/globe/sun.ts), good to about 0.01°.

• Visited: three symbols switch between your countries (a flag), trips (a plane) and years (a calendar); pointing at one shows its name. Each has a small box of figures. Keep track of where you've been, out of the world's 197 countries, with the count and percentage for each continent. Under the share of the world's countries is the share of its people your places are home to, and of its land they cover ("Home to 24% of its people, on 36% of its land"): people from the World Bank, and land as big as each place is on the map, which measures every place alike (the World Bank counts only Greenland's land free of ice). Each place counts for itself, so Greenland's people and land are Greenland's, not Denmark's. "✨ Your atlas as a poster" makes all of it a card to keep or share, as a year wrapped is (under Years, below): how many of the world's countries, a flat map of the world with every place been to and every route flown, how many territories, continents and cities, the share of the world's people and land, the flags of every place by continent (as big as they all fit, down to a size where the rest are "+N"), and your flights, trips and the first year you have a date for. or , and Escape or ✕ puts it away. Territories are counted separately, and also count for the country they belong to: marking just Greenland counts Denmark as a country been to, listed under Europe as "In Greenland" (with nothing to remove, as it isn't marked itself). The globe colors only what you've marked. Click a continent's bar to see its places over everything else: those you've visited first (with their visits, states and cities), then its countries not yet; click one to see it, or close the list with ×, Escape or a click beside it. A country's territories are listed under it, in its continent, whether you've been to the country or not: the Faroe Islands and Greenland under Denmark in Europe, Puerto Rico under the United States. Those you haven't visited are quieter, with a ✓ to mark them. Places that are no country's (Antarctica, Western Sahara, the Siachen Glacier) are listed on their own under their continent, so Antarctica has a bar too, counting its places. Search to add places (old names like "Swaziland" work too), or click a country and press "Add to visited atlas". They're colored on the globe.

The globe spins on its own until you touch it, and again once it's been left alone for 30 seconds. Tiny countries and islands get a ring marker, and clicks just beside a small island still count, also with the rings hidden. Zoomed in, tiny places reach 3.5 km around them, so pointing near Vatican City finds it (at this map's scale it's drawn 1.6 km from where it is). Only a pin's head answers to the pointer, so what's under its stem stays clickable. City pins fade out as they near the edge of the globe.

Online

Meridian is online at https://simongsk.github.io/meridian-track-your-travels/, so it opens in any browser, on a phone too, without installing anything. Every push to main builds it and puts the new version there with GitHub Pages (.github/workflows/deploy.yml, about a minute). It's served over https://, so it can be installed as an app and works offline (below), and a friend opening it is at the same address as you, so "Copy my link" works between you.

Your places are kept by the browser for each address, so the online app starts empty even if you've used npm run dev. To bring them over, Download backup under More at http://localhost:5173 and Restore from a backup… online (see Backup).

To set it up the first time, the repository has to be public (GitHub Pages is free only for public repositories), and in its Settings › Pages, Source set to GitHub Actions (skip the suggested workflows, like Jekyll or Static HTML: the repository has its own). Then run the Deploy workflow from the Actions tab, or push to main.

Screensaver

The globe can be your Mac's screensaver, spinning with your places on it. With ?screensaver in the address the app shows only the globe, and the pointer doesn't stop it. It looks at the globe from just north of the equator, so as it turns you see Europe and Canada but also Australia and New Zealand, and its pins stay until closer to the edge. A screensaver keeps its own storage, so the address carries your places, flights, trips, wishlist, design and layers in its #places=… part. Trips to come show as on the globe, with Future visits and Future flights switched on.

With Replay timeline on (a switch at the top of More › Screensaver, on unless switched off, and only with the Flights layer shown), the screensaver replays your trips every so often: ten seconds after it starts, then a minute and a half after each one ends. It's the replay from the Trips list, without the bar, and without moving the globe: it spins on as it was, while every trip been on comes back in its turn, oldest first, each flight flown by its plane, drawing its line behind it, and a country colored as the flight lands in it, or in its turn when it's reached without one, those of the trip it's on standing out. Then everything shows again until the next. The preview in the app replays too.

1. Run npm run build:screensaver. It builds the app into one self-contained file, screensaver/index.html, that opens from disk without a server, and copies it to /Users/Shared/Meridian/ (screensavers can't read Documents, Desktop or Downloads).
2. Install WebViewScreenSaver (Apache 2.0), which shows a web page as a screensaver: brew install --cask webviewscreensaver. (Its README adds --no-quarantine, but current Homebrew no longer has that option; macOS asks you to allow the screensaver instead, below.)
3. Open System Settings › Wallpaper and click Screen Saver…. Scroll down to Other, all the way to the right, and pick WebViewScreenSaver.
4. The first time, macOS blocks it: in System Settings › Privacy & Security, allow it on the message there.
5. Back in Screen Saver, click Options and paste the screensaver address, which the app's Screensaver card, under More, copies for you.

The screensaver doesn't update by itself. After changing your places, design or layers, copy the address again and paste it in Options; after changing the app, run npm run build:screensaver again. An older screensaver doesn't know what's been added to the app since, so it leaves out what it can't show (a screensaver from before trips shows none of them), and one built before October 4th sets every layer back on when the address has layers it doesn't know.

"Preview", next to the address in the Screensaver card, shows the screensaver right there in the app, to have a look: everything but the spinning globe steps aside, and the globe turns to the screensaver's view. An "Exit preview" button shows in the corner as it opens, and again when you move the mouse (with the pointer) or tap the screen on a phone; it and Escape bring everything back, with the Screensaver card still open. The real screensaver has neither.

Backup

Visited places, when you went and your notes, states, cities, flights and trip names, the wishlist, visits planned, a friend you compare with, best scores and times, daily challenges, the design, the settings and your currency are saved in your browser (localStorage). Nothing is sent anywhere, so clearing the browser's site data, or moving to another browser or computer, would leave them behind. Under More, Download backup saves all of it to a file (meridian-backup-2026-10-04.json, readable JSON), and shows when you last did. Restore from a backup… reads one, says what it holds and when it was made, and only replaces what's in this browser when you confirm. Every part of the file is checked the way the app checks it when loading, so a damaged or foreign file is refused as a whole rather than half restored.

Removing something by mistake is easy to take back: removing a country, a visit, a city, a flight, a place on the wishlist or a friend shows a note at the bottom ("Removed Japan · Undo") for eight seconds. Undo, or Cmd/Ctrl+Z when you're not typing, puts it back as it was: a visit with its note, a flight where it was among the others (so its trip stays the same). Only the last removal can be undone.

Opening the app never writes over what's saved: something is saved only when you change it. So if the app finds data it can't read (saved by a newer version, or damaged), it leaves it as it is. If you then change that part, the new data is saved and the old is kept beside it, under the same name with .unreadable added.

Install as an app

Meridian can be installed as an app, which opens in its own window from the dock or home screen, with its globe icon:

• Chrome or Edge: the Install Meridian button under More (App), or the install icon at the end of the address bar.
• Safari on a Mac: File › Add to Dock.
• iPhone or iPad: in Safari, Share › Add to Home Screen.

It's called just Meridian. An app installed under an earlier name (it was "Meridian · Countries of the World", then "Meridian · Track your Travels") can keep that name in its window and menus until the browser updates it, which Chrome does now and then when it opens the app; to have it at once, uninstall the app and install it again. Your places are kept by the browser for the address, not by the app, so they stay, as long as you don't tick "Also clear data" when uninstalling (download a backup first, to be safe).

After the first visit it works offline, installed or not: the globe, your places and flights, the cities and airports, and every game. The build writes a service worker (sw.js, by vite.offline.ts) that keeps a copy of every file of the app, with a version made from their contents. Online, the page comes from the network, so a new build is noticed. Once the new version has been downloaded, in the background, a note at the bottom says "A new version is ready": Reload switches to it at once, and otherwise it takes over the next time the app is opened. Either way the old copy is cleared. While the app stays open, it looks for a new version every hour and whenever you come back to it. The service worker runs only in the production build served over the web (not npm run dev, nor the screensaver). Browsers allow one only on https:// or localhost.

Built with React, TypeScript and Vite, using react-globe.gl (three.js) for the globe, world-atlas (Natural Earth 1:50m) for country shapes and flag-icons for flags. The fonts are Fraunces, Inter and JetBrains Mono (SIL Open Font License), from Fontsource. Flags and fonts are bundled, so no requests go to third parties, but for the day's exchange rates (below).

Getting started

npm install
npm run dev

Then open http://localhost:5173.

To see the app with someone's travels already in it, run npm run dev:demo and open http://localhost:5174. It has 42 places with visits over ten years (some with notes, and several visited again and again for the heat map), states, cities, trips made from its flights (three of them named), a wishlist, a trip to India coming up (with its flights booked) and one to Chile, best scores and a daily streak. Being on another port, its data is kept apart from yours. The sample data is put in when nothing is saved there yet; add ?reset to the address to start over. It's only in this mode, not in the build.

Scripts

Command	What it does
npm run dev	Start the dev server
npm run dev:demo	Start the dev server with sample data, on port 5174 (see Getting started)
npm run build	Type-check and build for production into dist/
npm run build:screensaver	Build the screensaver file and copy it to /Users/Shared/Meridian/ (see Screensaver)
npm run preview	Serve the production build
npm run lint	Lint with Oxlint
npm test	Unit and component tests (Vitest)
npm run test:watch	Same, re-running on changes
npm run test:coverage	Unit and component tests with a coverage report
npm run test:e2e	End-to-end tests against the real WebGL globe (Playwright)
npm run data:map	Regenerate src/data/countries-50m.json (the country shapes, with lakes cut out)
npm run data:extra	Regenerate src/data/extra-countries.json (places too small for the 1:50m map)
npm run data:regions	Regenerate src/data/regions.json (states and provinces)
npm run data:facts	Download capitals, population and area from the World Bank into src/data/country-facts.json
npm run data:time-zones	Read each place's time zones from the system's zone.tab into src/data/time-zones.json
npm run data:currencies	Download which currencies each place uses from the Unicode CLDR into src/data/currencies.json
npm run data:rates	Download a recent day's exchange rates into src/data/rates.json, bundled for offline
npm run data:languages	Download the languages spoken in each place from the Unicode CLDR into

The first time you run the end-to-end tests, install the browser:

npx playwright install chromium

Tests

• Unit and component tests (Vitest and Testing Library, in jsdom): the data, the game rules, the globe's layers against a real three.js camera, every panel, and the whole app with a stand-in for the WebGL globe. About 980 tests, covering over 99% of the lines.
• End-to-end tests (Playwright): the real app with its WebGL globe in headless Chromium, on a desktop and a phone (touch, tab bar, sheets): hovering and clicking countries, visited places, states, cities and flights kept after reloading, the wishlist, a friend's link, the settings, a year in review and its replay, a backup downloaded and restored, undoing a removal, the designs, every game, the screensaver and its preview (42 tests). In CI they run on the production build, with the service worker.

.github/workflows/tests.yml runs all of it on GitHub for every pull request and every push to main: lint, the unit tests, the build (which type-checks), and the end-to-end tests. .github/workflows/deploy.yml then puts each push to main online (see Online).

How it works

src/
  App.tsx              ties it together: globe, hover/selection, menu, games, camera flights
  CountryPanel.tsx     panel shown for the selected country
  RegionPicker.tsx     its states to tick off
  CityPicker.tsx       its visited cities, and a box to add more
  FlagCorner.tsx       hovered country's flag, bottom-right
  Tooltip.tsx          country name that follows the mouse
  countries.ts         every place: shape, names, codes, size, map color; lookup by point or name
  flags.ts             country → flag image URL
  data/
    names.ts           display names, alternative spellings, countries vs territories
    sovereigns.ts      the country each territory belongs to (Greenland to Denmark)
    continents.ts      each place's continent
    westernSahara.ts   shows all of Western Sahara (see below)
    countries-50m.json    the country shapes, with lakes cut out
    extra-countries.json  Tuvalu and Gibraltar, from the 1:10m map
    regions.ts         states and provinces: names, lookup, loading (shapes in regions.json)
    facts.ts           capital, population and area (data in country-facts.json)
    cities.ts          big and well-known cities: loading, lookup (data in cities.json)
    airports.ts        airports with scheduled flights: loading, search (data in airports.json)
    flights.ts         flights: distances, figures, routes, moving old city flights to airports
    trips.ts           flights grouped into trips as worked out from where they go, and their stops
    savedTrips.ts      trips made by hand, the only record of visits: visits and flights in order, what's in none,
                       where something new goes, and what there was before (dates, plans) put into trips
    replay.ts          replaying your trips, oldest first, or one, as a timeline of flights flown and places reached,
                       on its own clock, to pause and go faster
    localTime.ts       each place's time zones and the time there (data in time-zones.json)
    languages.ts       the languages spoken in each place (data in languages.json)
    money.ts           each place's currency, what it's worth in yours, and a guess at yours
                       (data in currencies.json, rates bundled in rates.json)
  storage.ts           state saved in the browser
  base64url.ts         packing text into an address, for the screensaver and a friend's link
  screensaver.ts       the screensaver mode, and carrying your places in its address
  demo.ts              sample data for `npm run dev:demo`
  ui/                  the cards with "GAMES ··· 06" headers, the boxes of figures, the key in the globe's corner,
                       keeping password managers off the text boxes, and a clock that moves on each minute
  nav/                 the top bar, tabs, the column of cards on the right
  explore/             the Explore tab's buttons: the atlas search, and the designs and layers, with their settings
  visited/             visited countries, states and cities; the wishlist; a friend to compare with; flights, and the airport search;
                       achievements (achievements.ts), their view and the note when one is earned;
                       each year's review (yearInReview.ts) and its view; the cards to keep or share, a year wrapped
                       (wrapped.ts), a trip (tripCard.ts) or your atlas (atlasPoster.ts), drawn on a canvas
                       (cardDrawing.ts) and shown full screen
  design/              design picker, how to set up the screensaver, and the way out of its preview
  more/                the More tab's small cards, each opening to all of it
  settings/            backups: making, checking and restoring them, and their card; installing the app;
                       your currency and the day's rates (useCurrency.ts), and their card
  pwa/                 the service worker (serviceWorker.ts, written into the build by vite.offline.ts),
                       starting it, and the browser's offer to install
  games/               game rules (games.ts, letterGame.ts, higherLower.ts, daily.ts, cityGame.ts, cityCountry.ts, biggerCity.ts,
                       neighboursGame.ts), what the globe shows (globeView.ts),
                       state and best scores (useGame.ts), perfect runs and their times (records.ts),
                       the panel, answer box and outlines
  globe/
    sphereMesh.ts      triangulating countries on the sphere
    countryLayer.ts    all countries merged into one mesh, plus borders and markers; the raised country
    regionLayer.ts     states and provinces drawn over their country
    pinLayer.ts        pins on visited cities, and finding the pin under the pointer
    flightLayer.ts     flight routes as arcs, with planes flying along them
    colors.ts          which color each country gets (game answers > hover > a friend's > visited > wishlist > land)
    themes.ts          the designs
    hooks.ts           the layers, pointer picking, depth precision, idle spin
    interaction.ts     click-vs-drag, flight duration/altitude, easing
    picking.ts         screen position → lat/lng on the globe
    style.ts           heights
e2e/                   Playwright tests
scripts/               data extraction
.github/workflows/     the tests, run on GitHub, and putting the app online with GitHub Pages

A few choices keep the globe smooth:

• One mesh for all countries. The globe library's polygon layer draws each country piece separately (~1,500 meshes, 7,500+ draw calls per frame). Instead, every country is merged into a single mesh. Each country keeps its own range of vertex colors, so hover and game answers recolor it in place. The selected country is drawn separately, slightly raised with walls.
• Our own triangulation. Each polygon is projected with a gnomonic projection centered on it (great circles become straight lines), triangulated with earcut so it follows the coast exactly, then subdivided until no edge is longer than 3° so the flat triangles hug the sphere. This works across the antimeridian and around the poles, builds the whole world in ~60 ms, and avoids the gaps the globe library's triangulation left in countries like Greenland.
• Depth precision. The camera's near plane moves out as you zoom out, so the land never flickers against the ocean below it.
• No mesh raycasting. Hover and click intersect a ray with the globe's sphere, then look up which country contains that lat/lng (about 0.1 ms), forgiving a few pixels near markers and coasts.
• Eased auto-rotate. The idle spin eases in and out, stops on any interaction, and resumes after 30 seconds untouched.

Country data

The map has 243 places: the 197 countries (the 193 UN members, the observer states Vatican City and Palestine, and Kosovo and Taiwan) and 46 territories and other areas, such as Greenland, Puerto Rico, Hong Kong, Western Sahara and Antarctica.

Each place has:

• name: the display name, e.g. "Eswatini". The map data (Natural Earth) abbreviates names ("Dem. Rep. Congo") and writes "eSwatini", the styling the kingdom itself uses; we show full current English short names.
• mapName: the name in the map data.
• aliases: every other name it goes by, from ISO and a curated list of former and common names ("Swaziland", "East Timor", "Ivory Coast").
• kind: "country" or "territory".
• continent: from flag-icons' country data, with the Caribbean islands it places in South America (Aruba, Curaçao, Bonaire, Trinidad and Tobago) counted as North America, as usual. Russia and Cyprus are in Europe; Türkiye, Georgia, Armenia and Azerbaijan in Asia.
• isoCode and isoAlpha2: ISO 3166-1 codes ("208", "DK"). A few disputed areas have none (null); Kosovo uses the widely adopted "XK".
• centroid, extent and areaKm2: center and size of the main landmass, and the area.
• tiny: under 2,500 km², so it gets a marker.
• island: shares no land border, so (under 30,000 km²) it gets a ring in the letter hunt.
• mapColor: 0–4, never shared with a neighbor.

Some corrections to the map data:

• Lakes. Natural Earth's country shapes cover their lakes (lakes are a separate layer), so the Great Lakes, Lake Victoria and Baikal would be land. scripts/extract-map.mjs cuts its 275 lakes at 1:50m out of the countries, and extract-regions.mjs out of the states, so they show as water and pointing at them finds no country. The cutting is done with Clipper on the map's own grid: every other point stays exactly where it was (so neighbors still share their borders), and points along borders that follow a parallel, like the 49th between the USA and Canada, are kept, as without them those borders would bulge into great circles on the globe. Borders that ran through lakes are now lake shores.
• Borders as the UN counts them. Natural Earth draws borders as they are on the ground. Where the UN counts land as another country's, scripts/un-borders.mjs follows the UN: Crimea is Ukraine's (General Assembly resolution 68/262), the Golan Heights are Syria's (Security Council resolution 497, cut along the 1967 line), the Chagos Archipelago is Mauritius's (resolution 73/295), and Somaliland and Northern Cyprus, which run themselves but are recognized by few countries, are part of Somalia and Cyprus. The countries involved say so in their panels. Disputes the UN takes no side in, like Kashmir, stay as drawn. Kosovo and Taiwan, which aren't UN members, are kept as countries, as in most lists of the world's 197.
• Western Sahara. Natural Earth draws only the inland strip east of the Moroccan sand wall as Western Sahara and counts the coast as Morocco. We show the whole territory, bordering Morocco along 27°40′N, as the UN and most maps do.
• Tuvalu and Gibraltar are too small for the 1:50m map and are copied from the 1:10m map.
• The Maldives are in the map but are a few tiny atolls, so like other small places they get a marker.
• Monaco's area. The World Bank gives 75 km²; it's about 2 km², set in country-facts-extra.json.

Local time and currency. Under a country's inhabitants and area, its panel shows the time at its capital ("06:42"), and how far ahead of yours ("7 h ahead of you"); a place with several times (the USA's 29 time zones are 6 times) says so, and that the one shown is the capital's. Beside it, what a round sum of its money is worth in yours: "100 JPY = 4.23 DKK", the smallest of 1, 10, 100… worth at least one of yours, with the currency's name, or "as yours" when it's the same. Across the bottom, the languages spoken there: the official ones first, then those official in a part of it (Catalan in Spain), each by how many speak it, or for a place with none official, the most spoken. The first four show, and "+17 more" shows the rest (India has 21). Your currency is a setting under More › Settings › Currency; until you pick one it's guessed from your device's time zone (set by where you are, so Copenhagen's is the Danish krone), else the region of your language, without asking for your location.

The time zones are the IANA time zone database's zone.tab (public domain), which lists every zone with its country and the place it's named for: scripts/extract-time-zones.mjs (npm run data:time-zones) reads the system's copy into src/data/time-zones.json, the zone nearest to each capital first; Kosovo, with none of its own, has Skopje's. Which currencies each place uses today come from the Unicode CLDR (Unicode License), the locale data browsers are built on (npm run data:currencies), and so do its languages, with how many speak each and whether they're official (npm run data:languages); their names are the browser's own. The rates, per euro, are the open currency-api (public domain): those of a recent day are bundled (npm run data:rates), so it works offline straight away, and the app fetches the day's from it at most once a day, only when you open a country's panel (or the Currency card) and are online. That's the one request the app makes to a third party; it carries nothing of yours. The panel says from which day the rates are.

Capitals, population (2024) and total area come from the World Bank's open data (CC BY 4.0). Places it doesn't cover (Taiwan, Vatican City, Western Sahara and several territories) use recent censuses and estimates from src/data/country-facts-extra.json, marked as estimates in the app. Somalia's and Cyprus's figures include Somaliland and Northern Cyprus.

Cities come from GeoNames (CC BY 4.0), via all-the-cities. For each place, scripts/extract-cities.mjs keeps the capital, every city of a million or more, the next biggest (more for more populous countries, from 50,000 people), and a hand-picked list of famous smaller ones (Venice, Key West, Chefchaouen…), leaving out suburbs within 25 km of a city already picked. GeoNames often uses local spellings, so the script has English names for well-known cities ("Cologne", not "Köln") and leaves out transliteration marks; it also has a short list of GeoNames entries that are districts, camps or campuses rather than cities. Overseas regions like Réunion are listed under the country the map draws them in. Cities in the USA, Canada, Australia and Brazil carry their state: GeoNames' state code for the city, matched to the map's state that most of that code's towns fall in (the city's own point won't do, as the map's simplified outlines leave cities on a coast or a border just outside). A few places the all-the-cities extract leaves out (Vilanculos) are added by hand, with their GeoNames ids.

How far each city reaches, for the city game, comes from Natural Earth's 1:10m urban areas (public domain). scripts/measure-cities.mjs lays a grid of square kilometers over the built-up land around each city, and counts the land reached from the city without a gap of more than 2 km, so a river or a strait doesn't cut a city in two (New York, Istanbul) but a town apart from it isn't counted. Where cities grow into each other, like Tokyo and Yokohama, each square goes to the city it's nearest to for its size, so the bigger one reaches farther. A city's reach is the radius of a circle as big as its land.

Airports come from OurAirports (public domain): scripts/fetch-airports.mjs keeps the large and medium airports with scheduled airline service and an IATA code, which covers every international airport.

Lakes come from Natural Earth's 1:50m lakes, also via sane-topojson.

The Realistic design's picture of the Earth is NASA's Blue Marble (public domain), 4096 × 2048, with a map of where the sea is to make it shine and one of how high the land is, for the relief. The lights at night, in every design, are kept from NASA's Earth at night: in that picture they're dots a pixel or two wide on moonlit land and sea, which would blur into the blue when shrunk to fit the globe, so scripts/make-night-lights.mjs (npm run data:night-lights) keeps only what's brighter than around it, on black, where it blurs into a glow instead. All of them come from three-globe's examples (src/assets/).

States and provinces come from Natural Earth's 1:50m states and provinces, which covers the USA (50 states and D.C.), Canada, Australia and Brazil. They're copied out of sane-topojson (MIT) and load in the background after the globe. More countries would need Natural Earth's much larger 1:10m dataset.

Commit messages

This repo uses Conventional Commits: feat:, fix:, refactor:, docs:, test:, chore:.