SatsDecoder: Decode Satellite Signals Without Expensive Hardware

SatsDecoder: Decode Satellite Signals Without Expensive Hardware

What if I told you that right now, hundreds of satellites are screaming data into the void—and you can actually hear them? Not with million-dollar ground stations. Not with NASA-level budgets. With a laptop, some free software, and a little-known tool that the satellite-hunting underground doesn't want you to know about.

Here's the painful truth most developers discover too late: satellite communication feels like an exclusive club. The hardware costs thousands. The protocols are buried in obscure PDFs written in Russian. The software? Either proprietary black boxes or abandoned GitHub repos from 2014. You've probably stared at waterfall displays, wondering why your SDR dongle is just collecting dust while others post stunning satellite images on Reddit.

Enter SatsDecoder.

This unassuming open-source project is quietly demolishing every barrier between you and actual satellite data. We're talking real images from real spacecraft. Telemetry streams that tell you temperature, power status, orientation—straight from orbit to your screen. No PhD required. No ham radio license (though it helps). Just pure, decoded satellite goodness flowing into your machine.

The satellite decoding community has been gatekeeping this for years. That ends now.

What Is SatsDecoder?

SatsDecoder is a specialized image and telemetry decoder built for amateur satellites, with particular focus on the Geoscan and Sputnix platforms. Created by developer baskiton and released under GPL-3.0-or-later licensing, this Python^{↗ Bright Coding Blog}-based application transforms raw radio signals into human-readable satellite data and actual images from space.

The project emerged from the vibrant amateur satellite community, particularly connecting with Russian and European satellite programs that actively encourage public participation. Geoscan satellites—part of a growing constellation of educational and research spacecraft—transmit imagery and telemetry on amateur radio frequencies. Sputnix, another major platform, uses its Unified SPUTNIX Protocol (USP) for similar purposes. These aren't theoretical exercises; they're operational satellites passing overhead multiple times daily, broadcasting data that anyone with the right tools can capture.

Why is SatsDecoder trending now? Three converging forces: the explosion of CubeSat launches (over 1,800 launched as of 2024), the plummeting cost of Software Defined Radios (SDRs like the RTL-SDR v3 dropping below $30), and a resurgence of interest in space accessibility following high-profile amateur achievements. The repository shows healthy download metrics and active maintenance, with dual-language documentation (English and Russian) reflecting its international user base.

Unlike generic SDR tools that leave you drowning in raw IQ samples, SatsDecoder speaks the actual protocols these satellites use. It's the difference between hearing static and understanding a conversation.

Key Features That Make SatsDecoder Essential

Multi-Protocol Satellite Support SatsDecoder doesn't just handle one satellite type—it decodes 17 distinct protocols currently, with more added as new satellites launch. From the widely-used AX.25 packet radio standard to specialized formats like CSP (Cubesat Space Protocol), GreenCube, Ledsat, and Lucky-7, the tool covers the amateur satellite spectrum comprehensively. Each protocol implementation includes proper frame parsing, checksum validation, and payload extraction.

Flexible Data Source Architecture The application accepts input through six different pathways: direct AGWPE client connections to soundmodems (the standard approach), HEX string decoding for captured data, file-based HEX processing, TCP client/server sockets for networked setups, JSON file ingestion with structured metadata support, and KISS file reading for packet radio enthusiasts. For SatDump users, direct .frm file reading is available for AX.25 and Geoscan protocols.

Real-Time Image Reconstruction Perhaps the most visually satisfying feature: SatsDecoder assembles satellite image transmissions in real-time. The Merge mode allows continuous image building across multiple passes, while New Image forcing enables manual segmentation. Output directories are fully configurable, and the tool handles the complex task of packet ordering and missing frame interpolation.

Cross-Platform Python Foundation Built on Python 3.7+ with minimal dependencies, SatsDecoder runs anywhere Python does. The tkinter-based GUI provides immediate usability, while the underlying architecture supports headless operation for automated ground stations. Build options include both PyInstaller and Nuitka compilation for distributable binaries.

Active Telemetry Parsing Beyond images, SatsDecoder extracts structured telemetry data—voltage readings, temperature sensors, solar panel efficiency, attitude information—presenting it in human-readable formats rather than raw byte dumps.

Real-World Use Cases Where SatsDecoder Dominates

Educational Ground Stations

Universities and high schools building CubeSat tracking labs face a critical gap: they can receive signals, but cannot interpret them. SatsDecoder bridges this gap, letting students see immediate results from their antenna setups. The JSON file support enables integration with automated logging systems for long-term analysis projects.

Amateur Radio Satellite Hunting

The thriving AMSAT community constantly seeks new satellites to track. When a fresh CubeSat deploys from the ISS, SatsDecoder often adds support before commercial solutions. The RAW data mode allows experimentation with undocumented or partially-reversed protocols, giving serious hunters an edge.

Remote Sensing on a Budget

Environmental monitoring groups use SatsDecoder with cheap SDR hardware to capture Geoscan imagery for vegetation analysis, weather pattern observation, and disaster assessment. At under $50 total hardware cost, this democratizes satellite imagery access previously requiring Landsat or Sentinel subscriptions.

SatDump Integration Workflows

Users of the popular SatDump satellite processing suite leverage SatsDecoder's .frm file reading capability for specialized amateur satellites that SatDump doesn't natively support. This creates a two-tool pipeline: SatDump for acquisition and initial processing, SatsDecoder for protocol-specific decoding.

Automated Monitoring Stations

The TCP server mode with structured header support enables 24/7 unattended operation. Radio enthusiasts deploy Raspberry Pi-based stations that feed decoded data directly into SatsDecoder, with results archived automatically. The timestamp preservation ensures accurate orbital tracking correlation.

Step-by-Step Installation & Setup Guide

Prerequisites

Before touching SatsDecoder, you need a functioning soundmodem setup. This is non-negotiable—SatsDecoder doesn't directly interface with your SDR; it receives demodulated data from soundmodem software.

Download the appropriate soundmodem for your target satellites:

Configure soundmodem following the R4UAB guide, noting your AGWPE server port for SatsDecoder connection.

Installing SatsDecoder from Source

Step 1: Clone the repository and prepare environment

# Clone the repository
git clone https://github.com/baskiton/SatsDecoder.git
cd SatsDecoder

# Create virtual environment (strongly recommended)
python -m venv venv

# Activate it
# On Linux/macOS:
source venv/bin/activate
# On Windows:
venv\Scripts\activate

Step 2: Install dependencies

# Install required Python packages
pip install -r requirements.txt

Step 3: Launch the application

# Run as Python module
python -m SatsDecoder

Building Standalone Executables

Option A: PyInstaller (simpler, larger files)

# Install PyInstaller
pip install pyinstaller

# Build executable
pyinstaller -y decoder.spec

# Find your build in dist/ directory

Option B: Nuitka (complex, optimized, smaller)

# Install Nuitka
pip install nuitka

# Build with full optimization flags
python -m nuitka --python-flag=-m --onefile --standalone \
    --assume-yes-for-downloads --output-dir=dist --script-name=SatsDecoder \
    --enable-plugins=tk-inter --windows-icon-from-ico=res/icon.png \
    --include-data-dir=res=res --noinclude-data-files=res/*.txt

Initial Configuration

1. Launch SatsDecoder and select your target protocol tab (GEOSCAN, USP, etc.)
2. Set Output Directory via Out Dir — this is where decoded images and telemetry files appear
3. Configure Connection: Set Server to your soundmodem's IP (typically localhost) and Port to match AGWPE settings (check File → Devices → AGWPE Server Port in soundmodem)
4. Enable Merge mode if you want continuous image assembly across multiple satellite passes
5. Click Connect and start playing your FM-demodulated satellite signal

REAL Code Examples from SatsDecoder

Let's examine actual implementation patterns from the SatsDecoder repository, showing how this tool handles real satellite data formats.

Example 1: TCP Data Source Header Structure

When using TCP client or server modes, SatsDecoder expects a specific binary header before payload data. This ensures proper framing and timestamp correlation:

// Standard C structure for TCP data source headers
struct header {
    int64_t t;     // unix timestamp, seconds (-1 if not available)
    uint32_t len;  // length of following data payload in bytes
};

Critical implementation detail: Byte order is Network (big-endian). This is standard practice for cross-platform binary protocols but easy to overlook. The int64_t t field allows millisecond-precision timing when negative values aren't used, enabling precise orbital position correlation. The -1 sentinel value gracefully handles cases where the data provider cannot generate timestamps.

Why this matters: Satellite passes last only 10-15 minutes. Accurate timestamps let you reconstruct when each packet arrived, correlating with orbital elements to determine satellite position during transmission. This transforms raw data into geospatially meaningful information.

Example 2: JSON File Data Format

SatsDecoder accepts structured JSON files for batch processing or integration with external logging systems. The schema is deliberately flexible:

{
    "001": {
        "raw": "DEADBEEF",
        "datetime": "2026-01-09T13:52:05"
    },
    "002": {
        "data": "1337A55A",
        "unixtime": "1767966804"
    },
    "003": {
        "data": "ABBA",
        "unixtimemill": 1767966804898
    },
    "004": {
        "raw": "EA51"
    }
}

Key schema requirements: Each top-level key must be unique (shown as "001", "002", etc.). The payload requires either "raw" or "data" containing hex strings—both keys are treated identically, providing backward compatibility. Timestamps are optional but highly recommended, with three supported formats:

• "unixtime": seconds since epoch (string or number)
• "unixtimemill": milliseconds since epoch (string or number)
• "datetime": ISO 8601 format string (YYYY-MM-DDTHH:MM:SS)

Practical implementation pattern: Log your SDR's output to this JSON format during satellite passes, then batch-process through SatsDecoder for comprehensive decoding. The flexibility in timestamp formats accommodates various logging tools without preprocessing.

Example 3: Running from Source (Development/Extension)

For developers extending SatsDecoder or debugging protocol implementations:

# Standard Python module execution
python -m SatsDecoder

This invocation pattern is crucial—it ensures proper package resolution for relative imports within the SatsDecoder namespace. The __main__.py entry point handles GUI initialization, protocol registration, and connection management.

Development tip: When adding new protocols, examine existing implementations in the protocols directory. The modular architecture allows dropping in new decoder classes that automatically register in the GUI tab system. PEP-8 compliance is enforced for contributions, maintaining code readability across international contributors.

Example 4: Nuitka Build with Full Options

For distribution to non-technical users, the Nuitka build provides single-file executables:

python -m nuitka --python-flag=-m --onefile --standalone \
    --assume-yes-for-downloads --output-dir=dist --script-name=SatsDecoder \
    --enable-plugins=tk-inter --windows-icon-from-ico=res/icon.png \
    --include-data-dir=res=res --noinclude-data-files=res/*.txt

Flag breakdown for optimization:

• --onefile --standalone: Creates portable executable with embedded Python runtime
• --enable-plugins=tk-inter: Critical for GUI functionality—without this, the tkinter interface fails
• --windows-icon-from-ico=res/icon.png: Professional presentation for Windows builds
• --include-data-dir=res=res: Bundles resource files (icons, configs) maintaining directory structure
• --noinclude-data-files=res/*.txt: Excludes development text files from production build

This build process demonstrates mature Python deployment practices, producing executables that run without Python installation—essential for the radio amateur community's diverse technical backgrounds.

Advanced Usage & Best Practices

Automated Pass Capture: Combine SatsDecoder with satellite tracking software like GPredict or Orbitron. Trigger recordings when satellites rise above horizon, feed through soundmodem automatically, and let SatsDecoder's merge mode assemble complete images across marginal signal periods.

Multi-Satellite Monitoring: Run multiple SatsDecoder instances on different ports, each configured for a different protocol. A single antenna and SDR setup can monitor several satellites simultaneously during busy launch periods.

Signal Quality Optimization: The New Image button isn't just for manual control—use it when signal degradation causes image corruption. Force a fresh start rather than contaminating good data with unrecoverable frames.

Custom Data Pipelines: The TCP server mode with structured headers enables creative integrations. Feed SatsDecoder from GNU Radio flowgraphs, custom demodulators, or networked SDR servers like rtl_tcp. The JSON output format supports downstream analysis in Python, MATLAB, or specialized satellite tracking software.

Version Management: Check F1 for update notifications. The active development on dev branch means frequent improvements—contribute protocol additions or bug fixes following the branch strategy: always branch from dev, PR back to dev.

SatsDecoder vs. Alternatives: The Honest Comparison

The verdict: SatDump excels at direct SDR integration and professional satellite reception. Universal Radio Hacker dominates signal analysis and reverse engineering. But for purpose-built amateur satellite decoding with minimal friction, SatsDecoder occupies a unique niche. The soundmodem dependency is actually a feature—it decouples demodulation from decoding, letting you optimize each stage independently and swap SDR hardware without touching your decoding pipeline.

FAQ: Your Burning Questions Answered

Do I need a ham radio license to use SatsDecoder? Receiving satellite transmissions on amateur frequencies is generally legal without a license in most jurisdictions (check your local regulations). Transmitting requires licensing. SatsDecoder is receive-only.

What hardware do I actually need to get started? Minimum viable: RTL-SDR v3 dongle (~$25), simple antenna (dipole or QFH), laptop running soundmodem + SatsDecoder. Total under $50. Better results come from LNA, better antennas, and outdoor mounting.

Why does SatsDecoder need soundmodem instead of connecting directly to my SDR? This architectural separation allows protocol-agnostic SDR usage. Soundmodem handles the physical layer (FM demodulation, FSK/GMSK decoding), while SatsDecoder handles the application layer (packet parsing, image reconstruction). Swap SDRs or modulation types without changing your decoding workflow.

Can I decode satellites not listed in the protocols? The RAW mode captures any data, but you'll need to implement parsing yourself. For documented protocols, contribute implementations back to the project—the MIT licensing for contributions keeps the ecosystem growing.

How do I know when satellites are overhead? Use orbital prediction software: GPredict (free, cross-platform), Orbitron (Windows), or web-based tools like N2YO.com. Most amateur satellites have published two-line elements (TLEs) updated regularly.

Why are some protocol documents in Russian? Many supported satellites (Geoscan, Sputnix platforms, several university projects) originate from Russian institutions. The SatsDecoder community actively translates and verifies these specifications. Dual-language README support reflects this international collaboration.

Is Windows supported? Yes—Python and tkinter run natively on Windows. The Nuitka build instructions specifically include Windows icon compilation. Most users report easiest setup on Windows 10/11 with pre-built soundmodem binaries.

Conclusion: Your Satellite Data Journey Starts Now

SatsDecoder represents something rare in the satellite world: genuine accessibility without compromise. It doesn't abstract away the technical beauty of satellite communication—it makes that beauty reachable. Every decoded image is a photograph taken from orbit, transmitted through the void, captured by your equipment, and reassembled by your software. That's not just data processing; that's participation in humanity's space presence.

The tool's strength lies in its focused scope. It doesn't try to be everything for everyone. It does one thing—decode amateur satellite protocols—exceptionally well, with clean architecture that invites contribution and extension.

The satellite decoding community has been small because the barriers were high. Projects like SatsDecoder are systematically dismantling those barriers. The next decoded image could come from your station. The next protocol addition could be your contribution. The next satellite launch could be the one you track from first beacon to final frame.

Stop watching others post satellite images. Start capturing your own.

👉 Get SatsDecoder on GitHub — clone it, build it, point your antenna skyward, and join the orbital data revolution.

The satellites are calling. Will you answer?