# 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**