Nearstream

A shared journal between close friends — manifesto v0.5

Status — buildingUpdated 2026-06-11Supersedes v0.4 · v0.3 · v0.2 · v0.1
The single source of truth for terms, decisions, and reasoning behind Nearstream. The Decisions log (§05) is the most important section — code can be re-read, but the reasons behind picks rot fastest.
00Concept

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.

01Lexicon

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.

Now

What you’re up to at the moment, at the top of your home. Replaces itself — it isn’t posted, and friends never see it in their reader. Called Letter until 2026-08.

Line

The short-text Stream primitive. A sentence, no title, no commitment — the most casual thing you can post.

Voice note

Up to 60 seconds, recorded in the browser. Plays with a visualizer that moves with the sound, and travels to friends’ readers through RSS.

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.

02Architecture

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 readeryour 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.

03Content model

Stream / Library / Now

Two territories and a standing note. Stream is the process — a Line or a voice note, posted in passing. Library is the artifact — a track, a picture, an essay, each with its own permanent URL. Nowis what you’re up to at the moment: it replaces itself, never syndicates, and isn’t a post at all.

The home page renders both territories as one dated document— everything you’ve posted, newest first, no pagination and no sections. Library is where the same things are filed by kind.

StreamLibrary
ShapeA Line or a voice note + timestamp + modeTyped entry — track, picture, essay
URLVoice notes get one; Lines live in the timelineEach entry has its own deep page
SortStrictly chronologicalBy kind, newest within
CadenceDaily-ish — the texture of lifeWeekly to monthly — finished work
Mental modelWhat you'd say to a friend at coffeeWhat 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 · images · body · visibility

Pictures, objects, anything visual. Lands at /library/inventory/{slug}.

Music track

title · artist · audio · cover · notes · visibility

A track you want to keep somewhere that isn't a streaming service. Stored as uploaded — no re-encoding. Lands at /library/music/{slug}.

04Anti-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.

05Decisions log

Terse. Each entry: the decision, the reason, when. Append here when we pick something — never delete.

2026-08-29

The home page is one dated document, not category sections

Everything you post — Lines, voice, pictures, tracks, essays — merged into a single reverse-chronological page with no pagination. Each kind carries its own form: a short Line is set large because one sentence is the whole post, a long one drops small and narrow, pictures go full width, audio is a band, an essay is the only thing with a headline. Why: the sectioned home read as four filing cabinets when full and as empty when sparse, and every entry rendered identically so a photograph and a one-liner were the same object. Stream is the diary; Library is where the same things are filed by kind.

2026-08-29

Older entries fade; looking at one brings it back

Contrast and a hair of blur derived from the post’s age, floored so nothing becomes unreadable, with hover and focus restoring it fully. A companion idea — fresh entries arriving faint and darkening as the ink set — was built and then removed: it read as a rendering fault rather than a choice. Why: recency should come from optics, not from an algorithm choosing an order or a “load more” hiding the past. Nothing is ever removed from the page — it just goes quiet, the way a print left in the light does. And you can’t see your own new post at full strength immediately, which is the inverse of the instant-feedback loop every other posting surface is built on.

2026-08-27

Letter becomes Now, and leaves the composer

Renamed and moved into its own block, separate from posting. Why: it was never a post. It replaces itself rather than accumulating, has no permanent URL, and never appears in RSS, a friend’s reader or the digest — it never leaves your own page. Sitting in “post something” beside five things that genuinely syndicate made it read as a sixth way to publish. “Now” is the IndieWeb convention for exactly this; “Letter” implied the newsletter §04 rejects.

2026-08-27

The composer groups by territory, and Stream is already open

Two chips — Stream and Library — with the Line composer open on arrival, so the most casual thing you can post costs zero taps. Why: a flat row of primitives overflowed on every phone once music landed, and it grew with each new type. Two groups stay two groups forever; a new Library type joins one instead of extending a row. The short-text primitive is a “Line” rather than a “note” — a note sounds like it has length to it.

2026-08-12

Voice and music are first-class, and the visualizer is a choice

Voice notes in Stream, music tracks in Library, both on one shared audio layer. Three visualizers — ant traces, proximity web, wave grid — and the pick travels with the post rather than with the viewer. Why: audio is the differentiator against every text-first alternative, and nothing else does it well at this scale. The visualizer is your signature, so a voice note should look the same on your page, in a friend’s reader and in the digest.

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.

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.

06Open questions

Unresolved. Move to §05 when we pick.

?

Stream cadenceshould there be a daily limit? Should the reader collapse same-friend same-day entries?

?

Searchwhen do we add it, and across what scope (site / library / reader)?

?

Draftsexist as unpublished entries with a flag, or in a separate namespace?

?

Reader-level interactionscomments? webmentions? read receipts? When do these violate “no metrics”?

?

Cross-discipline reader renderingwhen a Stream post and a Library entry sit next to each other, how does the chrome differentiate them at a glance?

?

Custom domain handoffmanual at first (operator flips DNS), or self-serve via a settings page?

?

Friends-level privacytoday every entry is public or private. Do we need a third level visible only to followed sources?

?

Edit historystore every save as a new version, or just the latest? Friends-visible or private?

07Build 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
08Stack

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.

09Connection to Nearbox

Nearbox

Physical device. Always-on. Small trusted network. Short messages. Intentional, constrained communication. The physical layer of intimacy.

same
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.

Nearstream — manifesto v0.5start small · own everything · add friends slowly