OMEGA.

Why OMEGA Exists.

Live ocean data is scarce. The instruments that gather it (official scientific moorings) are expensive, so there are very few of them. For most stretches of coast there is no real-time measurement at all: if you want to know what the water is doing at your harbor, reef, or research site, you usually get a forecast model's guess instead of a reading.

OMEGA changes who gets to measure the ocean. A research lab, a harbor, a school, or a sailing community can put their own sensors in the water (readings like water temperature, air pressure, and position) and watch their own patch of sea live: when the temperature spikes, when the swell turns, when a storm arrives. The system also pulls in the official public feeds (NOAA buoys, tide gauges, ocean models), so your hardware and the government's appear side by side on the same map.

And because every reading is cryptographically signed and the network is an open federation anyone can join, what one operator measures can be shared with (and trusted by) everyone else. Many affordable, verifiable eyes on the ocean, instead of a few expensive ones.

Three Things It Has Actually Done.

Start with results. All three came out of this system's own hardware and pipeline, and each one is written up in full on the pages that follow.

A Reading Means the Same Thing, However It Arrives.

A reading should mean the same thing no matter how it reached you: by radio, by cable, or over the internet. Everything else hangs on that. In the program's words, "the standard is the protocol, not the box." The data's meaning (its envelope) is kept separate from the exact format it happens to travel in (its wire form).

That single decision is what makes OMEGA open: an 8-channel radio receiver, a sailboat's SignalK navigation feed, and The Things Network all joined the mesh with zero protocol changes; they feed the same ingest contract, and boats and third-party networks become first-class OMEGA stations. The envelope standardizes identity, time, location, and payload, while the format shifts to fit each link: a dense 84-byte packet over radio, plain JSON over the internet, other formats for specialized receivers.

What Layer Four Looks Like.

The Journey, End to End.

What Actually Made This Difficult.

The architecture above reads clean. Getting there wasn't. These are the fights that shaped the design: each one a real problem, hit in practice, with the fix that shipped.

Only Real Measurements, Each One Signed.

An ocean instrument is only scientifically useful if you can always tell a measurement from a forecast. OMEGA enforces an "Absolute Data Purity" rule: the live map shows only real, deployed hardware and real measurements. Missing data renders as an honest gap, never quietly filled in with a forecast. Each measurement is cryptographically signed at the source, a tamper-proof seal that travels with the data and marks it as genuine.

An Open, Multi-Operator Network.

OMEGA runs as an open network of independently-run gateways. Identity is rooted in cryptography, and joining is zero-config: a gateway mints its own key, and that key is its credential.

Why Python over Go or Rust?

For a telemetry gateway handling raw binary bytes, compiled languages like Rust or Go look like the obvious choice. OMEGA runs on Python anyway, and the reason is who uses it.

Why SQLite over PostgreSQL?

Conventional wisdom says a serious backend needs a "real" database server running in its own container. OMEGA deliberately uses a single SQLite file, which at sea is the safer bet.

The Constraint: the gateway often runs on a Raspberry-Pi-class board on a pitching vessel, where waves over the solar panel can cut power without warning; and SD cards are notorious for corrupting under exactly that abuse.

The Decision: a Docker daemon with a PostgreSQL volume is a lot of moving machinery to trust to a fragile SD card. SQLite compiles directly into the Python process (no daemon at all) and the whole database is one physical .db file, so a field operator can copy omega.db to a USB stick and hold a complete, air-gapped backup of the entire deployment. Write-ahead mode (PRAGMA journal_mode=WAL) removes SQLite's classic locking limits: the safety of a flat file with the speed of a networked database.

Why a 3D Globe on the GPU?

OMEGA renders the map the way a video game does: hand all the points to the graphics card (the GPU) at once. A normal web map (like Leaflet) draws every dot as its own little web-page element, which holds up for a handful of pins and grinds the browser to a halt once you pile on thousands of historical readings.

The Decision: the portal uses a self-hosted CesiumJS 3D globe that bypasses the browser's DOM, passing coordinate buffers directly to the GPU via WebGL. To keep a laptop responsive it renders on-change rather than in a fixed loop, with time-stepped overlays for playing history back.

Honest status: the 3D digital twin (DTO v3) is partial and in-flight; first load is currently on the order of 30–60 seconds. Pushing into the millions-of-points regime via a Deck.gl layer is a roadmap goal, not shipped today.

import { DeckGL } from '@deck.gl/react';
import { ScatterplotLayer } from '@deck.gl/layers';

// Roadmap sketch: a GPU point layer for dense historical telemetry
function TelemetryMap({ data }) {
  const layer = new ScatterplotLayer({
    id: 'telemetry-layer',
    data,
    // WebGL bypasses the DOM and injects directly to the GPU
    getPosition: d => [d.longitude, d.latitude],
    getFillColor: d => {
      // Color map based on raw temperature
      if (d.temperature > 25) return [239, 68, 68]; // Red
      return [59, 130, 246]; // Blue
    },
    getRadius: d => 10,
    radiusUnits: 'pixels',
    pickable: true
  });

  return (
    <DeckGL
      initialViewState={{ longitude: -157, latitude: 21, zoom: 6 }}
      controller={true}
      layers={[layer]}
    />
  );
}

Let Operators Add Their Own Formulas, Safely.

Operators frequently need custom derived metrics (e.g., dewpoint, heat index, density) calculated on the fly without writing backend code. The naive approach is running Python's eval() on the server, which is a serious code-injection vulnerability on a public gateway.

The Solution: The backend implements a custom Abstract Syntax Tree (AST) interpreter for derived metrics. It parses and validates mathematical formulas at definition time, explicitly allowing only numeric literals and a whitelisted set of math operations (sqrt, sin, log). Attribute access, function calls, and import tricks are rejected at parse time. Operators get full mathematical expressiveness, and anything outside that whitelist never runs.

Where the Stack Actually Stands.

An honest read of where the stack is strong and where it isn't: the protocol, gateway, and portal carry real field evidence; the alternate bearers and the edge firmware's field-hardening are the least mature parts.