Container Portby Wilhelm

Your containers need a ship. Your ships need a harbor.

A ship is a sealed container that holds a whole Docker stack, with its own address and its own data. The harbor is the desktop app that builds, backs up and connects many of them on one machine.

Get started See how it works

A white harbor seen from above: ships at anchor, a quay, a lighthouse, a shipyard and a container terminal.

A still of the launcher's own harbor view.

  • at anchor: running
  • at the quay: stopped
  • on the slipway: being built

The idea

A VM for your VMs.

Docker gives you containers. It does not give a whole stack a home: every project shares one engine, one set of ports, one pile of volumes. A ship is that home, a whole machine of its own. The harbor is the machine that runs them.

Layer 1

Your machine.

A Mac, a Linux box or a server you rent. Container Port is one desktop app on it.

  • macOS, Linux, Windows

Layer 2

The harbor.

One private network and one gate. On Linux the harbor runs on the machine itself. On a Mac it lives in a single small Linux VM. Every ship gets a fixed address here.

  • private network 10.77.0.0/24
  • one gate

Layer 3

A ship.

A complete Linux machine. It boots, runs its own services, has its own root disk and its own limits. Stop it, copy it, snapshot it or save it as one file. Its neighbors never notice.

  • 10.77.0.11
  • 6 CPU
  • 16 GB memory
  • 100 GB disk

Layer 4

Its own Docker.

Inside the ship runs a Docker engine nobody else uses, with one stack on it. Ports 80 and 443 are free on every ship, because every ship has its own.

  • its own Docker
  • ports 80 and 443 free
  • one settings file per ship

Layer 5

The apps.

Each app is a container on deck. Nextcloud, n8n and NocoDB carry every container ship. Everything else is cargo you choose.

  • 19 apps on this ship

To be precise: a ship is a system container, not a hardware-level virtual machine. It has its own init system, its own Docker, its own address, disk and limits, and shares only the kernel with its host. That is why it behaves like a VM, yet boots no second kernel and reserves no memory up front.

  • A whole machine each

    Its own Docker, address and disk. Nothing to share, nothing to collide.

  • No second kernel

    A ship boots like a container and reserves no memory up front.

  • Hard limits

    A ship gets the CPU and memory you gave it, and no more.

  • Snapshots

    Freeze a ship's state before an update. Roll back if it goes wrong.

  • One file per ship

    Back up, restore, move and clone a ship as a single file.

  • Sealed off

    Ships cannot reach each other. One gate decides what comes in.

On board

Name it. Equip it. Load it.

This is the launcher's own ship model. Scroll to watch one come together.

Step 1

Name it.

Give the ship a name and a flag. Container Port creates a fresh machine with its own file system and its own limits for CPU, memory and disk. Nothing is on board yet.

Step 2

Equip it.

Nextcloud is the hold that carries the data. TaskHQ is the bridge. Traefik is the antenna that takes requests. n8n is the piping between apps. The ship gets its address on the harbor network.

Step 3

Load it.

Every other app is a container on deck. Small apps travel as parcels, heavy ones as high cubes, and they stack. The yard adds up the memory they need and tells you before launch if the ship is too small.

Then launch. The ship installs its stack on its own and reports each step. When it is done it drops anchor. Running ships lie at anchor, stopped ships are moored at the quay.

In action

Run it. Watch it.

This is the launcher's own harbor. A ship shows how it is doing: green at anchor, low in the water when it is overloaded, listing when a core part fails, sinking when it crashes. Try it.

A white harbor seen from above with ships at anchor.

The states and how they look come from the launcher's own code. The ship and its numbers are a sample.

The app

One window for the whole fleet.

Container Port is a desktop app. These are its views, rebuilt for this page with sample ships. Click through them.

See every ship at once.

Running ships lie at anchor, stopped ones at the quay, new ones on the slipway. Pick a ship to open its sheet.

Harbor

All 7At anchor 4Docked 2In the yard 1

agency

At anchor · running · Panamax

CPU6 coresMemory16 GBApps19

10.77.0.11local

Ship core

AntennaTraefikHoldNextcloudPipingn8nBridgeTaskHQ

Cargo

WebwowPenpotPhotostoreIllusionatorOutdesignFigmentoPlausibleListmonk+7

The fleet as a list.

Address, domain, limits and cargo of every ship, with the actions you need most.

Ships

Every ship is its own sealed machine with a whole stack and its own address.

New ship in the yard

agencyrunningAgency

At anchor

Domain
agency.wilhelm.local
Address
10.77.0.11
Limits
6 CPU · 16 GB

WebwowPenpotPhotostoreIllusionator+5

OpenDockBack upMore ...

shoprunningCommerce

At anchor

Domain
shop.wilhelm.local
Address
10.77.0.12
Limits
6 CPU · 16 GB

TwentyListmonkPlausibleMeilisearch

OpenDockBack upMore ...

practicestoppedServices

Docked

Domain
practice.wilhelm.local
Address
10.77.0.13
Limits
6 CPU · 16 GB

Cal.comDocumensoTwentyVaultwarden

OpenAnchorBack upMore ...

ai-labrunningAI and knowledge

At anchor

Domain
ai-lab.wilhelm.local
Address
10.77.0.14
Limits
16 CPU · 64 GB

Open WebUIMeilisearchNextcloudn8n+4

OpenDockBack upMore ...

workflowsrunningAutomation

At anchor

Domain
workflows.wilhelm.local
Address
10.77.0.15
Limits
2 CPU · 3 GB

TaskHQn8nNocoDB

OpenDockBack upMore ...

documentsstoppedDocuments

Docked

Domain
documents.wilhelm.local
Address
10.77.0.16
Limits
2 CPU · 4 GB

TaskHQStirling PDFDocumenso

OpenAnchorBack upMore ...

factorybeing builtProduction

In the yard

Domain
factory.wilhelm.local
Address
10.77.0.17
Limits
6 CPU · 16 GB

OdooPlaneUptime Kuma

OpenAnchorBack upMore ...

Build a ship in five steps.

Name, plan, size, cargo, launch. The yard adds up the memory the cargo needs before you launch. Load a few apps and try it.

Shipyard
  1. New
  2. Plan
  3. Ship
  4. Cargo
  5. Launch

Cargo

Search apps ...

Deck

RAM

Feeder 18 slots · 4 CPU · 8 GB

Tap an app to load or unload it.

Draw a line from a domain to a ship.

The gate forwards the domain and its subdomains to that ship. Inside the ship each app answers on its own subdomain: cloud., n8n. and so on.

Router

3 domains · 3 of 7 ships with an entrance · gate harbor-gate (running)

+ Domain
agency.wilhelm.localwith subdomains · TLS internalagency10.77.0.11 · running
shop.wilhelm.localwith subdomains · TLS internalshop10.77.0.12 · running
practice.wilhelm.localwith subdomains · TLS internalpractice10.77.0.13 · docked
without a route (4)

Setup without a terminal.

The app shows only the steps your machine is missing, each as a button. Check then tests the whole path from inside a ship.

Setup

Done: Homebrew · Colima and Incus · Start Linux VM · Create harbor · Connect this Mac to the ships

Check All good.

  • Incus reachable Incus answers.
  • Version Incus 6.8.
  • Ship network Network wilhelm-harbor (10.77.0.1/24) is up.
  • Address inside a ship (from harbor-gate) 10.77.0.2/24
  • Route to the host (from harbor-gate) 10.77.0.1 answers.
  • Internet (from harbor-gate) 1.1.1.1 is reachable.
  • Name resolution (from harbor-gate) Names resolve (via 10.77.0.1).
  • HTTPS (from harbor-gate) github.com answers over HTTPS.
  • Memory 21 of 32 GB free.
  • Disk 62 of 100 GB free.

Whole ships as files.

One click saves a ship as a single file: disk, Docker volumes and snapshots included. A schedule keeps the newest files per ship in a folder you choose.

Backup

Back up ships to files automatically

Target folder~/Backups/harbor

Intervaldaily

Files to keep per ship7

Alarm after hours without a backup48

ShipLast backupFiles
agency-0
shop-0
practice-0
ai-lab-0
workflows-0

Rebuilt in HTML from the app's real views. The app's interface is German today; the labels here are translated.

Network

One door in.

Every ship lies in a closed basin. The only way in from outside is the gate, and the gate sends each domain to exactly one ship. Ships cannot reach each other.

Follow a domain
  • One gate

    Requests from outside enter in one place. Everything else is closed.

  • One ship per domain

    A domain and its subdomains lead to one ship and nowhere else.

  • No way across

    A ship answers the gate and your own machine. It does not answer other ships.

Blueprints

Start from a plan, not from zero.

A blueprint is a short file that lists the apps for one kind of work. Pick one, change the cargo if you like, launch.

Agency

Made for: Agencies and creative studios

Hull
Panamax · 6 CPU · 16 GB · 100 GB
On board
Base plusWebwowPenpotPhotostoreIllusionatorOutdesignFigmentoPlausibleListmonkFormbricks

Commerce

Made for: Online shops and retail

Hull
Panamax · 6 CPU · 16 GB · 100 GB
On board
Base plusMedusaTwentyListmonkPlausibleMeilisearch

Services

Made for: Consultancies, law firms, practices

Hull
Panamax · 6 CPU · 16 GB · 100 GB
On board
Base plusCal.comDocumensoTwentyVaultwardenCollabora Office

AI and knowledge

Made for: Local language models and search

Hull
Megamax · 16 CPU · 64 GB · 250 GB
On board
Base plusOllamaOpen WebUIQdrantMeilisearchNeo4j

Production

Made for: Manufacturing, trades, project work

Hull
Panamax · 6 CPU · 16 GB · 100 GB
On board
Base plusOdooPlaneUptime KumaLoki and Promtail

Base

Made for: Any team

Hull
Feeder · 4 CPU · 8 GB · 60 GB
On board
TraefikNextcloudn8nNocoDBTesseractStirling PDFACIDGotenbergTaskHQ

Automation

Made for: Workflows and tables, nothing else

Hull
Houseboat · 2 CPU · 3 GB · 30 GB
On board
TraefikTaskHQn8nNocoDB

Documents

Made for: PDF tools, text recognition, signatures

Hull
Barge · 2 CPU · 4 GB · 40 GB
On board
TraefikTaskHQStirling PDFGotenbergTesseractDocumenso

AI workplace

Made for: A local chat model, nothing else

Hull
Barge · 2 CPU · 4 GB · 40 GB
On board
TraefikTaskHQOllamaOpen WebUI

Web presence

Made for: A website and a newsletter

Hull
Houseboat · 2 CPU · 3 GB · 30 GB
On board
TraefikTaskHQWebwowListmonk

Raft

Made for: Exactly one app of your choice

Hull
Raft · 1 CPU · 2 GB · 20 GB
On board

Every container ship starts from the base and adds to it.

From a raft to a Megamax.

A ship is as big as its cargo needs. A raft carries a single app. A houseboat carries a handful. Container ships carry the full stack.

CPU cores
Memory
Disk
Container slots
Compare all sizes in a table
SizeGood forCPU coresMemoryDiskContainer slots
RaftOne app, one container. No frame around it.12 GB20 GB1
HouseboatTwo or three apps with a proxy and a control panel.23 GB30 GB2
BargeA small, self-contained setup with up to six apps.24 GB40 GB6
CutterA few tools for a small team.24 GB40 GB16
FeederNimble and frugal. The core stack fits.48 GB60 GB36
FeedermaxThe core plus one industry package.412 GB80 GB56
PanamaxThe all-rounder for agencies, shops and law firms.616 GB100 GB108
Post-PanamaxPlenty of deck for many departments.824 GB120 GB150
Neo-PanamaxAI models and the creative suite at the same time.1232 GB160 GB180
MegamaxA full load. Everything on board.1664 GB250 GB336

These are the yard's suggestions. You can change CPU, memory and disk for any ship at any time.

Cargo

47 apps, ready to load.

This is the launcher's container terminal. Every app the stack can carry stands here as a container. Point at one to see what it is. Click it and it goes on board the ship at the quay.

Three apps carry every container ship

  • Nextcloud

    Files, calendars and contacts. The home of every ship's data.

  • n8n

    Automation. Connects apps, forms and data without code.

  • NocoDB

    A database with a spreadsheet face: lists, forms and an API.

Stacked white containers with app icons under a gantry crane, next to a quay.

On board nothing loaded yet

Point at a container, click to load it. With the keyboard: arrow keys choose, Enter loads.

Show as list
  • NextcloudFiles, calendars and contacts. The home of every ship's data.
  • n8nAutomation. Connects apps, forms and data without code.
  • NocoDBA database with a spreadsheet face: lists, forms and an API.
  • TaskHQStart, check and back up the stack
  • TraefikReverse proxy inside the ship
  • Uptime KumaWatches services, reports outages
  • Loki and PromtailAll container logs in one place
  • ntfyPush notifications
  • Collabora OfficeDocuments and sheets in the browser
  • Stirling PDFMerge, split, redact, sign
  • DocumensoDigital signatures
  • TesseractText recognition for scans
  • GotenbergTurns documents into PDF
  • ACIDDocument converter
  • TwentyContacts, companies, deals
  • Cal.comAppointment booking
  • PlaneTasks and projects
  • OdooInventory, production, accounting
  • MedusaShop and storefront
  • VaultwardenPassword vault for the team
  • FormbricksSurveys and forms
  • GhostfolioPortfolio tracking
  • WebwowVisual website builder
  • PenpotDesign and prototyping
  • PlausibleWebsite statistics without cookies
  • ListmonkNewsletters and mailing lists
  • ImmichPhoto and video library
  • OllamaLanguage models that run on the ship
  • Open WebUIChat interface for those models
  • QdrantVector database for search
  • Neo4jGraph database
  • MeilisearchFast full-text search
  • EnterCode editor with an AI agent
  • OpenClawSteer the ship by chat
  • PhotostoreImage editing
  • IllusionatorVector graphics
  • OutdesignPage layout
  • FigmentoInterface design
  • PremixerVideo editing
  • Later EffectsMotion graphics
  • BrightroomPhoto library and RAW
  • AudiationAudio workstation
  • AkrobatPDF workbench
  • WordsmithWord processing
  • ExcelsiorSpreadsheets
  • PowerpaintPresentations
  • Fission2D and 3D CAD

Who it is for

For people who run more than one of something.

Agencies and service providers

One ship per client. Each client gets their own files, their own automations and their own domain. When a client leaves, hand over the ship as a single file.

Teams that must keep data apart

Separation here is not a permission setting inside one big app. It is a network boundary and a separate disk. A mistake on one ship cannot leak into another.

Self-hosters

Try a new stack without touching the one you rely on. Take a snapshot before an update and roll back if it goes wrong. Keep everything on hardware you own.

Get started

Download Container Port.

One desktop app for macOS, Linux and Windows. Download it, open it, and let it set up the rest.

Downloads are coming with the first release. The installers are not published yet. Until the first release, you can build the app from source, see below.

macOS

macOS 11 or later

Apple silicon .dmgIntel .dmg

Linux

x86-64

AppImageDebian, Ubuntu .deb

Windows

x86-64, connects to a harbor in WSL2 or on a Linux machine

Installer .exe

What happens on first start

The app checks what your machine is missing and shows only those steps. Each step is a button. On a Mac it sets up one small Linux virtual machine for the harbor. On Linux it installs the container engine and sets up its network and firewall. Where a step needs admin rights, your system asks for the password.

A built-in check then tests the connection from inside a ship and names the cause if something is off. On Windows the app connects to a harbor in WSL2 or on a Linux machine, and that connection is still set up by hand.

Then build your first ship

  1. Let the setup screen finish. Its last step creates the harbor: the network, the firewall rule and the gate.
  2. Open the shipyard, pick a blueprint and a size.
  3. Launch. The ship builds itself and shows up in the harbor with its own address.
Build from source

For developers, and for everyone until the first release. It needs Node.js and git, and Incus for the ships.

The repository is private at the moment. You need access to it for the steps below.

1. Get Incus

macOS

On a Mac, Incus runs inside a slim Linux virtual machine managed by Colima. The setup screen in the app installs and starts both with one click each. If you prefer to do it by hand:

brew install colima incus
colima start --runtime incus

Works on Apple silicon and Intel. The app then connects on its own.

Linux

On Linux, Incus runs directly on your machine. On Debian 13 or Ubuntu 24.04 and later:

sudo apt install incus
sudo incus admin init --minimal
sudo usermod -aG incus-admin $USER

Log out and back in so the group applies. The setup screen in the app shows each step with its status. Fedora is covered there too.

Windows

On Windows, Incus runs in WSL2 or in a Linux virtual machine, and the launcher connects to it over HTTPS. Inside that Linux system:

incus config set core.https_address :8443
incus config trust add-certificate client.crt

The second line trusts the launcher's client certificate, which you copy over from the Windows machine. Then open Settings in the launcher, choose HTTPS, enter the address and confirm the server's fingerprint. The same steps connect the launcher to a remote server.

2. Start the launcher

git clone https://github.com/The-Wilhelm-Project/Wilhelm-Techstack.git
cd Wilhelm-Techstack/tools/harbor
npm install
npm start

Repository on GitHub Launcher README

Under the hood

For the skeptical.

No magic, only well-known parts put together carefully.

Containers
Each ship is an Incus system container built from an Ubuntu cloud image. Docker runs inside it with nesting enabled. Incus needs Linux: on a Mac it runs in one small Linux VM managed by Colima, and the setup installs both with Homebrew. Virtual machines are supported by Incus too and show up in the same interface.
Stack
Inside a ship there is one Docker Compose project. Apps are Compose profiles. On first boot cloud-init installs Docker, the yard writes the ship's .env, and the stack installer runs without questions. Traefik routes subdomains to the apps.
Network
A bridge network, 10.77.0.0/24, with outbound NAT. An access list drops all inbound traffic to ships except from the host and the gate. Outbound stays open so ships can pull images.
Gate
Caddy in its own container. Host ports 80 and 443 are forwarded to it. Per route it proxies a domain and its subdomains to one ship and keeps the Host header.
Launcher
An Electron app with no runtime dependencies beyond Electron and the Node standard library. It talks to the Incus REST API directly, over the local socket or over HTTPS with a pinned server fingerprint. The interface runs sandboxed with no Node access.
State
A ship's settings are stored as keys on the Incus instance itself, so they survive snapshots, backups and copies. Routes and app settings sit in a folder in your home directory.
No cloud
There is no account, no control plane and no telemetry. Building a ship downloads container images from their public registries. After that a ship runs without the internet.
License
Source-available under the Sustainable Use License, a fair-code license: free for your own internal business use and for personal use. The apps inside a ship keep their own licenses.

Everything above is also a command

./wilhelm.sh harbor snapshot agency before-update
./wilhelm.sh harbor backup agency ~/agency.tar.gz
./wilhelm.sh harbor import ~/agency.tar.gz --name agency-restore
./wilhelm.sh harbor route add client.example.com agency --tls auto
./wilhelm.sh harbor route apply

The core operations are also commands. The app and the command line share one library.

What is not there yet

  • Signed, notarized downloads. The first release will warn you on macOS and Windows.
  • Automatic updates of the launcher.
  • Replication between machines. A ship moves by backup and import.