Seed is the open-source software for the Hypermedia protocol. It is a small family of programs that work together, and this section has one page for each program. Each page is a map for people who change or run that program. It is not a user manual.
The programs fall into four groups:
The apps put a person in front of a daemon: the desktop app, the web app and the mobile app.
The services add things around it: notify sends email, the vault keeps identities, and the app environment runs agents.
A program here means software you install, run or deploy. It does not mean an "app" in the product sense. An app is a document that lists its tools, pages and triggers, and it has its own pages on this site. The two meet in one place: the app environment is the program that runs apps and agents.
All the code is in one repository, github.com/seed-hypermedia/seed. It uses four toolchains:
The Go daemon and the protobuf definitions are built with Please and the ./dev script.
The TypeScript apps are a pnpm workspace under frontend/.
The vault and the app environment are separate Bun workspaces.
The mobile app installs its own dependencies with npm.
Contributing explains the setup.
The programs
Read the daemon first, because every other program needs one, directly or through a site. Then read the page of the program you work on.
Program | What it is | Where | Talks to the daemon over |
|---|---|---|---|
The Go node. It stores, indexes and signs data, syncs over libp2p, and serves gRPC and HTTP. |
| It is the daemon. | |
The Electron app: a browser, an editor and an archive. It starts its own daemon and, when that setting is on, a local app environment. |
| gRPC-web on the daemon's HTTP port. | |
The site server and gateway. It serves rendered pages, the Seed API and the site services, and it signs in the browser. |
| gRPC-web on the daemon's HTTP port, with a bearer token for each request. | |
The command-line client for documents, comments, contacts, capabilities and keys. It also publishes these docs from git (see Publish a folder). |
| The Seed API of a site over HTTPS. One command talks to a local daemon. | |
The notifications and email service. |
| The daemon's activity feed over gRPC-web. | |
The identity vault. It keeps account keys that the server cannot read, and it gives browsers session keys. |
| gRPC-web to the site's daemon, to look up accounts and to sign. It uploads profile and capability blobs to | |
The Expo app for iOS, Android and the web. |
| The Seed API of a site. | |
A browser for the raw data on the network: documents, blobs, the activity feed and an API lab. |
| The Seed API of a site. | |
The server that runs agents and apps. It has a signed action API, sessions, tools and triggers. |
| The Seed API of a site, as a client with delegated keys. |
Every program page has the same sections: what the program is, where the code is, how it talks to the daemon, its configuration, how to run it, and how it works with the Seed app, the CLI commands, the SDK, the Seed API and agents.
The shared packages
Five TypeScript packages in frontend/packages/ sit under the programs:
@seed-hypermedia/client is the SDK.
@shm/shared is the app layer.
@shm/ui holds the components.
@shm/editor is the block editor.
@seed-hypermedia/apps-ui packages the agents screens for other apps.
The first four depend on each other in that order. The shared packages describes each one, the editor, and the rules that make a document look the same in every program.
Ports at a glance
This is the port table of the site. The program pages link here.
Port | Prod | Dev | Belongs to |
|---|---|---|---|
Daemon P2P | 56000 | 58000 | daemon, spawned by the desktop app |
Daemon HTTP, gRPC-web, | 56001 | 58001 | daemon |
Daemon native gRPC | 56002 | 58002 | daemon, unused by the TypeScript apps |
Desktop API bridge, | 56004 | 58004 | desktop app |
App environment | 3050 | 3051 | app environment |
Vault | 3030 | vault | |
Web app | 3000 | web | |
Notify | 3060 | notify | |
Explorer | 5173 | explore |
How to read the table:
"Prod" is a released desktop app. "Dev" is the development stack that ./dev up starts. The two use different ports, so both can run at the same time.
A daemon that you start yourself, without the desktop app, uses 55000, 55001 and 55002.
A hosted site runs its daemon on 56000 behind a reverse proxy.
Outside development, notify and the vault listen on 3000. Each program page names its port setting.
The daemon has no separate metrics port. Its metrics are at /debug/metrics on the HTTP port.
The daemon network reference describes the daemon's ports in more detail.
See also
The shared packages, the code the programs have in common.
Seed Agents, what the app environment runs.
Building on Hypermedia, for using these programs from your own code.
Seed API, the API most of these programs speak.
Running Seed and Self-hosting, for running a site.
Contributing, for developing them.
The protocol, what the daemon implements.
The programs, one page each
Do you like what you are reading? Subscribe to receive updates.
Unsubscribe anytime