Five layers. One platform.

Two pieces of off-the-shelf hardware do most of the work: a Mac mini running inside the nav station and a standard NMEA-2000 gateway plugged into the boat's instrument network. The Mac mini runs the OS, the apps, and local AI inference. The gateway translates every instrument reading into data the platform can use.

I also support a handful of add-ons — Victron battery monitors over Bluetooth, WiFi-connected weather stations, AIS receivers. They all feed through the same ingestion pipeline. You are never writing a new driver because you bought a different brand of GPS.

The hardware layer is the foundation. Everything above it assumes these things are running.

The bus is the data exchange layer — the spine that connects the hardware below it to the OS and apps above. Every sensor reading, state change, and event flows through it as a typed, timestamped, source-tagged message. Apps subscribe; they do not poll.

This is not SignalK, not a third-party message broker, not a format I bolted on later. It is 32°N's own native bus, designed from the start to be the thing all the other layers depend on. The schema is open and versioned in the public repo.

Communications between the hub and connected devices — phones, tablets, remote clients — also go through here. One bus, one data model, many consumers.

The 32°N OS is the software layer that boots on the hub, starts the platform services, and manages the apps. It handles identity, the local data store, the event bus, the AI gateway, the audit log, and the sync engine. Apps get all of that for free by targeting the platform contracts — they do not wire it up themselves.

Security is baked in from the start. Every device that connects to the hub goes through registration and is scoped to specific permissions. The audit log is structured, queryable, and tamper-evident. Nothing connects that has not been explicitly admitted.

The OS runs on a Mac mini today. Other hub platforms come after 1.0 — the architecture does not depend on Apple Silicon, that is just the right hardware for where we are now.

The apps are the things sailors actually use: the chartplotter, the weather router, the anchor watch, the logbook, the electrical planner, the passage planner, the security audit tool. Each one does one job. None of them know about each other. They all know about the platform.

Writing a new app means implementing the platform contracts — not negotiating proprietary device protocols, not reinventing identity or sync, not building your own AI integration. The platform hands all of that to you on arrival. That is how I can build a growing catalogue of apps without the whole thing becoming unmaintainable.

The extensions model means anyone can build apps on top and distribute them through the same registry. AGPL-3.0 means the licence terms are clear and the same for everyone.

Some things genuinely need the cloud: syncing your data across devices, pulling in live weather forecast models, routing AI requests to frontier models, share links so you can send your passage plan to someone. The cloud layer handles all of that.

I run a hosted instance. You can also point the cloud layer at infrastructure you control — any provider, or a server in your house. I publish container images. Same code either way; the licence prevents a "cloud edition" that quietly diverges.

If you are off-grid with no satellite link, the hub keeps working. The cloud layer is where capability expands, not where the product breaks down.