The first electronic navigational charts that a casual sailor could afford showed up in the late 1990s. The open standards that made them possible — IHO S-57 and S-100, NMEA 2000, AIS message formats, and Signal K — exist today. The data is there. The math is there. The foundation is solid.
Yet a serious sailor who wants to know whether to leave Newport for Bermuda on Tuesday morning still has to navigate a modern mess: open TimeZero, Coastal Explorer, or OpenCPN for the chart overlay. Open PredictWind or Squid for the routing. Open Windy for an atmospheric model sanity check. Open Navionics on a phone for community soundings. Open ActiveCaptain for anchorage notes. Check tides in a third app. Cross-reference a paper notebook. Text the shore contact via satellite.
Seven apps. Three browser tabs. One physical notebook. The sailor's brain is the integration layer.
Marine navigation software is fifteen years behind the rest of consumer technology. Existing platforms are excellent at isolated tasks — TimeZero's chart engine is impressive, PredictWind's ensemble visualizations are groundbreaking, and OpenCPN has shown what a credible open-source plotter looks like — but none of them tie together, because the incumbents have structural reasons not to. The instruments at the helm, the apps in your pocket, and the routing tools on your laptop live in separate worlds. Those seams are exactly where mistakes happen.
That is the problem Meridian exists to solve. And how we are solving it matters as much as what we are solving.
The math, briefly
A sailboat does not move where its bow is pointed. It moves where the wind, the water current, and the physical characteristics of the hull interact. Performance is governed by a polar diagram — a two-dimensional function that maps true wind speed and true wind angle to boat speed. (For the curious, jieter/orc-data hosts MIT-licensed polars for hundreds of production boats, derived from ORC's Velocity Prediction Program.)
The metric that matters most to a captain is Velocity Made Good (VMG) — the component of the boat's motion that actually carries it toward the destination:
VMG = Boat Speed × cos(θ)Where θ is the angle between heading and bearing-to-destination. Because sailboats cannot sail directly into the wind, optimal routing across an ocean is an integration problem.
The reigning algorithm is the isochrone method — introduced by Hagiwara in 1989 and refined in modern open-access form by Mannarini et al.'s VISIR paper. From a starting position, you fan out candidate headings, advance each by polar speed over a time step (Δt), and prune those points down to a one-dimensional curve of equal-time positions — an isochrone. You repeat iteratively until the curves reach the destination, then trace backward to recover the optimal route.
Existing apps run this calculation against a single, static forecast model. That is a dangerous simplification. Real weather is uncertain. The ECMWF Integrated Forecast System runs an ensemble of 51 members for every operational forecast, each perturbed slightly to encode atmospheric uncertainty; NOAA's GFS runs 31.
Meridian routes against every single member of these ensembles simultaneously. Instead of drawing a single deterministic line, it presents the captain with a true probability cloud: a median route, a 5-to-95 percent safety envelope, an arrival-time distribution, and clear risk metrics like the probability of encountering a gale. It preserves the exact information that matters most.
Why this is a sovereign architecture problem
Marine software is exceptionally difficult to build. It is data-heterogeneous, real-time, hardware-adjacent, heavily regulated, and legally tangled by viral copyleft licenses. Most critically: it must work entirely offline.
A boat in the middle of the Pacific may not be able to phone home to a cloud server for permission to render a chart — and even when it can, you can't depend on it. The architecture must be sovereign because the boat itself is sovereign — a self-contained vessel, far from help.
My background building Loggly (a high-scale time-series log platform) and Grub directly informs this design. A boat is fundamentally a live time-series problem:
- Every NMEA sentence is a timestamped event.
- Every GRIB file is a snapshot of a four-dimensional field.
- Every AIS target and depth ping is a stream of events through a coordinate system.
Sovereign Architecture means software systems whose owners fully control and understand their dependencies. You know exactly what runs on your hardware, where your data lives, and why every automated decision is made.
How builders use agentic tools to build better tools
Building software at this depth requires an engineering pipeline that mirrors the runtime environment. The same three components we use to develop Meridian are the exact primitives running onboard the vessel, split cleanly by operational intent:
| Component | Architecture & build role | Onboard runtime behavior |
|---|---|---|
| Hyperia | The surface. A terminal emulator and agentic display driver. Hyperia and its internal agent are responsible for writing and rendering the entire frontend layout. | The helm interface. Generates dynamic, custom-built displays and contextual controls tailored specifically for the captain. |
| Nemesis 8 | The orchestrator. Manages the backend, builds new components, and synthesizes on-the-fly data connectors so the frontend always has the precise datasets it needs. | The infrastructure. Automatically deploys and keeps critical processes running locally without the user ever having to think about containers or provisioning. |
| Ferricula | The memory and search engine. It doesn't plan — it remembers. Stores continuous context for Nemesis agents to plan against, manages local deployment artifacts, and indexes files. | The sovereign library. Acts as a completely local search engine, indexing passage notes, equipment manuals, and port guides — everything needed to get from point A to point B safely without an internet connection. |
This alignment means build time and run time use the exact same architecture. Nemesis 8 uses Ferricula's indexed memory to plan and build local data connectors on the fly, while Hyperia shapes the interface to match.
The stack uses a network connection if it's up, but it is engineered to function flawlessly when completely disconnected. It provides dynamic graphing, tailored controls, and custom displays built special-purpose for the captain right at the helm.
What we have so far
Our system runs on live data in a real browser against public APIs:
- Interactive polars. Hand-curated performance data for hulls ranging from a J/120 to a Lagoon 42 catamaran. Move the wind-speed slider; the curve responds.
- Ensemble routing. Live 51-member ECMWF Open Data atmospheric routing showcasing real forecast divergence in the Gulf Stream region.
- Ocean currents. Integrated Copernicus Marine SMOC data shifting routing envelopes based on real-time drift.
- Photorealistic 3D approaches. Marine-instrument overlays mapped directly onto Google Photorealistic 3D Tiles for unparalleled situational awareness in unfamiliar harbors.
What comes next
Meridian will be ready for testing in the near future. We are not announcing a hard date because we refuse to announce a timeline we cannot guarantee.
If you are a sailor who wants to get on the testing list, or an industry partner looking to discuss integration, let's talk. Reach out to kord@deepbluedynamics.com.
Meridian is built by Deep Blue Dynamics on the same stack we ship — Hyperia, Nemesis 8, and Ferricula. The boat is sovereign because it has to be.
// transmission ends