amir/dreamstack
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
dreamstack/USE_CASES.md
enzotar 70ca55b1af docs: add USE_CASES.md — vision, revenue paths, and demo roadmap 
5 fundamental UI redesigns: ambient UI, time-travel interfaces,
signal mixing, zero-install apps, physics-native interaction.

5 revenue applications: relay-as-a-service, live education,
collaborative design, IoT dashboards, live commerce.

Demo prioritization: step sequencer → physics playground →
whiteboard → session replay → multi-surface dashboard.
2026-02-25 18:58:12 -08:00

7.7 KiB
Raw Blame History

DreamStack — Use Cases & Vision

Core insight: DreamStack turns UI into a streamable binary protocol. Any .ds app becomes multiplayer with one line. No networking code. No database sync. Just stream main on url { mode: signal }.

The Paradigm Shift

Today, a UI is a program running on your device. With DreamStack's bitstream, a UI is a signal stream — writable by any source, receivable by any surface, composable, replayable, and physics-native.

Traditional DreamStack
App runs on one device Signal stream renders on N surfaces
Multiplayer = WebSocket + state sync + conflict resolution Multiplayer = one stream declaration
Screen sharing = compressed pixels State sharing = signal diffs (10-100x smaller)
Session replay = specialized SDK Session replay = just record the bitstream
Physics = external library Physics = built-in WASM engine, state streamed

Fundamental UI Redesigns

1. Ambient UI — App Without a Device

A .ds app runs once (server, edge, or one browser). Its signal stream renders on every available surface simultaneously:

  • Phone shows controls (buttons, sliders)
  • Laptop shows detail view (data, forms)
  • TV shows visualization (charts, physics)
  • Watch shows status (alerts, counts)

This isn't responsive design (same app adapting). It's one signal graph, many renderers. Each surface subscribes to the signals it cares about and renders at its own resolution and frame rate.

Why it matters: Apps stop being "installed things" and become ambient services that appear on whatever screen is nearest.

2. Time-Travel Interfaces

Every signal diff is a timestamped binary frame. Record the stream → complete session recording. Scrub to any point. Fork from any moment into a new interactive session.

  • Bug reporting: User reports a bug → replay their exact session, scrub to the problem, fork it, debug live
  • Tutorials: Record an interactive tutorial — viewers replay it at their own pace, with full interactivity
  • Undo/redo: Unlimited, branching undo — fork from any point in history
  • Analytics: Replay user sessions to understand behavior (not heatmaps — actual interactive replays)

Why it matters: Every app gets "save game" for free.

3. UI Composition via Signal Mixing

source weather_api | layout dashboard | render tv

Take a data signal stream from a weather API. Take a layout signal from a design tool. Take interaction signals from a game controller. Merge them into one renderer.

  • Dashboards: Compose N data sources into one view without backend
  • Mashups: Overlay a chat stream on a video stream on a data stream
  • Customization: Users pick their own layout for someone else's data

Why it matters: UI becomes composable like Unix pipes.

4. Zero-Install Instant Apps

The receiver doesn't need the app code. It just decodes the bitstream and renders. Connect to ws://app.example.com/stream/main and the full interactive UI appears. Close the tab, it's gone.

  • No download, no permissions, no App Store
  • The app "lives" on the source — viewers are just windows into it
  • Updates are instant — the source changes, all viewers see it immediately
  • Works on any device with a bitstream receiver

Why it matters: Distribution friction drops to zero.

5. Physics-Native Interaction

With ds-physics baked into the language, UI elements aren't positioned — they're simulated.

  • Drag a panel → it continues with momentum
  • Throw a card → it bounces off other cards
  • Pinch a stack → items push apart with spring forces
  • Resize a container → content flows like water

The physics state streams like any other signal. Multiple users can interact with the same physics world simultaneously.

Why it matters: Interfaces feel physical instead of mechanical.

Revenue-Generating Applications

A. Relay-as-a-Service — "Liveblocks Competitor"

Market: $50M+ (Liveblocks $30M raised, PartyKit acquired by Cloudflare, Ably $50M raised)

Sell the bitstream relay as hosted infrastructure:

  • Developers add one stream line to their app
  • Charge per concurrent connection / bandwidth
  • Dashboard with analytics, channel management, auth

Edge over incumbents:

  • Binary protocol (10x smaller than JSON pub/sub)
  • WebRTC auto-upgrade for low latency
  • Signal-graph-aware (not generic pub/sub)
  • Keyframe cache for instant late-join

Ship fast: The relay already works. Add auth, metering, a dashboard.

B. Interactive Live Education — "Nearpod Killer"

Market: $100M+ (Nearpod sold for $650M, Pear Deck acquired by GoGuardian)

Teacher runs a .ds lesson — interactive physics simulation, math visualizer, chemistry model. 30 students connect, see the same simulation, can interact. Teacher sees who's clicking what.

Edge over incumbents:

  • Actual interactive simulations (WASM physics engine), not slides with polls
  • Sub-frame latency via WebRTC
  • Works offline — student can fork and explore independently
  • "Turn any simulation into a live classroom with one line of code"

C. Collaborative Design/Prototyping

Market: $1B+ (Figma worth $20B — multiplayer-by-default was the differentiator)

A .ds file IS a running prototype. Multiple stakeholders view and interact simultaneously. Signal diffs mean only changed state transmits.

Edge over Figma/Framer:

  • DreamStack prototypes are actual running apps, not static mockups
  • They have physics, reactivity, routing
  • They compile to production JS
  • Same file = design AND implementation

D. IoT / Operations Dashboards

Market: $10B+ (Grafana, Datadog, industrial IoT monitoring)

Stream sensor data / device state to multiple monitoring screens. Signal diffs mean minimal bandwidth. Keyframe cache means new operators see current state instantly.

Edge: Binary protocol is 10-100x more efficient than JSON polling. Physics engine enables animated, organic data visualization.

E. Live Commerce / Interactive Shopping

Market: $500B+ globally (live shopping market)

A host demonstrates products. Viewers see the same interactive page — rotate 3D models, change colors, see inventory in real-time. The host controls the flow, viewers interact with products.

Edge: Not a video stream with overlay buttons — a full interactive app where the product page IS the stream.

Demo Prioritization

Demo Effort Wow Factor Revenue Signal
Collaborative Step Sequencer 1 day ⭐⭐⭐⭐⭐ Relay-as-a-Service
Two-Tab Synced Counter 1 hour ⭐⭐⭐ —
Physics Playground 2 days ⭐⭐⭐⭐ Education
Collaborative Whiteboard 2 days ⭐⭐⭐⭐ Design Tool
Session Replay Viewer 3 days ⭐⭐⭐ Analytics
Multi-Surface Dashboard 1 week ⭐⭐⭐⭐⭐ IoT/Operations

Recommended first demo: Collaborative Step Sequencer. It's visual, temporal, interactive, and multiplayer — proving the entire stack in the most visceral way possible. Two browser tabs, one beat grid, instant sync, zero networking code.

Technical Foundation (Complete)

All infrastructure is built and tested:

  • ✅ Bitstream protocol: 16-byte binary header, 6 frame types
  • ✅ Relay v1.0.0: Multi-source routing, keyframe cache, channel GC, max receivers, source reconnection, 54 tests
  • ✅ WASM codec: Shared Rust↔browser encoding (18KB)
  • ✅ WebRTC transport: Peer-to-peer data channels with auto-fallback
  • ✅ Compiler integration: stream keyword, stream from expression, transport: webrtc option
  • ✅ Receiver protocol: All 6 frame types, RLE decode, exponential backoff
  • ✅ 105 tests, 0 failures