What the URSALA, RAQUEL, and FARRAH Satellite Programs Actually Reveal About Modern SIGINT Engineering

The Problem & Industry Shift

For most of the last two decades, space-based signals intelligence (SIGINT) followed a simple, expensive pattern: launch a small number of large, exquisite satellites, downlink raw RF to a handful of ground stations, and do the heavy processing on the ground. That model is now collapsing under three pressures.

Downlink bandwidth is the bottleneck, not the sensor. A wideband RF collector can generate tens of Gbps of raw IQ data. Getting that to the ground over a constrained X-band or Ka-band link is often the hardest part of the mission.
Latency matters more than it used to. Tactical users want geolocation and emitter classification in minutes, not days. A store-and-forward pipeline that waits for a ground station pass is structurally too slow.
Constellations beat monoliths. Distributed smallsats give persistent coverage and graceful degradation, but they multiply the coordination problem.

The 2025 reporting around the URSALA, RAQUEL, and FARRAH programs (publicly discussed in open-source reporting and budget documents, with much of the detail still classified) is interesting precisely because it maps onto this shift. These are not single satellites; they are program families associated with distributed, on-orbit-processed RF collection. Treat the specific orbital and payload parameters as unverified, but the engineering patterns they imply are well understood and worth studying.

Caveat up front: The exact capabilities of URSALA, RAQUEL, and FARRAH are not public. This article does not claim to know them. It uses the public framing of these programs as a hook to explain the real, documented engineering techniques that any modern space-based SIGINT system must use.

Architecture & Core Mechanics

A modern distributed RF-sensing constellation looks roughly like this:

        SPACE SEGMENT                         GROUND SEGMENT
  +---------------------+              +--------------------------+
  |  Sensor Sat (x N)   |              |   Ground Station (x M)   |
  |  -----------------  |   X/Ka band  |   ---------------------  |
  |  Wideband RF front  |  downlink    |   Demod / decode         |
  |  ADC -> FPGA        | -----------> |   Cross-cue fusion       |
  |  On-orbit detect    |              |   Emitter geolocation    |
  |  Feature extract    |              |   Tasking uplink         |
  +----------+----------+              +------------+-------------+
             |                                      |
             |  Inter-satellite link (optical/RF)   |
             +--------------------------------------+
             |                                      |
             v                                      v
     +----------------+                    +------------------+
     | Edge inference |                    |  Data lake /     |
     | (FPGA/ASIC)    |                    |  analytics tier  |
     +----------------+                    +------------------+

The core mechanics break into four layers:

1. Wideband RF front end. The antenna and receiver define the observable spectrum. Wide instantaneous bandwidth (hundreds of MHz to GHz) is the differentiator, but it directly drives ADC sample rate, thermal load, and power budget. On a smallsat, power is the binding constraint.

2. On-orbit processing. Instead of downlinking raw IQ, the satellite runs detection and feature extraction in FPGAs or radiation-tolerant SoCs. The output is a product — energy detections, pulse descriptors, coarse angle-of-arrival — not a firehose. This is the single biggest architectural change and the reason constellations are viable at all.

3. Inter-satellite coordination. Geolocation by time-difference-of-arrival (TDOA) or frequency-difference-of-arrival (FDOA) requires simultaneous observations from multiple platforms with synchronized clocks. That means precision time transfer (often via GNSS-disciplined oscillators) and a mesh or star inter-satellite link.

4. Ground fusion. The ground segment correlates detections across satellites and passes, resolves ambiguities, and produces the final emitter track. This is a distributed-systems problem as much as a DSP problem: clock skew, partial observations, and out-of-order arrival all matter.

Production Code Example

The interesting engineering problem is the on-orbit detection pipeline: you must reduce a high-rate sample stream to a low-rate product under severe compute and power constraints. Below is a realistic, runnable Python model of the ground-side fusion step — correlating detections from multiple satellites to estimate emitter position via TDOA. This is the kind of code that actually runs in a ground segment, and it demonstrates the numerical care required.

"""
TDOA geolocation fusion across a satellite constellation.

Models the ground-segment step: given time-of-arrival (TOA) measurements
from N satellites for a single emitter pulse, estimate the emitter's
position on the WGS-84 ellipsoid.

Key engineering decisions are annotated inline.
"""

from __future__ import annotations

import numpy as np
from dataclasses import dataclass
from scipy.optimize import least_squares

C = 299_792_458.0  # speed of light, m/s


@dataclass(frozen=True)
class Observation:
    """One satellite's measurement of a single pulse."""
    sat_ecef: np.ndarray   # satellite position, ECEF meters
    toa: float             # time of arrival, seconds (common time base)
    toa_sigma: float       # 1-sigma timing uncertainty, seconds


def _range(sat_ecef: np.ndarray, emitter_ecef: np.ndarray) -> float:
    return float(np.linalg.norm(sat_ecef - emitter_ecef))


def _residuals(
    emitter_guess: np.ndarray,
    obs: list[Observation],
    ref_index: int,
) -> np.ndarray:
    """
    TDOA residuals relative to a reference satellite.

    We do NOT fit absolute TOA: the emitter's transmit time is unknown.
    Only *differences* of TOA are observable, which is why TDOA needs
    at least 3 satellites for a 2D fix (and 4 for 3D + clock bias).
    """
    ref = obs[ref_index]
    ref_range = _range(ref.sat_ecef, emitter_guess)
    out = []
    for i, o in enumerate(obs):
        if i == ref_index:
            continue
        # Predicted TDOA = (range_i - range_ref) / c
        predicted = (_range(o.sat_ecef, emitter_guess) - ref_range) / C
        measured = o.toa - ref.toa
        # Weight by combined timing uncertainty (inverse-variance weighting).
        sigma = float(np.hypot(o.toa_sigma, ref.toa_sigma))
        out.append((measured - predicted) / sigma)
    return np.asarray(out)


def geolocate(
    obs: list[Observation],
    initial_guess: np.ndarray,
    ref_index: int = 0,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Returns (emitter_ecef, covariance).

    Uses Levenberg-Marquardt via scipy.least_squares. The Jacobian is
    computed numerically here for clarity; in production you would supply
    an analytic Jacobian to cut solve time by ~3-5x.
    """
    if len(obs) < 4:
        raise ValueError("Need >=4 observations for a 3D fix with clock bias")

    result = least_squares(
        _residuals,
        x0=initial_guess,
        args=(obs, ref_index),
        method="lm",
        xtol=1e-6,
        ftol=1e-6,
    )

    # Covariance from the Gauss-Newton approximation: (J^T J)^-1 * s^2
    J = result.jac
    dof = max(1, J.shape[0] - J.shape[1])
    s2 = 2.0 * result.cost / dof
    cov = np.linalg.inv(J.T @ J) * s2
    return result.x, cov


if __name__ == "__main__":
    # Toy geometry: 4 satellites, emitter near the surface.
    rng = np.random.default_rng(42)
    emitter_true = np.array([4_000_000.0, 3_000_000.0, 3_500_000.0])

    sats = np.array([
        [7_000_000.0, 0.0, 0.0],
        [0.0, 7_000_000.0, 0.0],
        [0.0, 0.0, 7_000_000.0],
        [-5_000_000.0, -5_000_000.0, 4_000_000.0],
    ])

    obs = []
    for s in sats:
        true_toa = _range(s, emitter_true) / C
        noisy = true_toa + rng.normal(0.0, 1e-9)  # 1 ns timing noise
        obs.append(Observation(sat_ecef=s, toa=noisy, toa_sigma=1e-9))

    est, cov = geolocate(obs, initial_guess=emitter_true + 1000.0)
    err = np.linalg.norm(est - emitter_true)
    print(f"position error: {err:,.1f} m")
    print(f"1-sigma per-axis: {np.sqrt(np.diag(cov))}")

Three things this snippet makes concrete:

You cannot fit absolute TOA. The emitter's transmit time is unknown, so only differences are observable. This is why TDOA needs one more satellite than you might naively expect.
Weighting is not optional. Inverse-variance weighting by per-observation timing uncertainty is what separates a usable fix from garbage when one satellite has a noisy clock.
Geometry dominates accuracy. The covariance matrix is driven by the spread of satellite positions. A tight cluster of satellites gives a poorly conditioned J^T J and a huge error ellipse, no matter how good your timing is.

Performance, Cost & Trade-offs

Design choice	Benefit	Cost
On-orbit FPGA processing	10-100x downlink reduction; low latency	Radiation tolerance, limited dev velocity, harder to patch
Wideband RF front end	Captures more emitters per pass	ADC power, thermal, data rate
Large constellation	Persistent coverage, TDOA geometry	Launch cost, coordination, ground-station load
Optical inter-sat links	High bandwidth, hard to intercept	Pointing accuracy, acquisition time
Ground fusion	Best compute, easy to update	Latency, downlink dependency

Latency vs. accuracy. On-orbit detection trades classification accuracy for speed. A lightweight FPGA model may miss low-SNR emitters that a ground-side deep model would catch. The standard mitigation is a two-tier design: coarse on-orbit detection triggers a targeted high-fidelity downlink of the raw IQ window around the detection, rather than the whole band.

Timing is the whole ballgame. TDOA accuracy scales linearly with timing error. A 1 ns timing error corresponds to roughly 30 cm of range error, but geometry amplifies that into hundreds of meters of position error. This is why GNSS-disciplined oscillators and precise inter-satellite time transfer are non-negotiable.

Security considerations. Ground segments are high-value targets. Standard practice includes:

End-to-end encryption of tasking uplinks and product downlinks, with keys rotated per pass.
Air-gapped or strictly segmented processing tiers; no direct path from the analytics tier to the tasking uplink.
Signed software/firmware images for on-orbit reconfiguration, with rollback to a known-good image.
Strict provenance on every detection record so a compromised feed cannot silently poison the fusion layer.

Cost reality. The economics have flipped. A single exquisite satellite can cost billions; a distributed constellation of smallsats can be an order of magnitude cheaper per unit of coverage, but the ground segment and software become the dominant cost. The hard part is no longer the spacecraft — it is the pipeline that turns detections into decisions.

Actionable Checklist / Summary

If you are building anything in this space — or just want to apply the patterns — here is what to do:

Push processing toward the edge. Decide explicitly what runs on-orbit vs. on the ground, and design the downlink product accordingly. Raw IQ is almost never the right answer.
Treat time as a first-class subsystem. Budget for GNSS-disciplined clocks, inter-satellite time transfer, and per-observation timing uncertainty in your data model.
Weight your measurements. Never fuse unweighted observations. Carry a per-observation sigma from the sensor all the way to the estimator.
Model your geometry. Before you launch, simulate the covariance of your TDOA/GDOP for realistic orbits. Bad geometry cannot be fixed in software.
Design for partial failure. A constellation must degrade gracefully. Your fusion layer should produce a usable (if coarser) fix with N-1 satellites.
Secure the ground segment first. It is the softest and most valuable target. Encrypt, segment, sign, and log everything.
Keep the software updatable. On-orbit FPGA/SoC logic is hard to change; keep the ground-side fusion layer modular and versioned so you can improve accuracy without a launch.

Bottom line: The specific capabilities of URSALA, RAQUEL, and FARRAH are not public, and this article does not claim otherwise. What is public and well-documented is the engineering playbook that any 2025-era distributed RF-sensing constellation must follow: on-orbit processing, precision timing, weighted multi-satellite fusion, and a hardened ground segment. Those are the transferable lessons, and they apply far beyond defense — to any distributed sensing system you build.

The Problem & Industry Shift

Architecture & Core Mechanics

Production Code Example

Performance, Cost & Trade-offs

Actionable Checklist / Summary

References