Simplicity as Freedom: The Hypermedia Nostr Experiment

Nostr web clients behave like any other modern web applications. They ship React bundles, state managers, WebSocket layers, build pipelines, and megabytes of JavaScript just to display a feed. Nostr-hypermedia takes a very different path, starting with a deceptively simple question:

What happens when we let the browser do the job it was built to do?

Instead of shipping a miniature application runtime to every user, we send plain HTML. Instead of forcing the browser to act as a thick client, we keep it thin and let the server describe the entire application state through links and forms.

This approach may look outdated in 2025, but it gives developers more power by removing client-side complexity. It also brings Nostr closer to its cypherpunk foundations by building simple systems, writing inspectable code, avoiding brittle abstractions, and minimizing the need for trust.

What Is Hypermedia / HATEOAS?#

Hypermedia as the Engine of Application State (HATEOAS) demands a shift in mindset for anyone who grew up inside client-heavy architectures. It replaces custom client-side logic with server-driven links and forms, and challenges developers to instead rely on the browser's native strengths.

HATEOAS works through some straightforward rules:

• The server sends data and tells the client what actions it can take next.
• Every state transition exists as a link or a form, just like the early web.
• The client no longer invents a router, manages state containers, or synchronizes models. It simply follows hyperlinks.

Modern SPAs vs. HATEOAS#

In order to understand the difference between typical Nostr web clients and what we are working on with Nostr-hypermedia, let's take a look at how the two models work.

Single Page Apps (SPA) model:

• The client owns the application logic.
• The server only returns data.
• Both sides must stay perfectly version-aligned.
• Creates complexity and is prone to breaking.

HATEOAS model:

• The server defines the current state and every allowed transition.
• The client behaves like a simple hypermedia agent.
• Browsers already understand this model. They natively handle links, forms, navigation, caching, and history.

Why Hypermedia Fits Nostr#

Nostr embraces radical minimalism with tiny event structures, stateless relays, and a loose, schema-light design. This design gives clients absolute freedom to interpret and innovate. A hypermedia client fits this ethos completely:

• Minimal client: No bundlers, heavy JS payloads, or toolchains. Hypermedia ideas can be integrated gradually even with React or other frameworks.
• Intelligent server: Renders views and exposes actions as plain HTML.
• Universal compatibility: Works on any browser, even with JavaScript turned off.
• Simpler code paths: Write less code, avoid more bugs, and eliminate entire categories of assumptions.

Nostr-hypermedia offers the web what Nostr offers messaging:

• A small set of composable rules without unnecessary layers.
• You never create a node_modules folder.
• You skip dependency forests and transient build errors.
• You don’t wait for hot reloading.
• You write HTML and ship it.

The Cypherpunk Connection#

Cypherpunks don't just write code, we write auditable code. Hypermedia fits that culture naturally:

• View-source verification: Anyone can read every interaction without special tools.
• No third-party JS CDNs: No silent updates, trackers, or supply-chain surprises.
• Support for constrained environments: Works on Tor, text browsers, old hardware, and locked-down networks.
• Privacy by default: No analytics scripts, fingerprinting, or background telemetry.

Running a self-hosted hypermedia Nostr client feels like running a Gopher server (I know, just me) or a Bitcoin node, not a modern web application. That’s exactly the feeling we aim for.

Practical Benefits#

As you change your mindset to align with HATEOAS philosophy, you see the benefits immediately. Plain HTML works with screen readers, keyboard navigation, and assistive tech without ARIA puzzles or framework quirks. First paint is the final paint. A hypermedia approach avoids hydration delays, JS waterfalls, and background CPU drain. Since we just rely on HTML, our app works without worrying about CDN failures, or outdated dependencies. Finally, HTML ages well, while frameworks do. Have you ever had to update a Rails or React project between major framework revisions? Hypermedia gives your project a long life with minimal maintenance.

Of Course, There Are Tradeoffs#

Hypermedia delivers a lot, but it doesn't solve every problem:

• Real-time updates require either page refreshes or small, intentional sprinkles of JavaScript.
• Some interactions feel slower without optimistic UI techniques.
• The server handles more work because it manages transitions.
• Highly interactive applications—design tools, spreadsheets, games—don’t fit this model.

Some Final Words#

The web already shipped with an application protocol: HTML. For decades, we kept stacking abstractions on top of it while trying to mold the browser into a desktop operating system, but the original model still works beautifully when we let it.

We are building a hypermedia Nostr client to rediscover that simplicity. In a world full of opaque, bloated, over-engineered software, choosing simplicity becomes a way to reclaim autonomy.

If this resonates with you, reach out, and let’s try a new approach to developing Nostr clients that aligns with the core ideology of our cypherpunk roots.