Real-Time and Streaming System Design Questions

Clarify requirements & constraints

• Target: low-end clients (mobile), visually heavy VFX (smoke/fluid), interactive but not physics-critical, ~50–200 concurrent clients per region, sub-100 ms perceived latency for visual coherence.

High-level architecture

• Clients ⇄ Edge Gateways ⇄ Regional Orchestrator ⇄ Cloud Compute Pool
• Edge hosts short-lived simulation microservices (GPU-accelerated containers) close to players; cloud handles batch/long-running precomputation and replay storage.

Microservice decomposition

• Simulation Service: runs particle/volume sim per scene/zone, exposes delta state (sparse voxels, SDFs, particle snapshots).
• Aggregation Service: merges multi-client inputs, enforces authoritative rules.
• LOD/Compression Service: generates progressive LODs, temporal delta-compression, quantization, entropy coding.
• Sync/Session Service: session membership, tick management, fallback to cloud.
• Replay/Cache Service: stores recent frames and precomputed effects for reuse.

Latency & synchronization

• Use lockstep-independent sims: server authoritative but deterministic seeds; clients predict locally using lightweight solvers for immediate response.
• Server emits keyframes (every N ticks) + high-frequency deltas. Keyframe interval tuned (e.g., 250–500 ms) to balance quality vs bandwidth.
• Timestamped state with interpolation/extrapolation windows; client smooths with easing and particle blending.

Client blending strategy

• Hybrid rendering: client runs low-cost simulation (reduced particle count / noise-based approximations). When server frames arrive:
  • Match by timestamp, compute blend factor based on interpolation window.
  • Fade out local particles and spawn server-authored particles gradually to avoid popping.
  • Use screen-space compositing and depth-aware blending to preserve local effects and lighting.

Failure & retry

• Graceful degradation: if server unreachable, client continues local approximated sim and switches to cached precomputed VFX.
• Exponential backoff + jitter for reconnection; edge fallback to next region; health-check-based reroute.
• Idempotent state patches; sequence numbers and snapshots to resync after long disconnects.

Cost/scale trade-offs

• Edge GPUs expensive — run small, hot pods for active zones; autoscale based on active-sessions-per-zone.
• Use spot instances for cloud precompute; cache hot effects at edge to reduce compute.
• Tune keyframe frequency and compression to trade bandwidth vs server CPU/GPU.
• Instrument metrics: visual divergence, bandwidth, latency, compute cost per active user; optimize LOD thresholds.

Why this works

• Keeps perceived latency low via client prediction and blending, preserves visual fidelity by offloading heavy sims, and ensures resilience and cost control through caching, LOD and hybrid edge/cloud placement—practical for game engines like Unity/Unreal via a networked VFX plugin.