2026-06-11
Stream tag is a mode, not a discipline
Three broad buckets — making / taking in / being. Modes describe the shape of a moment instead of the identity of its author — a knitter and a coder both fit “making” without inventing new tags.
00 — Concept
A small group of close friends each own a personal site. Each site is their stream — daily life, work, ideas, photos. A shared reader pulls everyone’s stream together. No algorithm. No public. No likes. It accumulates quietly over time, like a shared journal you can all write in.
The problem with existing social networks: they bundled personal publishing and content aggregation together, and optimised for platform growth — not for the person. Nearstream unbundles these two layers and returns ownership to the individual.
The closest existing movement is IndieWeb (indieweb.org) — a community building exactly this since 2011. The reason it never reached normal people: too technical to set up, built by developers for developers. The cost structure of building tooling has shifted, which is why this is approachable now.
Nearstream is not trying to be the next anything. It’s trying to be the next nothing— the platform that doesn’t try to grow into your life. Start small. Stay small per instance. Spread by codebase, not by user count.
01 — Lexicon
The load-bearing terms. If we use a word, it’s defined here.
Reader
The shared room. Pulls all your sources’ feeds into one chronological stream. Same shape for everyone in the network. Nearstream’s territory.
Site
A tenant’s home. Their domain. Where their content lives. The user’s territory.
Stream
Short, ephemeral posts. Microblog. Timestamped + mode tag. What you’d say to a friend at coffee.
Library
Permanent typed entries — essays + inventory. Each has its own page. What you’d hand a friend.
Letter
The dated standing note at the top of your home. Updated when your head changes.
Mode
Stream metadata — making / taking in / being. Describes the shape of a moment, not the identity of the author.
Profile mark
The animated identity in place of a profile photo. Picked from ten parameterised variants on onboarding. No face, just a moving signature.
Source
A friend’s feed URL added to your local reader. The friend graph is your contacts; the source is one entry in it.
Friend graph
Local to your reader.The domains you’ve added, with optional local nicknames. Like contacts on a phone — public domain, private label. There is no shared graph.
Domain
A tenant’s public address. The “phone number.” Anyone with the domain can subscribe to its RSS feed.
Instance
A deployment of the codebase that hosts one or more tenants. Could be solo or multi-tenant. Anyone can run an instance.
Studio
The built-in posting interface. Inside the same app as your site, not a separate tool.
02 — Architecture
Three valid framings — they describe different cuts of the same thing. How does data move? (data flow) · What do users control? (freedom budget) · Who runs what? (tracks + protocol).
Data flow
// Each friend has their own site. The reader is yours alone.
friend_a.com→ RSS →your reader→your screen
friend_b.com→ RSS →↑
you.com→ RSS →↑
Freedom budget
Freedom is budgeted: a lot in some places, none in others. The whole architecture rests on this discipline.
Layer 01 · low freedom
Reader
The shared room. Same chrome for everyone in the network. You vary what you see (lenses), not how it's rendered.
+ density (compact / standard / magazine) · + filter (everyone / only X / library only) · + order (chronological / by friend / digest)
Layer 02 · medium freedom
Site
Your home, but constrained. Pick from a curated set of templates, palette pairs, type pairs — no free-form CSS, no hex picker, no font marketplace.
+ template · + palette pair (~8 curated) · + type pair · + masthead style + optional sections
Layer 03 · high freedom
Library entry
A single piece. High freedom within the site's language. Compose with typed primitives. Type the surface, not the visual.
+ plates / tracklist / spec table · + sequences / quotes / footnotes · + media embeds + process timelines
The discipline that makes this work:the reader is Nearstream’s territory; the site is the user’s territory. Neither invades the other. If users redesign the reader, the network feels fragmented. If they can’t shape their site, it’s a blog and they go back to Squarespace.
Two tracks + one protocol
Nearstream is two tracks bound by one protocol. The protocol is the only load-bearing contract — RSS 2.0 with a small typed-primitive namespace. Anyone who publishes that format appears in any reader.
Track 1 · Hosted
Multi-tenant instance someone operates. Friends sign up, get an account, post.
For most friends.
A community instance
Same codebase, different operators. A photo group, a college, a co-op.
Anyone can run one.
Track 2 · Self-host
Solo install. Clone, deploy anywhere, write your own UI. Just publish the feed.
For technical friends.
↓ ↓ ↓
The protocol
RSS 2.0 with a tiny xmlns:nearstream namespace so typed entries (note / essay / picture) round-trip between instances.
03 — Content model
Stream / Library / Letter
Three primitives every Nearstream site has. Stream is the process. Library is the artifact. Letter is the standing note at the top of your home.
| Stream | Library | |
|---|---|---|
| Shape | Short text + timestamp + mode | Typed entry — essay, inventory item |
| URL | None — lives only in the timeline | Each entry has its own deep page |
| Sort | Strictly chronological | Sectioned (essays / inventory), recent within |
| Cadence | Daily-ish — the texture of life | Weekly to monthly — finished work |
| Mental model | What you'd say to a friend at coffee | What you'd hand a friend |
Bridge: a Stream post can announce a Library entry with a small arrow link. The substance lives in the Library; the Stream just says this happened.
Mode tag
Stream entries carry one of three modes, not disciplines. A knitter and a coder both fit making without inventing new tags.
making
writing, cooking, sketching, building…
taking in
reading, watching, listening…
being
feeling, noticing, idling, just life…
Typed entries — the menu
Each Library entry uses one of these. Rule for adding a new type: only when an existing one would force the wrong shape.
Essay
title · body (markdown) · visibility
Long-form writing. Lands at /library/{slug}.
Inventory item
title · image · body · visibility
Pictures, objects, anything visual. Lands at /library/inventory/{slug}.
04 — Anti-aspirations
What Nearstream is not. The product is partly defined by what it refuses.
Not Squarespace
No drag-and-drop builders, no free-hex pickers, no font marketplace, no “section libraries.” The constraints are the product.
Not Instagram
No likes, no views, no metrics, no algorithm, no public.
Not Substack
Not a newsletter. Not optimised for “audience.”
Not Twitter / Threads
Not stream-only — the Library matters as much as the Stream.
Not Mastodon-shaped
Not federated-Twitter. It’s personal sites + a reader, not microblog instances.
Not retro cosplay
Modern structure, analog texture. No fake CRT chrome, no pixel fonts everywhere.
05 — Decisions log
Terse. Each entry: the decision, the reason, when. Append here when we pick something — never delete.
2026-06-11
Manifesto as a structured page, not rendered markdown
/manifesto is a curated, schematic page; NEARSTREAM.md is the internal working doc. The public manifesto is hand-laid for clarity. Decisions log here is the canonical reference for anyone reading the project.
2026-06-06
Profile marks instead of profile photos
Every non-host tenant picks one of ten parameterised “human-circle” animations. A face is the wrong primitive for a network whose point is to stop performing for strangers. The mark is a moving signature, not a likeness.
2026-06-06
Studio first-time empty state
Freshly-onboarded /studio leads with a single-paragraph welcome. Removes the “blank dashboard with eight unfilled forms” first impression.
2026-05-27
Phase 1 deploys to Vercel — interim, not architectural
Vercel is the host today; the codebase avoids Vercel-specific APIs. Lock-in stays theoretical while we stay disciplined; migration to Fly remains a 2–3 hour task.
2026-05-23
Two-layer design system: Nearstream chrome vs user site
Components in app/_components/ are platform chrome — same on every instance. Keeps the platform recognisable while letting users own the look of their personal stream.
2026-05-23
Nearstream chrome palette is pure mono, no accent
Black, foreground, two greys, border. No light mode. Austerity makes it a backdrop, not a brand fighting for attention.
2026-05-15
Auth is HMAC over Web Crypto, not a JWT library
Magic-link tokens and session cookies are base64url(payload).base64url(HMAC-SHA256(secret, payload)). This is auth for a handful of people, not enterprise. ~30 lines, zero dependencies, rotating AUTH_SECRET invalidates everything.
2026-05-15
Allowlist is an env var, not a database
ALLOWED_EMAILS is a comma-separated list in .env. Adding a friend = redeploy. Friction by design. A self-serve invite UI is the exact kind of feature this project shouldn’t have.
2026-05-12
R2 client is aws4fetch, not the AWS SDK
Single-file SigV4 signer over fetch. AWS SDK is ~1.6 MB / ~120 packages, mostly features we don’t need.
2026-04-28
Two tracks + one protocol
Hosted multi-tenant codebase AND self-hostable template, bound by an open RSS + typed-primitive format. Solves adoption (Track 1), sovereignty (Track 2), and longevity (the protocol outlives any instance).
2026-04-28
Friend graph is local, like a phone book
Domain = phone number (public). Friends list = your contacts (private). No follow requests, no central registry. Matches the real shape of friendship.
2026-04-28
Ownership through exit, not infrastructure
Each user owns their domain. Content is exportable at all times (JSON + media bundle). Identity is the domain, not the instance. Lets us run a hosted instance for adoption without compromising sovereignty.
2026-04-28
Scale by instance count, not user count per instance
Nearstream scales like email: many small instances, all interoperating via the protocol. Each instance ~10–80 friends. The friend-graph mechanic only works at small scale; the right unit of growth is the circle, not the user.
2026-04-28
Alessandro’s instance is for his close friends
Growth is incidental, not a goal. Future hand-off (paid tier / co-op / non-profit) is a future decision. Locks v1 scope to “small but durable.”
2026-04-27
Squarespace is the explicit anti-aspiration
Test for any new feature: would Squarespace add this? If yes, default to not adding it. Kitchen-sink builders are the wrong shape for friend-network publishing.
2026-04-27
Library is the parent of disciplines, not their sibling
All sites use Stream / Library / About as nav. Multi-discipline sites partition inside Library. Keeps single- and multi-discipline sites the same shape; “Library” stays a stable network-wide term.
06 — Open questions
Unresolved. Move to §05 when we pick.
?
Stream cadence — should there be a daily limit? Should the reader collapse same-friend same-day entries?
?
Search — when do we add it, and across what scope (site / library / reader)?
?
Drafts — exist as unpublished entries with a flag, or in a separate namespace?
?
Reader-level interactions — comments? webmentions? read receipts? When do these violate “no metrics”?
?
Cross-discipline reader rendering — when a Stream post and a Library entry sit next to each other, how does the chrome differentiate them at a glance?
?
Custom domain handoff — manual at first (operator flips DNS), or self-serve via a settings page?
?
Friends-level privacy — today every entry is public or private. Do we need a third level visible only to followed sources?
?
Edit history — store every save as a new version, or just the latest? Friends-visible or private?
07 — Build phases
Each phase is intentionally small. Build in order. Don’t jump ahead.
00
Define the protocol
Lock the TypeScript schemas for v1 typed primitives. The contract that flows through forms, storage, RSS, and reader cards.
Shipped~1 day
01
Solo end-to-end loop
Single user (host). Studio + Stream + Library + RSS feed. Magic-link auth. Cloudflare R2 storage. Custom domain optional.
Shipped~1 week
02
Library primitives
Essay + Inventory typed schemas, studio forms, site rendering. Library archive page. Each entry gets its own URL.
Shipped~1 week
03
Multi-tenant + reader
Hostname-aware proxy. Per-tenant R2 namespace. Tenant onboarding (handle + display name + profile mark). Reader pulls friends’ RSS feeds and merges by date.
Shipped~2 weekends
04
Onboard the first friends
Adding the first close friends to the allowlist. Watching how they use the studio and reader. Iterating on the empty states and the picker UX.
In progressongoing
05
Iterate on reader + library
Density modes, filter by person, grouping by day, unread indicators. New typed primitives only when an existing one would force the wrong shape.
Nextongoing
06
Richer interactions + federation
WebMention, ActivityPub bridge, POSSE to Instagram. Public open-source release with onboarding docs for instance-runners.
Laterv2
08 — Stack
Single Next.js app, portable storage, AGPL-3.0. Vercel-interim, Sanity-free.
Application
Single Next.js app
Site + studio + reader live together. Routes gated by auth where private. Open source, AGPL-3.0.
Storage
Cloudflare R2
S3-compatible object storage. Per-tenant prefix users/{userId}/… . JSON for content, blob for media. No database, no migrations.
Auth
Magic-link via Resend
Sessions are HMAC-signed cookies, 30 lines of Web Crypto. No SDKs, no JWT library, no Lucia.
Schemas
TypeScript types
Single source of truth: typed primitives flow through studio forms + site rendering + RSS export + reader cards.
Feed
RSS 2.0 + nearstream ns
Standard RSS plus typed-entry metadata via a tiny xmlns:nearstream namespace. Backwards-compatible with any reader.
Compute
Vercel (interim) · portable
Vercel today, intentionally portable. No Vercel-specific APIs — the codebase ships as a single container to anywhere that runs Node.
09 — Connection to Nearbox
Nearbox
Physical device. Always-on. Small trusted network. Short messages. Intentional, constrained communication. The physical layer of intimacy.
same
philosophy
─────
different
medium
philosophy
─────
different
medium
Nearstream
Personal web. Owned infrastructure. Small trusted network. Stream of life and work. The digital layer of intimacy.
Both reject the same thing: platforms that extract value from your attention and relationships. Both bet on the same thing: that a small, known audience is more meaningful than a large, unknown one.