Designed and Created by Project Moon Pi · projectmoonpi.com · Help: support@projectmoonpi.com
A live ADS-B radar scope styled after an ATC display: aircraft from the internet (adsb.fi) or your own SDR receiver, drawn over runways, airspace and SID/STAR routes. It runs on a Raspberry Pi driving an HDMI monitor or TV, and in any web browser (sharp on Retina and high-DPI screens).
- Python 3.10+ and pygame (or pygame-ce, its drop-in community edition); no other packages.
- Pi + HDMI: a fullscreen pygame display (tested at 1920×1080 and 1280×720).
- Browser: the same scope at
http://<address>:7700/radar, from any device on your network, or alone on a laptop with--web-only. - Settings page at
http://<address>:7700/radar_config.
SkyScope 1.11.0 for Mac ·
SkyScope 1.11.0 for Windows
(also on projectmoonpi.com/downloads, or the
latest release page): one file. On a Mac, open it and double-click
Install SkyScope; on Windows, double-click it. The laptop and desktop section below
has the details. (GitHub's green Code › Download ZIP button gives the source
code as skyscope-main.zip, which isn't the installer.)
SkyScope Guide (PDF): requirements, step-by-step
Raspberry Pi installation, setup, every feature, and troubleshooting. The same
guide is built into the app at http://<address>:7700/guide (source:
docs/guide.html; rebuild the PDF with
sh tools/build_guide_pdf.sh).
| Raspberry Pi | Laptop / desktop | |
|---|---|---|
| Hardware | Pi 5 (recommended) or Pi 4 (2 GB+), official power supply, 16 GB+ microSD, HDMI display | Any Mac, Windows or Linux computer |
| Software | Raspberry Pi OS with desktop (64-bit), python3-pygame, git |
Python 3.10+, pip3 install pygame-ce, a current browser |
| Network | Internet for adsb.fi data, logos and photos; port 7700 on your LAN | Same |
| Optional | RTL-SDR dongle + 1090 MHz antenna (readsb); USB GPS (gpsd) |
- Radar scope on the left, full screen height: range rings, ATC-style runways, aircraft symbols, speed lines, labels, and dots for traffic just beyond the range
- Radar sweep: a rotating beam with a fading green trail; aircraft can fade between sweeps too (Display tab: Aircraft fade, with a fade rate from 1 to 100)
- Radar colours: Standard, or Green: aircraft, labels, runways and airspace all in green, like an older ATC screen
- Aircraft silhouettes (optional): top-down airliner, wide-body, business jet, turboprop, light single, glider and helicopter shapes, picked from each aircraft's ADS-B category and type code, sized by class. Or the original red triangles.
- Airline logos (optional): from the callsign (KLM887 → KLM), on the Nearest card, in the table, and optionally beside the radar tags
- Uncluttered labels: nearest aircraft are labelled first; a label that would cover another label, an aircraft or a compass letter tries the other side, above and below, and is left off if none fit (the aircraft stays in the table)
- Units of your choice: distance km / mi / nm, speed kt / km/h / mph, altitude ft / m. Every figure is labelled with its unit.
- Info panel on the right: clock (local + UTC), aircraft count, a "Nearest" card (callsign, registration, aircraft name, altitude and climb/descent, distance, bearing, speed, track) and a table of contacts, nearest first. The nearest contact is ringed in yellow on the scope.
- Live data from adsb.fi, polled every 5 s, with positions dead-reckoned between fetches so planes move smoothly
- Screens narrower than ~3:2 show the radar alone, centred
Every option can be changed from a phone or laptop on the same network at
http://<pi-address>:7700/radar_config (the address is shown at the bottom
of the side panel). The page is arranged in tabs: General (location, data
source), Display (scope, units, sweep), Map (runways, airspace,
SIDs/STARs), Filters, Presets, Alerts and About (updates,
a QR code for phones, version, this radar's addresses, links to the guide
and the companion displays, credits). Changes are kept until you press Save in the bar at the bottom,
which says when there are unsaved changes; saved changes apply to the screen
immediately.
Tip: name the Pi skyscope (Raspberry Pi Imager → hostname) and the page is
also at http://skyscope.local:7700/radar_config. The bare address
(:7700) opens the browser radar. The page has
no password, so anyone on your network can change settings. Set web_port to
0 in settings.json to turn it off.
In the Filters section of the settings page. Filters apply to the radar, the edge dots, the table and the Nearest card; while any is on, the panel says e.g. "35 of 134 aircraft (filtered)".
- Kinds of aircraft (tick the ones to show). Every aircraft is in exactly one:
- Airliners: jets, and turboprops flying an airline callsign
- Business jets
- General aviation: light aircraft and private turboprops (a Cessna on a flight school's callsign is still GA)
- Helicopters
- Military: flagged as military in the aircraft database
- Other / unknown: no type information (e.g. TIS-B targets) and ground stations
- Aircraft types: ICAO type codes, show only these or hide these.
*matches anything:B73*is every 737,A32*the A320 family. - Airlines / operators: the three-letter code at the start of the callsign
(
AAL,SWA,UAL,KLM...), show only or hide. - Country of registration: tick countries, show only or hide. Worked out
from each aircraft's 24-bit ICAO address (allocation table from ICAO Annex
10, in
data/icao_countries.json), so it works even without a registration. - Altitude blocks (barometric altitude; also an Altitude dropdown on the radar page with All / each block / Below FL180 / Above the low block): 10,000 ft AGL and below, from there to FL180, FL180 to FL600; untick a block to hide it. The low block counts from the ground at the radar's centre (in Denver it reaches about 15,200 ft MSL); the elevation comes from the GPS or Open-Meteo's free elevation service, or you enter it (General tab). Aircraft on the ground count as the lowest block; aircraft with no altitude are hidden while any block is off.
- Presets: built in are Everything, Airliners only, GA & helicopters, 10,000 ft AGL and below, Helicopters and Military. Set the filters you want and Save preset under your own name; Apply or Delete them on the settings page, or switch presets from the picker at the bottom of the radar page. The panel shows the active preset beside the range.
Watched aircraft and emergencies are always shown, whatever the filters.
- Emergency squawks: aircraft squawking 7700 (emergency), 7600 (radio failure) or 7500 (hijack), or broadcasting an emergency status, flash red/white with a pulsing ring, are labelled first, go to the top of the table, and get a red banner in the panel.
- Watchlist: callsigns, registrations, ICAO addresses or type codes, with
*wildcards (N123AB,ENY*,B52,A0B1C2). Matches get a gold ring, a ★ in the table and a gold callsign, are labelled first, and (optionally) a gold banner while in range. - Colour by kind: airliners red, business jets orange, GA blue, helicopters purple, military khaki, other grey, with a key in the panel. Off: everything red.
The Nearest card also names the aircraft's kind (e.g. "NEAREST · AIRLINERS").
Choose Aircraft data from on the settings page:
- Internet (adsb.fi): the default. Needs a network connection; polled every 5 s.
- SDR receiver on this Pi: a USB RTL-SDR dongle with a 1090 MHz antenna, decoded by readsb (or dump1090-fa / PiAware). Works with no internet at all, refreshes every second, and shows what your antenna hears, so range depends on the antenna and its view of the sky.
The radar reads the decoder's aircraft.json. With the location left at
auto it finds readsb, dump1090-fa, dump1090 or a tar1090/SkyAware web page
by itself; otherwise enter the file path or URL. The settings page shows
which one it's reading, or why it can't. The side panel shows the source
("adsb.fi" or "SDR receiver") next to the aircraft count.
Installing readsb (the decoder) on the Pi:
sudo bash -c "$(wget -O - https://github.com/wiedehopf/adsb-scripts/raw/master/readsb-install.sh)"
sudo readsb-set-location <your-lat> <your-lon>Your receiver can also feed FlightAware with its free PiAware software (install guide); SkyScope keeps reading readsb. Feeders get a free FlightAware account and a larger free AeroAPI allowance for flight routes.
Note: with a local receiver, the aircraft type and full name come from the decoder's aircraft database. If that isn't enabled, those fields may be blank for some aircraft. Airline logos already downloaded keep working offline; new ones need internet once.
With a GPS receiver attached, the radar can centre itself. Choose the Location source on the settings page:
| Source | Use it for | Behaviour |
|---|---|---|
| Manual | Typing the position in | Uses the latitude/longitude fields |
| GPS: read once at start-up | A Pi that stays put | Takes one fix each time it starts, then stays fixed. Read GPS now takes a fresh one (e.g. after moving it). |
| GPS: keep updating | A mobile Pi | Re-centres every N seconds (gps_update_s, default 30), ignoring moves under 50 m (GPS jitter) |
The panel shows GPS / GPS live next to the coordinates, or a red "no fix, last known position" note. The settings page shows fix type and satellite count. Every GPS position is saved, so after a reboot without a fix the radar starts at the last known spot.
The GPS is read through gpsd, the standard Linux GPS service, so any receiver gpsd supports works (USB sticks such as u-blox, or GPS HATs):
sudo apt install gpsd
# USB receivers are usually found automatically. For a HAT on the serial port,
# set DEVICES="/dev/serial0" in /etc/default/gpsd, then:
sudo systemctl restart gpsd| Key | Effect |
|---|---|
| R / Space / → | Next range (see Ranges below) |
| Mouse wheel over the scope | Up: shorter range, down: longer |
| ← | Previous range |
| U | Distance unit: km → mi → nm |
| W | Runways on/off |
| S | Sweep on/off |
| A | Aircraft symbols: silhouettes ↔ triangles |
| L | Airline logos: off → side panel only → panel + radar |
| G | Ground traffic on/off |
| D | Dots on the rim for aircraft just beyond the range on/off |
| F | Fullscreen ↔ window |
| Q / Esc | Quit |
All changes are saved.
The range is the distance to the outer ring, in round numbers for each distance unit. Every ring is labelled with its distance (beside the east spoke), at a round step: 25 mi → 5 / 10 / 15 / 20 / 25, 50 km → 10 … 50, 2 mi → 0.5 / 1 / 1.5 / 2.
| Unit | Ranges |
|---|---|
| km | 5, 10, 15, 25, 50, 100, 150, 200, 300, 400 |
| mi | 2, 5, 10, 15, 25, 50, 75, 100, 150, 200, 250 |
| nm | 2, 5, 10, 20, 40, 60, 80, 100, 150, 200 |
Changing the unit moves to the nearest equivalent range (e.g. 50 km → 25 mi). The largest ranges stay within adsb.fi's 250 nm query radius (the scope fetches ~11% past its outer ring for the edge dots). They can be busy: around Phoenix about 240 aircraft at 100 mi and 600 at 250 mi on a weekday afternoon. Labels thin themselves out, every aircraft stays in the table, and up to 1,500 aircraft are handled; filters help most here. The browser display draws 500+ aircraft in under 10 ms per frame; on a Pi, the pygame display may slow down at the largest ranges.
Everything is stored in settings.json next to skyscope.py (created on
first run). The web page and keys edit it for you; by hand you can also set:
| Key | Default | Meaning |
|---|---|---|
data_source |
"internet" |
"internet" or "sdr" |
sdr_location |
"auto" |
Path or URL of the decoder's aircraft.json |
distance_unit |
"km" |
"km", "mi" or "nm" |
speed_unit |
"kt" |
"kt", "kmh" or "mph" |
altitude_unit |
"ft" |
"ft" or "m" (climb rate then in m/s) |
hidden_classes |
[] |
Kinds to hide: airliner, bizjet, ga, helicopter, military, other |
type_mode / type_filter |
"off" / "" |
"only" or "hide"; codes like "B738, A32*" |
operator_mode / operator_filter |
"off" / "" |
"only" or "hide"; codes like "AAL, SWA" |
country_mode / country_filter |
"off" / [] |
"only" or "hide"; country names |
show_airspace |
true | US Class B/C/D outlines |
procedure_airports / procedure_mode |
{} / "both" |
Per airport, e.g. {"KPHX": "star"}; overall switch both (as ticked), sid, star, off |
runway_types / runway_centerlines |
["L","M","S"] / true |
Airports shown (major/regional/small); ATC-style centrelines |
center_airport |
"" |
ICAO code the scope is centred on |
hidden_alt_bands |
[] |
Altitude blocks to hide: low, mid, high |
elevation_source |
"auto" |
Ground elevation for the low block: "auto" (GPS, else looked up) or "manual" |
ground_elevation_ft |
0 |
The elevation used when elevation_source is "manual" |
filter_presets |
{} |
Your saved presets: name → filter values |
highlight_emergencies |
true | Flash and banner 7500/7600/7700 |
watchlist / watch_notice |
"" / true |
Watched aircraft; banner when in range |
color_by_kind |
false | Colour symbols by kind of aircraft |
location_source |
"manual" |
"manual", "gps_once" or "gps_live" |
gps_update_s |
30 | Seconds between GPS re-centres when mobile |
aircraft_symbol |
"silhouette" |
"silhouette" or "triangle" |
airline_logos |
"all" |
"off", "panel" or "all" |
scope_style |
"standard" |
"standard" or "green" (everything in green, like an older ATC screen) |
sweep_enabled |
true | Radar sweep on/off |
show_beyond_dots |
true | Rim dots for aircraft just outside the range |
web_port |
7700 | Settings page port (0 = off) |
sweep_period_s |
4.0 | Seconds per full turn of the beam |
sweep_trail_deg |
90 | Length of the fading trail, in degrees |
fade_enabled |
false | Aircraft brightest as the sweep passes, dimming (never out) until it comes round |
fade_rate |
50 | 1–100: how far they dim (1 barely, 100 to a fifth), over one whole turn |
fps |
30 | Frame-rate cap; lower it if a Pi struggles |
fetch_interval_s |
5 | ADS-B poll interval (adsb.fi allows 1 req/s) |
Full steps, with screenshots, are in the guide.
In short, on Raspberry Pi OS with the desktop (set the hostname to skyscope
in Raspberry Pi Imager):
sudo apt update && sudo apt install -y python3-pygame git
git clone https://github.com/projectmoonpi/skyscope.git ~/skyscope
python3 ~/skyscope/skyscope.py
# start on boot
mkdir -p ~/.config/autostart
sed "s#/home/pi#$HOME#" ~/skyscope/skyscope.desktop > ~/.config/autostart/skyscope.desktopThen open http://skyscope.local:7700/radar_config from any device on your
network. Update later with cd ~/skyscope && git pull. If frames stutter on a
Pi 4, use filters or a shorter range, set the display to 1280×720, or lower
fps in settings.json.
The radar can also be drawn by a web browser at http://<address>:7700/radar.
It's drawn at the screen's full resolution, so it's crisp on Retina and
scaled laptop screens where the pygame window looks soft. It fits any window
size; on a phone or a tall window the panel moves under the scope. It uses
the same data, units, symbols and logos as the pygame display, and follows the
settings page.
- Phone (at the bottom) shows a QR code and the radar's address on your
network, to open it on a phone or tablet on the same Wi-Fi. On Windows, a
note under the code says when something keeps phones out: the network set
to Public, or SkyScope's firewall opening missing (
/api/connect). - Changes from other devices (Settings › General): phones, tablets and other computers can always look at the radar; View only (the default: no Settings button on them), With a PIN (Settings asks for it first, once per device; Cancel goes back to the radar) or Allowed decides whether they can also change settings, filters and the range. The computer running SkyScope can always change everything, and only it can change this choice or the PIN.
- Updates: SkyScope asks GitHub a few times a day for a newer release
(
updates.py; off with Check for a newer SkyScope in About). A note on the radar, the menu bar icon's menu (Mac), a notice and menu item from the icon by the clock (Windows, once per version) and About's Updates card say when there is one. Update to (on the computer running SkyScope) downloads it in the background, checks it's signed by Project Moon Pi (signing.py: Ed25519, against the key built into your copy; anything unsigned or changed is refused), then installs it with no questions, keeping your settings and install answers, and SkyScope restarts by itself. - Phones on or off: Settings › General › Phones, tablets and Satellites (on the computer running SkyScope only) lets other devices on your Wi-Fi open it, or keeps it to this computer. It takes effect at once; on Windows, turning it on may ask for an administrator's OK once (the firewall).
- Click a plane (its symbol or label) or a row in the table to select it: cyan brackets on the scope, its label outlined and always shown, its row highlighted, and the card shows its details as "SELECTED" instead of the nearest aircraft. Click it again, press Esc or the ✕ to clear. Hovering a table row briefly highlights that plane on the scope.
- Flight route on the card (General tab, Flight routes): e.g. KPHX →
KOAK · Phoenix → Oakland. ADS-B carries no flight plan, so without a key
routes of airline flights come from free community databases by flight
number (adsbdb.com, hexdb.io), shown only when they fit where the aircraft
is. With an optional FlightAware AeroAPI key (free Personal tier: about
$5 of lookups a month, $10 if you feed FlightAware), the card shows the
filed route of the aircraft on it, private IFR flights included; SkyScope
looks up only that aircraft, once per flight, within a daily limit. The key
stays in
settings.jsonand is never shown or sent to the browser. - Aircraft photo beside the card (switch it off under Display): only a photo of that exact aircraft, from Planespotters.net, credited; clicking it opens the original page. Aircraft without one show a plane outline and "No image available" in the same box. The Pi display shows it too.
- R (or Space): next range; clicking the radar never changes it. F: fullscreen.
- Scroll wheel or trackpad over the scope: up (or pinch out) for a shorter range, down (or pinch in) for a longer one (one range a step, stopping at the ends). Elsewhere the page scrolls as usual.
- ⚙ Filters (bottom of the panel) opens a panel to pick any combination of kinds of aircraft and altitude blocks, a preset, and the SIDs/STARs switch. It applies at once; the button shows what's being shown (e.g. "Airliners · 10,000 ft and below").
- The pointer hides after 3 s, for a TV or kiosk.
- To run only the browser display (no pygame window), e.g. on a laptop:
python3 skyscope.py --web-only # opens http://localhost:7700/radarThe pygame window and the browser display can run at the same time: any
device on the network can open /radar while the Pi drives the TV.
The easy way (Mac or Windows): download for Mac or for Windows (also on the latest release): one file. On a Mac, open the disk image and double-click Install SkyScope; on Windows, double-click the downloaded installer. It runs on Python 3.10 or newer from python.org; if the computer hasn't got it, the installer offers to download and install it (checking it's signed by the Python Software Foundation). The installer:
- installs SkyScope for you (Mac:
~/Library/Application Support/SkyScope; Windows:%LOCALAPPDATA%\Programs\Project Moon Pi\SkyScope, or a folder you choose, though not the Desktop, Documents, Downloads or OneDrive, where ransomware protection and OneDrive stop it saving its settings) with its own copy of pygame-ce (and pystray and Pillow for its icon), - asks whether phones and SkyScope Satellite displays on your Wi-Fi may open it (otherwise it listens to this computer only), whether it should start when you log in, and whether Start and Stop go on the Desktop,
- puts Start SkyScope, Stop SkyScope and Uninstall SkyScope in Applications › SkyScope (Mac). On Windows it puts Open SkyScope (opens the radar, starting SkyScope first if it isn't running), Start SkyScope Service and Stop SkyScope Service (they only start and stop it in the background) in the Start menu, and lists SkyScope in Settings › Apps, where it's uninstalled (Uninstall SkyScope is also in the install folder). Uninstalling removes your settings too; if you've added a FlightAware API key, it asks whether to delete that as well (keep it, and installing SkyScope again puts it back).
Is it running? On a Mac, while SkyScope runs in the background, its radar icon sits in the menu bar (black or white like the icons beside it; faint if SkyScope stops answering) and goes away when SkyScope stops. Click it for the radar, the settings or Stop SkyScope; its menu also shows the version, when it started and how many aircraft are in range. On Windows its radar icon is by the clock (under the ^ until you drag it onto the taskbar) and stays there: green while SkyScope runs, red when it's stopped. Click it for the radar; right-click it for Open the radar, Start SkyScope Service and Stop SkyScope Service. Activity Monitor and Task Manager list it as SkyScope.
Run the installer again to update or to change your answers (phones can also be switched on or off in Settings › General). When SkyScope is already installed it offers Update (compares the installed files with the new ones and copies only those that differ), Repair (checks every installed file and puts back any that are damaged or missing) or Reinstall from scratch (removes everything SkyScope put on the computer, its settings too, and installs it new; only your FlightAware key is kept). Update and Repair keep your settings, FlightAware key and logo cache. If macOS says it can't verify the developer: System Settings › Privacy & Security › Open Anyway; if Windows says it protected your PC: More info › Run anyway. Step by step: section 4 of the guide.
From the source (developers, or Linux): download SkyScope
(git clone https://github.com/projectmoonpi/skyscope.git), install pygame-ce
(python3 -m pip install pygame-ce, the drop-in community edition of pygame,
which has ready-made packages for the newest Python versions), and run it
from a terminal. sh tools/make_mac_app.sh (Mac) or
tools\windows\create-shortcut.bat (Windows) makes desktop icons for that copy.
python3 skyscope.py --web-only # radar in your browser (sharpest); py on Windows
python3 skyscope.py --window 1280x720 # or a pygame windowThen open http://localhost:7700/radar_config (settings) in a browser on the same computer and
click Use this computer's location. The browser asks permission and
fills in your position from the operating system's location service (on a
laptop, worked out from nearby Wi-Fi; usually within a few hundred metres).
A computer without Wi-Fi (a desktop on a network cable, or a virtual machine)
can only guess from its internet address, often just the middle of your
provider's city: then SkyScope fills the position in but doesn't save it,
and says to check it first.
On a Mac, Location Services must be on for your browser (System Settings →
Privacy & Security → Location Services). The button only appears on
localhost: browsers don't share location with plain-http pages on other
devices, so on a Pi use GPS or type the position in.
Sharpness on high-resolution laptop screens: pygame can't draw at Retina (Mac) or scaled-display (Windows) resolution, so the window is drawn at standard resolution and the OS enlarges it, which looks slightly soft. A Pi on an HDMI TV or monitor isn't affected: one drawn pixel is one screen pixel.
python3 tools/make_downloads.py writes dist/SkyScope-<version>-for-Mac.dmg (a disk
image: Install SkyScope.app with the program inside it, the guide and a READ ME FIRST note)
and dist/Install-SkyScope-<version>-for-Windows.exe (the installer with the program's
files added to its end, as NSIS and Inno Setup installers carry theirs;
installer/windows/src/Payload.cs unpacks them), named with the version, and points this
README's download links at them; only files tracked by git go in. It also writes
SkyScope-<version>-for-Mac.zip and -for-Windows.zip, for SkyScope 1.8.5's Update button,
which looks for zips. Attach all of them to the release.
The installers live in installer/ (mac/, windows/). On a Mac,
make_downloads.py builds Install SkyScope.app (an AppleScript app made with
osacompile, the program inside it), which opens the installer's window
(installer/mac/window.py, Tk, made like the M.O.S.S. SD Card Creator's; try it
with python3 installer/mac/window.py --dry-run, --uninstall --dry-run); its work
is install.sh / uninstall.sh. On Windows, the installer is a compiled C#
program with no PowerShell anywhere (antivirus programs such as Bitdefender
block a hidden PowerShell that downloads, compiles and asks for admin rights as
malware): installer/windows/src/*.cs, built three times, by
installer/windows/build.sh on a Mac with Mono (against .NET Framework 4.8's
reference assemblies) or build.ps1 on Windows, into Install SkyScope.exe,
Uninstall SkyScope.exe and SkyScope.exe (one program; what it does goes
by its name). SkyScope.exe is Start (--no-browser), Stop (--stop) and
SkyScope's own process while it runs (--run, Python hidden beneath it, so Task
Manager shows SkyScope); the firewall change runs the same program with admin
rights (--firewall). Commit the rebuilt .exe files. The icons are in
tools/launcher/ (make_icon.py --start / --stop). For unattended test
installs, answer the questions ahead: SS_PHONES=yes|no, SS_AUTOSTART=yes|no,
SS_OPEN=no, SS_PYTHON=yes|no (install Python if it's missing; and
SS_UNATTENDED=1 for the uninstaller). The Python they install is pinned
(PY_VERSION in installer/mac/get_python.sh, PyVersion in
installer/windows/src/App.cs): move it on once pygame-ce, Pillow and PyObjC
have packages for a newer one. The menu bar / taskbar icon is tray.py,
started by skyscope.py --web-only --tray.
python3 skyscope.py --window 1280x720
python3 skyscope.py --window 1920x1080 --screenshot out.png --seconds 8Both displays open with the Project Moon Pi start-up screen, the same as the
train tracker's and the M.O.S.S. dash's: the badge with its light show (a lens
flare along the red swoosh bursting at its tip, twinkling stars, flickering
lander flames and a metal sheen), SKYSCOPE and "Designed and Created by
Project Moon Pi", while the first aircraft load. On the Pi display it lasts
about four seconds (any key or click skips it; --no-splash leaves it out and
--screenshot always does). In the browser it shows once per tab, until the
radar has its first data and the show has played (a click skips it), and
still for anyone with reduced motion turned on.
Runways are drawn like an ATC video map: true length (and true width when zoomed in), extended centrelines 10 nm out from each end of runways 5,000 ft and longer with a tick every nautical mile (longer every 5), runway numbers at the thresholds when zoomed in, and the code of every airport shown, at any range (biggest airports and longest runways first; a code that would overlap another is left off, so crowded areas keep the busier fields). On the settings page's Map tab: Airports shown: Major, Regional and Small (paved), each on or off, and Extended centrelines on/off.
Airspace (US): Class B, C and D outlines from the FAA's Class Airspace
data, in chart colours (B solid blue, C solid magenta, D dashed blue), with
each shelf's ceiling/floor in hundreds of feet (e.g. 90/30) when zoomed in.
SIDs and STARs (US): on the settings page's Map tab, every airport with published procedures within reach of the scope is listed (largest first, small fields included), each with its own SIDs and STARs tick boxes and counts; Add another airport searches the rest. Show is an overall switch on top: As ticked below / SIDs only / STARs only / None (also in the radar page's Filters panel). Departures are drawn teal, arrivals amber, as dashed routes with named fixes (△) and the procedure name. The settings page says how many each airport has. Data: FAA CIFP; legs flown on a heading ("then vectors") have no fixed track, so a route starts or ends where vectoring takes over. Not for navigation.
Map labels (fixes, shelves, airport codes) avoid each other; aircraft labels are drawn over the map.
Centre on an airport: in the Location card (Manual source), search by
ICAO or IATA code or by name (KDVT, PHX, Heathrow) and pick a result;
the scope centres on it and the panel shows its name.
The data comes from OurAirports (public
domain): data/airports.json (about 9,700 airports with 12,000 runways) and
data/airport_index.json (about 48,000 airports for the search). Small
airfields are included when they have a paved runway of 2,000 ft or more with
a known position. To refresh:
python3 tools/build_airports.py # airports and runways (OurAirports)
python3 tools/build_airspace.py # US Class B/C/D (FAA)
python3 tools/build_procedures.py # US SIDs/STARs (FAA CIFP, new cycle every 28 days)Logos are airlines' trademarks, so none are stored in this repo. The first time
an airline appears, its logo is downloaded from the
Jxck-S/airline-logos collection into
logos_cache/ and reused from then on (airlines with no logo are remembered in
logos_cache/missing.txt). To use your own artwork, put a PNG named after the
ICAO airline code in logos/ (e.g. logos/KLM.png); it takes priority.
Logos sit on a light tile so dark logos stay readable on the dark screen.
Both run on a 4.3″ ESP32-S3 touch display (Sunton ESP32-8048S043, 800×480):
- SkyScope Satellite: a
second screen for this SkyScope. It reads
/api/satelliteand shows the same radar, range, filters and map. Point it atskyscope.local(name the Piskyscope) or at the address on the settings page's About tab. - SkyScope Mini: a small standalone radar that fetches adsb.fi itself; no Pi needed.
SkyScope grew out of ESP32-Plane-Radar by MatixYo (MIT licence), a radar for a 1.28″ round display on an ESP32; its scope design, range presets and colours were the starting point.
| Data | Source | Terms |
|---|---|---|
| Live aircraft | adsb.fi open data API, or your own readsb/dump1090 receiver | adsb.fi's API terms (public limit 1 request/s) |
| Airports, runways, airport search | OurAirports | Public domain |
| Class B/C/D airspace (US) | FAA Class Airspace open data | Public domain |
| SIDs and STARs (US) | FAA CIFP (Coded Instrument Flight Procedures) | Public domain |
| Country from ICAO address | ICAO Annex 10 Vol III allocation table (via tar1090) | Facts |
| Airline logos | Downloaded at run time from Jxck-S/airline-logos; not stored in this repo | Airlines' trademarks |
| Aircraft photos | Planespotters.net photo API, exact aircraft only; shown from their servers, never stored | Photographers' copyright; shown with credit and link, per Planespotters' API terms |
| Flight routes | adsbdb.com and hexdb.io callsign APIs: the published route of an airline flight number, shown only when it fits the aircraft's position | Free community data |
| Filed flight routes (optional) | FlightAware AeroAPI, with your own key | FlightAware's AeroAPI terms |
| Ground elevation | Open-Meteo elevation API (Copernicus DEM GLO-90), looked up once per place | CC BY 4.0 |
| Software | Source | Licence |
|---|---|---|
| Language and display | Python and pygame / pygame-ce | PSF; LGPL 2.1 |
| Mac menu bar icon (installed copies) | pystray, Pillow, and on a Mac PyObjC | LGPL 3; MIT-CMU; MIT |
| Secure connections (installed copies) | truststore by Seth Larson: HTTPS checked with the computer's own certificates | MIT |
| QR codes for phones | QR Code Generator for JavaScript by Kazuhiko Arase (web/qrcode.js, 1.4.4) |
MIT |
| Windows installer | C# on Microsoft's .NET Framework 4.8 (Windows Forms), built with Mono's C# compiler (Roslyn) | .NET Framework: part of Windows; Mono and Roslyn: MIT |
| Signed updates | Signatures made with OpenSSH's ssh-keygen -Y sign; checked by signing.py, an Ed25519 check written from RFC 8032 |
BSD (OpenSSH) |
| Built with | Claude Code (Anthropic): designed, written and tested with Claude |
Not for navigation. Map layers are approximations for watching traffic; procedure routes skip legs flown on a heading, and arcs are drawn as chords.
Common questions are answered on projectmoonpi.com/support. For anything else, email support@projectmoonpi.com: say which computer SkyScope runs on (Mac, Windows or Raspberry Pi), its version (Settings › About) and what you saw. SkyScope's page is projectmoonpi.com/skyscope. For anything else (business, partnerships, the press), write to sales@projectmoonpi.com.
MIT; see LICENSE.

