RuView

Wed, 22 Apr 2026 16:52:45 +0800

ruvnet/RuView

π RuView

Beta Software — Under active development. APIs and firmware may change. Known limitations:

ESP32-C3 and original ESP32 are not supported (single-core, insufficient for CSI DSP)

Single ESP32 deployments have limited spatial resolution — use 2+ nodes or add a Cognitum Seed for best results

Camera-free pose accuracy is limited — use camera ground-truth training for 92.9% PCK@20

Contributions and bug reports welcome at Issues.

See through walls with WiFi

Turn ordinary WiFi into a sensing system. Detect people, measure breathing and heart rate, track movement, and monitor rooms — through walls, in the dark, with no cameras or wearables. Just physics.

π RuView is a WiFi sensing platform that turns radio signals into spatial intelligence.

Every WiFi router already fills your space with radio waves. When people move, breathe, or even sit still, they disturb those waves in measurable ways. RuView captures these disturbances using Channel State Information (CSI) from low-cost ESP32 sensors and turns them into actionable data: who’s there, what they’re doing, and whether they’re okay.

What it senses:

Presence and occupancy — detect people through walls, count them, track entries and exits
Vital signs — breathing rate and heart rate, contactless, while sleeping or sitting
Activity recognition — walking, sitting, gestures, falls — from temporal CSI patterns
Environment mapping — RF fingerprinting identifies rooms, detects moved furniture, spots new objects
Sleep quality — overnight monitoring with sleep stage classification and apnea screening

Built on RuVector and Cognitum Seed, RuView runs entirely on edge hardware — an ESP32 mesh (as low as $9 per node) paired with a Cognitum Seed for persistent memory, cryptographic attestation, and AI integration. No cloud, no cameras, no internet required.

The system learns each environment locally using spiking neural networks that adapt in under 30 seconds, with multi-frequency mesh scanning across 6 WiFi channels that uses your neighbors’ routers as free radar illuminators. Every measurement is cryptographically attested via an Ed25519 witness chain.

RuView also supports pose estimation (17 COCO keypoints via the WiFlow architecture), trained entirely without cameras using 10 sensor signals — a technique pioneered from the original DensePose From WiFi research at Carnegie Mellon University.

Built for low-power edge applications

Edge modules are small programs that run directly on the ESP32 sensor — no internet needed, no cloud fees, instant response.

What How Speed

Pose estimation CSI subcarrier amplitude/phase → 17 COCO keypoints 171K emb/s (M4 Pro)

Breathing detection Bandpass 0.1-0.5 Hz → zero-crossing BPM 6-30 BPM

Heart rate Bandpass 0.8-2.0 Hz → zero-crossing BPM 40-120 BPM

Presence sensing Trained model + PIR fusion — 100% accuracy 0.012 ms latency

Through-wall Fresnel zone geometry + multipath modeling Up to 5m depth

Edge intelligence 8-dim feature vectors + RVF store on Cognitum Seed $140 total BOM

Camera-free training 10 sensor signals, no labels needed 84s on M4 Pro

Camera-supervised training MediaPipe + ESP32 CSI → 92.9% PCK@20 19 min on laptop

Multi-frequency mesh Channel hopping across 6 bands, neighbor APs as illuminators 3x sensing bandwidth

What	How	Speed
Pose estimation	CSI subcarrier amplitude/phase → 17 COCO keypoints	171K emb/s (M4 Pro)
Breathing detection	Bandpass 0.1-0.5 Hz → zero-crossing BPM	6-30 BPM
Heart rate	Bandpass 0.8-2.0 Hz → zero-crossing BPM	40-120 BPM
Presence sensing	Trained model + PIR fusion — 100% accuracy	0.012 ms latency
Through-wall	Fresnel zone geometry + multipath modeling	Up to 5m depth
Edge intelligence	8-dim feature vectors + RVF store on Cognitum Seed	$140 total BOM
Camera-free training	10 sensor signals, no labels needed	84s on M4 Pro
Camera-supervised training	MediaPipe + ESP32 CSI → 92.9% PCK@20	19 min on laptop
Multi-frequency mesh	Channel hopping across 6 bands, neighbor APs as illuminators	3x sensing bandwidth

# Option 1: Docker (simulated data, no hardware needed)
docker pull ruvnet/wifi-densepose:latest
docker run -p 3000:3000 ruvnet/wifi-densepose:latest
# Open http://localhost:3000

# Option 2: Live sensing with ESP32-S3 hardware ($9)
# Flash firmware, provision WiFi, and start sensing:
python -m esptool --chip esp32s3 --port COM9 --baud 460800 \
  write_flash 0x0 bootloader.bin 0x8000 partition-table.bin \
  0xf000 ota_data_initial.bin 0x20000 esp32-csi-node.bin
python firmware/esp32-csi-node/provision.py --port COM9 \
  --ssid "YourWiFi" --password "secret" --target-ip 192.168.1.20

# Option 3: Full system with Cognitum Seed ($140)
# ESP32 streams CSI → bridge forwards to Seed for persistent storage + kNN + witness chain
node scripts/rf-scan.js --port 5006           # Live RF room scan
node scripts/snn-csi-processor.js --port 5006  # SNN real-time learning
node scripts/mincut-person-counter.js --port 5006  # Correct person counting

[!NOTE] CSI-capable hardware recommended. Presence, vital signs, through-wall sensing, and all advanced capabilities require Channel State Information (CSI) from an ESP32-S3 ($9) or research NIC. The Docker image runs with simulated data for evaluation. Consumer WiFi laptops provide RSSI-only presence detection.

Hardware options for live CSI capture:

Option Hardware Cost Full CSI Capabilities

ESP32 + Cognitum Seed (recommended) ESP32-S3 + Cognitum Seed ~$140 Yes Pose, breathing, heartbeat, motion, presence + persistent vector store, kNN search, witness chain, MCP proxy

ESP32 Mesh 3-6x ESP32-S3 + WiFi router ~$54 Yes Pose, breathing, heartbeat, motion, presence

Research NIC Intel 5300 / Atheros AR9580 ~$50-100 Yes Full CSI with 3x3 MIMO

Any WiFi Windows, macOS, or Linux laptop $0 No RSSI-only: coarse presence and motion

No hardware? Verify the signal processing pipeline with the deterministic reference signal: python v1/data/proof/verify.py

Option	Hardware	Cost	Full CSI	Capabilities
ESP32 + Cognitum Seed (recommended)	ESP32-S3 + Cognitum Seed	~$140	Yes	Pose, breathing, heartbeat, motion, presence + persistent vector store, kNN search, witness chain, MCP proxy
ESP32 Mesh	3-6x ESP32-S3 + WiFi router	~$54	Yes	Pose, breathing, heartbeat, motion, presence
Research NIC	Intel 5300 / Atheros AR9580	~$50-100	Yes	Full CSI with 3x3 MIMO
Any WiFi	Windows, macOS, or Linux laptop	$0	No	RSSI-only: coarse presence and motion

Real-Time Dense Point Cloud (NEW)

RuView now generates real-time 3D point clouds by fusing camera depth + WiFi CSI + mmWave radar. All sensors stream simultaneously into a unified spatial model.

Sensor	Data	Integration
Camera	MiDaS monocular depth (GPU)	640×480 → 19,200+ depth points per frame
ESP32 CSI	ADR-018 binary frames (UDP)	RF tomography → 8×8×4 occupancy grid
WiFlow Pose	17 COCO keypoints from CSI	Skeleton overlay on point cloud
Vital Signs	Breathing rate from CSI phase	Stored in ruOS brain every 60s
Motion	CSI amplitude variance	Adaptive capture rate (skip depth when still)

Quick start:

cd rust-port/wifi-densepose-rs
cargo build --release -p wifi-densepose-pointcloud
./target/release/ruview-pointcloud serve --bind 127.0.0.1:9880
# Open http://localhost:9880 for live 3D viewer

CLI commands:

ruview-pointcloud demo                            # synthetic demo
ruview-pointcloud serve --bind 127.0.0.1:9880     # live server + Three.js viewer
ruview-pointcloud capture --output room.ply       # capture to PLY
ruview-pointcloud train                           # depth calibration + DPO pairs
ruview-pointcloud cameras                         # list available cameras
ruview-pointcloud csi-test --count 100            # send test CSI frames
ruview-pointcloud fingerprint office --seconds 5  # record named CSI room fingerprint

The HTTP/viewer server defaults to loopback (127.0.0.1) — exposing live camera/CSI/vitals on 0.0.0.0 is an explicit opt-in. Brain URL defaults to http://127.0.0.1:9876 and is overridable via RUVIEW_BRAIN_URL env var or the --brain flag on serve/train.

The pose overlay currently uses an amplitude-energy heuristic (heuristic_pose_from_amplitude) rather than trained WiFlow inference — real ONNX/Candle inference is tracked as a follow-up.

Performance: 22ms pipeline, 905 req/s API, 40K voxel room model from 20 frames.

Brain integration: Spatial observations (motion, vitals, skeleton, occupancy) sync to the ruOS brain every 60 seconds for agent reasoning.

See PR #405 for full details.

What’s New in v0.7.0

Camera Ground-Truth Training — 92.9% PCK@20

v0.7.0 adds camera-supervised pose training using MediaPipe + real ESP32 CSI data:

Capability	What it does	ADR
Camera ground-truth collection	MediaPipe PoseLandmarker captures 17 COCO keypoints at 30fps, synced with ESP32 CSI	ADR-079
ruvector subcarrier selection	Variance-based top-K reduces input by 50% (70→35 subcarriers)	ADR-079 O6
Stoer-Wagner min-cut	Person-specific subcarrier cluster separation for multi-person training	ADR-079 O8
Scalable WiFlow model	4 presets: lite (189K) → small (474K) → medium (800K) → full (7.7M params)	ADR-079

# Collect ground truth (camera + ESP32 simultaneously)
python scripts/collect-ground-truth.py --duration 300 --preview
python scripts/record-csi-udp.py --duration 300

# Align CSI windows with camera keypoints
node scripts/align-ground-truth.js --gt data/ground-truth/*.jsonl --csi data/recordings/*.csi.jsonl

# Train WiFlow model (start lite, scale up as data grows)
node scripts/train-wiflow-supervised.js --data data/paired/*.jsonl --scale lite

# Evaluate
node scripts/eval-wiflow.js --model models/wiflow-real/wiflow-v1.json --data data/paired/*.jsonl

Result: 92.9% PCK@20 from a 5-minute data collection session with one ESP32-S3 and one webcam.

Metric	Before (proxy)	After (camera-supervised)
PCK@20	0%	92.9%
Eval loss	0.700	0.082
Bone constraint	N/A	0.008
Training time	N/A	19 minutes
Model size	N/A	974 KB

Pre-trained model: HuggingFace ruv/ruview/wiflow-v1

Pre-Trained Models (v0.6.0) — No Training Required

Download from HuggingFace and start sensing immediately

Pre-trained models are available on HuggingFace:

https://huggingface.co/ruv/ruview (primary) | mirror

Trained on 60,630 real-world samples from an 8-hour overnight collection. Just download and run — no datasets, no GPU, no training needed.

Model	Size	What it does
`model.safetensors`	48 KB	Contrastive encoder — 128-dim embeddings for presence, activity, environment
`model-q4.bin`	8 KB	4-bit quantized — fits in ESP32-S3 SRAM for edge inference
`model-q2.bin`	4 KB	2-bit ultra-compact for memory-constrained devices
`presence-head.json`	2.6 KB	100% accurate presence detection head
`node-1.json` / `node-2.json`	21 KB	Per-room LoRA adapters (swap for new rooms)

# Download and use (Python)
pip install huggingface_hub
huggingface-cli download ruv/ruview --local-dir models/

# Or use directly with the sensing pipeline
node scripts/train-ruvllm.js --data data/recordings/*.csi.jsonl  # retrain on your own data
node scripts/benchmark-ruvllm.js --model models/csi-ruvllm       # benchmark

Benchmarks (Apple M4 Pro, retrained on overnight data):

What we measured	Result	Why it matters
Presence detection	100% accuracy	Never misses a person, never false alarms
Inference speed	0.008 ms per embedding	125,000x faster than real-time
Throughput	164,183 embeddings/sec	One Mac Mini handles 1,600+ ESP32 nodes
Contrastive learning	51.6% improvement	Strong pattern learning from real overnight data
Model size	8 KB (4-bit quantized)	Fits in ESP32 SRAM — no server needed
Total hardware cost	$140	ESP32 ($9) + Cognitum Seed ($131)

17 Sensing Applications (v0.6.0)

Health, environment, security, and multi-frequency mesh sensing

All applications run from a single ESP32 + optional Cognitum Seed. No camera, no cloud, no internet.

Health & Wellness:

Application	Script	What it detects
Sleep Monitor	`node scripts/sleep-monitor.js`	Sleep stages (deep/light/REM/awake), efficiency, hypnogram
Apnea Detector	`node scripts/apnea-detector.js`	Breathing pauses >10s, AHI severity scoring
Stress Monitor	`node scripts/stress-monitor.js`	Heart rate variability, LF/HF stress ratio
Gait Analyzer	`node scripts/gait-analyzer.js`	Walking cadence, stride asymmetry, tremor detection

Environment & Security:

Application	Script	What it detects
Person Counter	`node scripts/mincut-person-counter.js`	Correct occupancy count (fixes #348)
Room Fingerprint	`node scripts/room-fingerprint.js`	Activity state clustering, daily patterns, anomalies
Material Detector	`node scripts/material-detector.js`	New/moved objects via subcarrier null changes
Device Fingerprint	`node scripts/device-fingerprint.js`	Electronic device activity (printer, router, etc.)

Multi-Frequency Mesh (requires --hop-channels provisioning):

Application	Script	What it detects
RF Tomography	`node scripts/rf-tomography.js`	2D room imaging via RF backprojection
Passive Radar	`node scripts/passive-radar.js`	Neighbor WiFi APs as bistatic radar illuminators
Material Classifier	`node scripts/material-classifier.js`	Metal/water/wood/glass from frequency response
Through-Wall	`node scripts/through-wall-detector.js`	Motion behind walls using lower-frequency penetration

All scripts support --replay data/recordings/*.csi.jsonl for offline analysis and --json for programmatic output.

What’s New in v0.5.5

Advanced Sensing: SNN + MinCut + WiFlow + Multi-Frequency Mesh

v0.5.5 adds four new sensing capabilities built on the ruvector ecosystem:

Capability	What it does	ADR
Spiking Neural Network	Adapts to your room in <30s with STDP online learning — no labels, no batches, 16-160x less compute	ADR-074
MinCut Person Counting	Stoer-Wagner min-cut on subcarrier correlation graph — fixes #348 (was always 4, now correct)	ADR-075
CNN Spectrogram Embeddings	Treat CSI as a 64×20 image → 128-dim embedding for environment fingerprinting (0.95+ similarity)	ADR-076
WiFlow SOTA Architecture	TCN + axial attention + pose decoder → 17 COCO keypoints, 1.8M params (881 KB at 4-bit)	ADR-072
Multi-Frequency Mesh	Channel hopping across 6 bands, neighbor WiFi as passive radar illuminators	ADR-073

# Live RF room scan (spectrum visualization)
node scripts/rf-scan.js --port 5006 --duration 30

# Correct person counting (fixes #348)
node scripts/mincut-person-counter.js --port 5006

# SNN real-time adaptation
node scripts/snn-csi-processor.js --port 5006

# CNN spectrogram embeddings
node scripts/csi-spectrogram.js --replay data/recordings/*.csi.jsonl

# WiFlow 17-keypoint pose training
node scripts/train-wiflow.js --data data/recordings/*.csi.jsonl

# Enable channel hopping on ESP32
python firmware/esp32-csi-node/provision.py --port COM9 --hop-channels "1,6,11"

Validated benchmarks:

Metric	v0.5.4	v0.5.5
Person counting	Broken (always 4)	Correct (MinCut, 24/24)
WiFi channels	1	6 (multi-freq hopping)
Null subcarriers	19% blocked	16% (frequency diversity)
Pose model	16K params (FC only)	1.8M params (WiFlow)
Online adaptation	None	<30s (SNN STDP)
Fingerprint dims	8	128 (CNN spectrogram)
Multi-node fusion	Average	GATv2 attention
New scripts	0	15+
New ADRs	3	8 (069-076)

What’s New in v0.5.4

Cognitum Seed Integration + Camera-Free Pose Training

v0.5.4 transforms RuView from a real-time sensing tool into a persistent edge AI system. Your ESP32 now remembers what it senses, learns without cameras, and proves its data cryptographically.

Capability	Details	Hardware
Persistent vector store	Every sensing event stored as searchable 8-dim vector in RVF format	ESP32 + Cognitum Seed ($140)
kNN similarity search	“Find the 10 most similar states to right now” — anomaly detection, fingerprinting	Cognitum Seed
Witness chain	SHA-256 tamper-evident audit trail for every measurement (1,747 entries validated)	Cognitum Seed
Camera-free pose training	17 COCO keypoints from 10 sensor signals — PIR, RSSI triangulation, subcarrier asymmetry, vibration, BME280	2x ESP32 + Seed
Pre-trained model	82.8 KB (8 KB at 4-bit quantization), 100% presence accuracy, 0 skeleton violations	Download from release
Sub-ms inference	0.012 ms latency, 171,472 embeddings/sec on M4 Pro	Any machine with Node.js
SONA adaptation	Adapts to new rooms in <1ms without retraining	ruvllm runtime
LoRA room adapters	Per-node fine-tuning with 2,048 parameters per adapter	Automatic
114-tool MCP proxy	AI assistants (Claude, GPT) query sensors directly via JSON-RPC	Cognitum Seed
Multi-frequency mesh	Channel hopping across ch 1/3/5/6/9/11 — neighbor WiFi as passive radar	2x ESP32 ($18)
RF room scanner	Real-time spectrum visualization: nulls, reflectors, movement, multipath	`node scripts/rf-scan.js`
Security hardened	Bearer tokens, TLS, source IP filtering, NaN rejection, credential rotation	All components

Training pipeline (ruvllm, no PyTorch needed):

# Collect data (2 min, ESP32s must be streaming)
python scripts/collect-training-data.py --port 5006 --duration 120

# Train — contrastive pretraining + task heads + LoRA + quantization + EWC
node scripts/train-ruvllm.js --data data/recordings/pretrain-*.csi.jsonl

# Camera-free 17-keypoint pose (uses PIR + RSSI + vibration + subcarrier asymmetry)
node scripts/train-camera-free.js --data data/recordings/pretrain-*.csi.jsonl

# Benchmark
node scripts/benchmark-ruvllm.js --model models/csi-ruvllm

Benchmarks — validated on real hardware (Apple M4 Pro + ESP32-S3 + Cognitum Seed):

What we measured	Result	Why it matters
Presence detection	100% accuracy	Never misses a person, never false alarms
Person counting	24/24 correct (MinCut)	Fixed the #1 user-reported issue
Inference speed	0.012 ms per embedding	83,000x faster than real-time
Throughput	171,472 embeddings/sec	One Mac Mini handles 1,700+ ESP32 nodes
Training time	84 seconds	From zero to trained model in under 2 minutes
Contrastive learning	33.9% improvement	Model learns meaningful patterns from CSI
Model size	8 KB (4-bit quantized)	Fits in ESP32 SRAM — no server needed
Skeleton physics	0 violations in 100 frames	Every pose is anatomically valid
Pose keypoints	17 COCO keypoints	Full body pose, no camera required
WiFi channels	6 simultaneous	3x more sensing data than single-channel
Online adaptation	<30 seconds (SNN)	Learns a new room without retraining
Witness chain	2,547 entries verified	Cryptographic proof every measurement is real
Test suite	1,463 tests passed	Rock-solid foundation
Total hardware cost	$140	ESP32 ($9) + Cognitum Seed ($131)

See ADR-069, ADR-071, and the Cognitum Seed tutorial for full details.

📖 Documentation

Document	Description
User Guide	Step-by-step guide: installation, first run, API usage, hardware setup, training
Build Guide	Building from source (Rust and Python)
Architecture Decisions	79 ADRs — why each technical choice was made, organized by domain (hardware, signal processing, ML, platform, infrastructure)
Domain Models	7 DDD models (RuvSense, Signal Processing, Training Pipeline, Hardware Platform, Sensing Server, WiFi-Mat, CHCI) — bounded contexts, aggregates, domain events, and ubiquitous language
Desktop App	WIP — Tauri v2 desktop app for node management, OTA updates, WASM deployment, and mesh visualization
Medical Examples	Contactless blood pressure, heart rate, breathing rate via 60 GHz mmWave radar — $15 hardware, no wearable

Real-time pose skeleton from WiFi CSI signals — no cameras, no wearables

▶ Live Observatory Demo | ▶ Dual-Modal Pose Fusion Demo

The server is optional for visualization and aggregation — the ESP32 runs independently for presence detection, vital signs, and fall alerts.

Live ESP32 pipeline: Connect an ESP32-S3 node → run the sensing server → open the pose fusion demo for real-time dual-modal pose estimation (webcam + WiFi CSI). See ADR-059.

🚀 Key Features

Sensing

See people, breathing, and heartbeats through walls — using only WiFi signals already in the room.

	Feature	What It Means
🔒	Privacy-First	Tracks human pose using only WiFi signals — no cameras, no video, no images stored
💓	Vital Signs	Detects breathing rate (6-30 breaths/min) and heart rate (40-120 bpm) without any wearable
👥	Multi-Person	Tracks multiple people simultaneously, each with independent pose and vitals — no hard software limit (physics: ~3-5 per AP with 56 subcarriers, more with multi-AP)
🧱	Through-Wall	WiFi passes through walls, furniture, and debris — works where cameras cannot
🚑	Disaster Response	Detects trapped survivors through rubble and classifies injury severity (START triage)
📡	Multistatic Mesh	4-6 low-cost sensor nodes work together, combining 12+ overlapping signal paths for full 360-degree room coverage with sub-inch accuracy and no person mix-ups (ADR-029)
🌐	Persistent Field Model	The system learns the RF signature of each room — then subtracts the room to isolate human motion, detect drift over days, predict intent before movement starts, and flag spoofing attempts (ADR-030)

Intelligence

The system learns on its own and gets smarter over time — no hand-tuning, no labeled data required.

	Feature	What It Means
🧠	Self-Learning	Teaches itself from raw WiFi data — no labeled training sets, no cameras needed to bootstrap (ADR-024)
🎯	AI Signal Processing	Attention networks, graph algorithms, and smart compression replace hand-tuned thresholds — adapts to each room automatically (RuVector)
🌍	Works Everywhere	Train once, deploy in any room — adversarial domain generalization strips environment bias so models transfer across rooms, buildings, and hardware (ADR-027)
👁️	Cross-Viewpoint Fusion	AI combines what each sensor sees from its own angle — fills in blind spots and depth ambiguity that no single viewpoint can resolve on its own (ADR-031)
🔮	Signal-Line Protocol	A 6-stage processing pipeline transforms raw WiFi signals into structured body representations — from signal cleanup through graph-based spatial reasoning to final pose output (ADR-033)
🔒	QUIC Mesh Security	All sensor-to-sensor communication is encrypted end-to-end with tamper detection, replay protection, and seamless reconnection if a node moves or drops offline (ADR-032)
🎯	Adaptive Classifier	Records labeled CSI sessions, trains a 15-feature logistic regression model in pure Rust, and learns your room’s unique signal characteristics — replaces hand-tuned thresholds with data-driven classification (ADR-048)

Performance & Deployment

Fast enough for real-time use, small enough for edge devices, simple enough for one-command setup.

	Feature	What It Means
⚡	Real-Time	Analyzes WiFi signals in under 100 microseconds per frame — fast enough for live monitoring
🦀	810x Faster	Complete Rust rewrite: 54,000 frames/sec pipeline, multi-arch Docker image, 1,031+ tests
🐳	One-Command Setup	`docker pull ruvnet/wifi-densepose:latest` — live sensing in 30 seconds, no toolchain needed (amd64 + arm64 / Apple Silicon)
📡	Fully Local	Runs completely on a $9 ESP32 — no internet connection, no cloud account, no recurring fees. Detects presence, vital signs, and falls on-device with instant response
📦	Portable Models	Trained models package into a single `.rvf` file — runs on edge, cloud, or browser (WASM)
🔭	Observatory Visualization	Cinematic Three.js dashboard with 5 holographic panels — subcarrier manifold, vital signs oracle, presence heatmap, phase constellation, convergence engine — all driven by live or demo CSI data (ADR-047)
📟	AMOLED Display	ESP32-S3 boards with built-in AMOLED screens show real-time presence, vital signs, and room status directly on the sensor — no phone or PC needed (ADR-045)

🔬 How It Works

WiFi routers flood every room with radio waves. When a person moves — or even breathes — those waves scatter differently. WiFi DensePose reads that scattering pattern and reconstructs what happened:

WiFi Router → radio waves pass through room → hit human body → scatter
    ↓
ESP32 mesh (4-6 nodes) captures CSI on channels 1/6/11 via TDM protocol
    ↓
Multi-Band Fusion: 3 channels × 56 subcarriers = 168 virtual subcarriers per link
    ↓
Multistatic Fusion: N×(N-1) links → attention-weighted cross-viewpoint embedding
    ↓
Coherence Gate: accept/reject measurements → stable for days without tuning
    ↓
Signal Processing: Hampel, SpotFi, Fresnel, BVP, spectrogram → clean features
    ↓
AI Backbone (RuVector): attention, graph algorithms, compression, field model
    ↓
Signal-Line Protocol (CRV): 6-stage gestalt → sensory → topology → coherence → search → model
    ↓
Neural Network: processed signals → 17 body keypoints + vital signs + room model
    ↓
Output: real-time pose, breathing, heart rate, room fingerprint, drift alerts

No training cameras required — the Self-Learning system (ADR-024) bootstraps from raw WiFi data alone. MERIDIAN (ADR-027) ensures the model works in any room, not just the one it trained in.

🏢 Use Cases & Applications

WiFi sensing works anywhere WiFi exists. No new hardware in most cases — just software on existing access points or a $8 ESP32 add-on. Because there are no cameras, deployments avoid privacy regulations (GDPR video, HIPAA imaging) by design.

Scaling: Each AP distinguishes ~3-5 people (56 subcarriers). Multi-AP multiplies linearly — a 4-AP retail mesh covers ~15-20 occupants. No hard software limit; the practical ceiling is signal physics.

	Why WiFi sensing wins	Traditional alternative
🔒	No video, no GDPR/HIPAA imaging rules	Cameras require consent, signage, data retention policies
🧱	Works through walls, shelving, debris	Cameras need line-of-sight per room
🌙	Works in total darkness	Cameras need IR or visible light
💰	$0-$8 per zone (existing WiFi or ESP32)	Camera systems: $200-$2,000 per zone
🔌	WiFi already deployed everywhere	PIR/radar sensors require new wiring per room

🏥 Everyday — Healthcare, retail, office, hospitality (commodity WiFi)

Use Case	What It Does	Hardware	Key Metric	Edge Module
Elderly care / assisted living	Fall detection, nighttime activity monitoring, breathing rate during sleep — no wearable compliance needed	1 ESP32-S3 per room ($8)	Fall alert <2s	Sleep Apnea, Gait Analysis
Hospital patient monitoring	Continuous breathing + heart rate for non-critical beds without wired sensors; nurse alert on anomaly	1-2 APs per ward	Breathing: 6-30 BPM	Respiratory Distress, Cardiac Arrhythmia
Emergency room triage	Automated occupancy count + wait-time estimation; detect patient distress (abnormal breathing) in waiting areas	Existing hospital WiFi	Occupancy accuracy >95%	Queue Length, Panic Motion
Retail occupancy & flow	Real-time foot traffic, dwell time by zone, queue length — no cameras, no opt-in, GDPR-friendly	Existing store WiFi + 1 ESP32	Dwell resolution ~1m	Customer Flow, Dwell Heatmap
Office space utilization	Which desks/rooms are actually occupied, meeting room no-shows, HVAC optimization based on real presence	Existing enterprise WiFi	Presence latency <1s	Meeting Room, HVAC Presence
Hotel & hospitality	Room occupancy without door sensors, minibar/bathroom usage patterns, energy savings on empty rooms	Existing hotel WiFi	15-30% HVAC savings	Energy Audit, Lighting Zones
Restaurants & food service	Table turnover tracking, kitchen staff presence, restroom occupancy displays — no cameras in dining areas	Existing WiFi	Queue wait ±30s	Table Turnover, Queue Length
Parking garages	Pedestrian presence in stairwells and elevators where cameras have blind spots; security alert if someone lingers	Existing WiFi	Through-concrete walls	Loitering, Elevator Count

🏟️ Specialized — Events, fitness, education, civic (CSI-capable hardware)

Use Case	What It Does	Hardware	Key Metric	Edge Module
Smart home automation	Room-level presence triggers (lights, HVAC, music) that work through walls — no dead zones, no motion-sensor timeouts	2-3 ESP32-S3 nodes ($24)	Through-wall range ~5m	HVAC Presence, Lighting Zones
Fitness & sports	Rep counting, posture correction, breathing cadence during exercise — no wearable, no camera in locker rooms	3+ ESP32-S3 mesh	Pose: 17 keypoints	Breathing Sync, Gait Analysis
Childcare & schools	Naptime breathing monitoring, playground headcount, restricted-area alerts — privacy-safe for minors	2-4 ESP32-S3 per zone	Breathing: ±1 BPM	Sleep Apnea, Perimeter Breach
Event venues & concerts	Crowd density mapping, crush-risk detection via breathing compression, emergency evacuation flow tracking	Multi-AP mesh (4-8 APs)	Density per m²	Customer Flow, Panic Motion
Stadiums & arenas	Section-level occupancy for dynamic pricing, concession staffing, emergency egress flow modeling	Enterprise AP grid	15-20 per AP mesh	Dwell Heatmap, Queue Length
Houses of worship	Attendance counting without facial recognition — privacy-sensitive congregations, multi-room campus tracking	Existing WiFi	Zone-level accuracy	Elevator Count, Energy Audit
Warehouse & logistics	Worker safety zones, forklift proximity alerts, occupancy in hazardous areas — works through shelving and pallets	Industrial AP mesh	Alert latency <500ms	Forklift Proximity, Confined Space
Civic infrastructure	Public restroom occupancy (no cameras possible), subway platform crowding, shelter headcount during emergencies	Municipal WiFi + ESP32	Real-time headcount	Customer Flow, Loitering
Museums & galleries	Visitor flow heatmaps, exhibit dwell time, crowd bottleneck alerts — no cameras near artwork (flash/theft risk)	Existing WiFi	Zone dwell ±5s	Dwell Heatmap, Shelf Engagement

🤖 Robotics & Industrial — Autonomous systems, manufacturing, android spatial awareness

WiFi sensing gives robots and autonomous systems a spatial awareness layer that works where LIDAR and cameras fail — through dust, smoke, fog, and around corners. The CSI signal field acts as a “sixth sense” for detecting humans in the environment without requiring line-of-sight.

Use Case	What It Does	Hardware	Key Metric	Edge Module
Cobot safety zones	Detect human presence near collaborative robots — auto-slow or stop before contact, even behind obstructions	2-3 ESP32-S3 per cell	Presence latency <100ms	Forklift Proximity, Perimeter Breach
Warehouse AMR navigation	Autonomous mobile robots sense humans around blind corners, through shelving racks — no LIDAR occlusion	ESP32 mesh along aisles	Through-shelf detection	Forklift Proximity, Loitering
Android / humanoid spatial awareness	Ambient human pose sensing for social robots — detect gestures, approach direction, and personal space without cameras always on	Onboard ESP32-S3 module	17-keypoint pose	Gesture Language, Emotion Detection
Manufacturing line monitoring	Worker presence at each station, ergonomic posture alerts, headcount for shift compliance — works through equipment	Industrial AP per zone	Pose + breathing	Confined Space, Gait Analysis
Construction site safety	Exclusion zone enforcement around heavy machinery, fall detection from scaffolding, personnel headcount	Ruggedized ESP32 mesh	Alert <2s, through-dust	Panic Motion, Structural Vibration
Agricultural robotics	Detect farm workers near autonomous harvesters in dusty/foggy field conditions where cameras are unreliable	Weatherproof ESP32 nodes	Range ~10m open field	Forklift Proximity, Rain Detection
Drone landing zones	Verify landing area is clear of humans — WiFi sensing works in rain, dust, and low light where downward cameras fail	Ground ESP32 nodes	Presence: >95% accuracy	Perimeter Breach, Tailgating
Clean room monitoring	Personnel tracking without cameras (particle contamination risk from camera fans) — gown compliance via pose	Existing cleanroom WiFi	No particulate emission	Clean Room, Livestock Monitor

🔥 Extreme — Through-wall, disaster, defense, underground

These scenarios exploit WiFi’s ability to penetrate solid materials — concrete, rubble, earth — where no optical or infrared sensor can reach. The WiFi-Mat disaster module (ADR-001) is specifically designed for this tier.

Use Case	What It Does	Hardware	Key Metric	Edge Module
Search & rescue (WiFi-Mat)	Detect survivors through rubble/debris via breathing signature, START triage color classification, 3D localization	Portable ESP32 mesh + laptop	Through 30cm concrete	Respiratory Distress, Seizure Detection
Firefighting	Locate occupants through smoke and walls before entry; breathing detection confirms life signs remotely	Portable mesh on truck	Works in zero visibility	Sleep Apnea, Panic Motion
Prison & secure facilities	Cell occupancy verification, distress detection (abnormal vitals), perimeter sensing — no camera blind spots	Dedicated AP infrastructure	24/7 vital signs	Cardiac Arrhythmia, Loitering
Military / tactical	Through-wall personnel detection, room clearing confirmation, hostage vital signs at standoff distance	Directional WiFi + custom FW	Range: 5m through wall	Perimeter Breach, Weapon Detection
Border & perimeter security	Detect human presence in tunnels, behind fences, in vehicles — passive sensing, no active illumination to reveal position	Concealed ESP32 mesh	Passive / covert	Perimeter Breach, Tailgating
Mining & underground	Worker presence in tunnels where GPS/cameras fail, breathing detection after collapse, headcount at safety points	Ruggedized ESP32 mesh	Through rock/earth	Confined Space, Respiratory Distress
Maritime & naval	Below-deck personnel tracking through steel bulkheads (limited range, requires tuning), man-overboard detection	Ship WiFi + ESP32	Through 1-2 bulkheads	Structural Vibration, Panic Motion
Wildlife research	Non-invasive animal activity monitoring in enclosures or dens — no light pollution, no visual disturbance	Weatherproof ESP32 nodes	Zero light emission	Livestock Monitor, Dream Stage

Edge Intelligence (ADR-041)

Small programs that run directly on the ESP32 sensor — no internet needed, no cloud fees, instant response. Each module is a tiny WASM file (5-30 KB) that you upload to the device over-the-air. It reads WiFi signal data and makes decisions locally in under 10 ms. ADR-041 defines 60 modules across 13 categories — all 60 are implemented with 609 tests passing.

	Category	Examples
🏥	Medical & Health	Sleep apnea detection, cardiac arrhythmia, gait analysis, seizure detection
🔐	Security & Safety	Intrusion detection, perimeter breach, loitering, panic motion
🏢	Smart Building	Zone occupancy, HVAC control, elevator counting, meeting room tracking
🛒	Retail & Hospitality	Queue length, dwell heatmaps, customer flow, table turnover
🏭	Industrial	Forklift proximity, confined space monitoring, structural vibration
🔮	Exotic & Research	Sleep staging, emotion detection, sign language, breathing sync
📡	Signal Intelligence	Cleans and sharpens raw WiFi signals — focuses on important regions, filters noise, fills in missing data, and tracks which person is which
🧠	Adaptive Learning	The sensor learns new gestures and patterns on its own over time — no cloud needed, remembers what it learned even after updates
🗺️	Spatial Reasoning	Figures out where people are in a room, which zones matter most, and tracks movement across areas using graph-based spatial logic
⏱️	Temporal Analysis	Learns daily routines, detects when patterns break (someone didn’t get up), and verifies safety rules are being followed over time
🛡️	AI Security	Detects signal replay attacks, WiFi jamming, injection attempts, and flags abnormal behavior that could indicate tampering
⚛️	Quantum-Inspired	Uses quantum-inspired math to map room-wide signal coherence and search for optimal sensor configurations
🤖	Autonomous & Exotic	Self-managing sensor mesh — auto-heals dropped nodes, plans its own actions, and explores experimental signal representations

All implemented modules are no_std Rust, share a common utility library, and talk to the host through a 12-function API. Full documentation: Edge Modules Guide. See the complete implemented module list below.

🧩 Edge Intelligence — All 65 Modules Implemented (ADR-041 complete)

All 60 modules are implemented, tested (609 tests passing), and ready to deploy. They compile to wasm32-unknown-unknown, run on ESP32-S3 via WASM3, and share a common utility library. Source: crates/wifi-densepose-wasm-edge/src/

Core modules (ADR-040 flagship + early implementations):

Module	File	What It Does
Gesture Classifier	`gesture.rs`	DTW template matching for hand gestures
Coherence Filter	`coherence.rs`	Phase coherence gating for signal quality
Adversarial Detector	`adversarial.rs`	Detects physically impossible signal patterns
Intrusion Detector	`intrusion.rs`	Human vs non-human motion classification
Occupancy Counter	`occupancy.rs`	Zone-level person counting
Vital Trend	`vital_trend.rs`	Long-term breathing and heart rate trending
RVF Parser	`rvf.rs`	RVF container format parsing

Vendor-integrated modules (24 modules, ADR-041 Category 7):

📡 Signal Intelligence — Real-time CSI analysis and feature extraction

Module	File	What It Does	Budget
Flash Attention	`sig_flash_attention.rs`	Tiled attention over 8 subcarrier groups — finds spatial focus regions and entropy	S (<5ms)
Coherence Gate	`sig_coherence_gate.rs`	Z-score phasor gating with hysteresis: Accept / PredictOnly / Reject / Recalibrate	L (<2ms)
Temporal Compress	`sig_temporal_compress.rs`	3-tier adaptive quantization (8-bit hot / 5-bit warm / 3-bit cold)	L (<2ms)
Sparse Recovery	`sig_sparse_recovery.rs`	ISTA L1 reconstruction for dropped subcarriers	H (<10ms)
Person Match	`sig_mincut_person_match.rs`	Hungarian-lite bipartite assignment for multi-person tracking	S (<5ms)
Optimal Transport	`sig_optimal_transport.rs`	Sliced Wasserstein-1 distance with 4 projections	L (<2ms)

🧠 Adaptive Learning — On-device learning without cloud connectivity

Module	File	What It Does	Budget
DTW Gesture Learn	`lrn_dtw_gesture_learn.rs`	User-teachable gesture recognition — 3-rehearsal protocol, 16 templates	S (<5ms)
Anomaly Attractor	`lrn_anomaly_attractor.rs`	4D dynamical system attractor classification with Lyapunov exponents	H (<10ms)
Meta Adapt	`lrn_meta_adapt.rs`	Hill-climbing self-optimization with safety rollback	L (<2ms)
EWC Lifelong	`lrn_ewc_lifelong.rs`	Elastic Weight Consolidation — remembers past tasks while learning new ones	S (<5ms)

🗺️ Spatial Reasoning — Location, proximity, and influence mapping

Module	File	What It Does	Budget
PageRank Influence	`spt_pagerank_influence.rs`	4x4 cross-correlation graph with power iteration PageRank	L (<2ms)
Micro HNSW	`spt_micro_hnsw.rs`	64-vector navigable small-world graph for nearest-neighbor search	S (<5ms)
Spiking Tracker	`spt_spiking_tracker.rs`	32 LIF neurons + 4 output zone neurons with STDP learning	S (<5ms)

⏱️ Temporal Analysis — Activity patterns, logic verification, autonomous planning

Module	File	What It Does	Budget
Pattern Sequence	`tmp_pattern_sequence.rs`	Activity routine detection and deviation alerts	S (<5ms)
Temporal Logic Guard	`tmp_temporal_logic_guard.rs`	LTL formula verification on CSI event streams	S (<5ms)
GOAP Autonomy	`tmp_goap_autonomy.rs`	Goal-Oriented Action Planning for autonomous module management	S (<5ms)

🛡️ AI Security — Tamper detection and behavioral anomaly profiling

Module	File	What It Does	Budget
Prompt Shield	`ais_prompt_shield.rs`	FNV-1a replay detection, injection detection (10x amplitude), jamming (SNR)	L (<2ms)
Behavioral Profiler	`ais_behavioral_profiler.rs`	6D behavioral profile with Mahalanobis anomaly scoring	S (<5ms)

⚛️ Quantum-Inspired — Quantum computing metaphors applied to CSI analysis

Module	File	What It Does	Budget
Quantum Coherence	`qnt_quantum_coherence.rs`	Bloch sphere mapping, Von Neumann entropy, decoherence detection	S (<5ms)
Interference Search	`qnt_interference_search.rs`	16 room-state hypotheses with Grover-inspired oracle + diffusion	S (<5ms)

🤖 Autonomous Systems — Self-governing and self-healing behaviors

Module	File	What It Does	Budget
Psycho-Symbolic	`aut_psycho_symbolic.rs`	16-rule forward-chaining knowledge base with contradiction detection	S (<5ms)
Self-Healing Mesh	`aut_self_healing_mesh.rs`	8-node mesh with health tracking, degradation/recovery, coverage healing	S (<5ms)

🔮 Exotic (Vendor) — Novel mathematical models for CSI interpretation

Module	File	What It Does	Budget
Time Crystal	`exo_time_crystal.rs`	Autocorrelation subharmonic detection in 256-frame history	S (<5ms)
Hyperbolic Space	`exo_hyperbolic_space.rs`	Poincare ball embedding with 32 reference locations, hyperbolic distance	S (<5ms)

🏥 Medical & Health (Category 1) — Contactless health monitoring

Module	File	What It Does	Budget
Sleep Apnea	`med_sleep_apnea.rs`	Detects breathing pauses during sleep	S (<5ms)
Cardiac Arrhythmia	`med_cardiac_arrhythmia.rs`	Monitors heart rate for irregular rhythms	S (<5ms)
Respiratory Distress	`med_respiratory_distress.rs`	Alerts on abnormal breathing patterns	S (<5ms)
Gait Analysis	`med_gait_analysis.rs`	Tracks walking patterns and detects changes	S (<5ms)
Seizure Detection	`med_seizure_detect.rs`	6-state machine for tonic-clonic seizure recognition	S (<5ms)

🔐 Security & Safety (Category 2) — Perimeter and threat detection

Module	File	What It Does	Budget
Perimeter Breach	`sec_perimeter_breach.rs`	Detects boundary crossings with approach/departure	S (<5ms)
Weapon Detection	`sec_weapon_detect.rs`	Metal anomaly detection via CSI amplitude shifts	S (<5ms)
Tailgating	`sec_tailgating.rs`	Detects unauthorized follow-through at access points	S (<5ms)
Loitering	`sec_loitering.rs`	Alerts when someone lingers too long in a zone	S (<5ms)
Panic Motion	`sec_panic_motion.rs`	Detects fleeing, struggling, or panic movement	S (<5ms)

🏢 Smart Building (Category 3) — Automation and energy efficiency

Module	File	What It Does	Budget
HVAC Presence	`bld_hvac_presence.rs`	Occupancy-driven HVAC control with departure countdown	S (<5ms)
Lighting Zones	`bld_lighting_zones.rs`	Auto-dim/off lighting based on zone activity	S (<5ms)
Elevator Count	`bld_elevator_count.rs`	Counts people entering/leaving with overload warning	S (<5ms)
Meeting Room	`bld_meeting_room.rs`	Tracks meeting lifecycle: start, headcount, end, availability	S (<5ms)
Energy Audit	`bld_energy_audit.rs`	Tracks after-hours usage and room utilization rates	S (<5ms)

🛒 Retail & Hospitality (Category 4) — Customer insights without cameras

Module	File	What It Does	Budget
Queue Length	`ret_queue_length.rs`	Estimates queue size and wait times	S (<5ms)
Dwell Heatmap	`ret_dwell_heatmap.rs`	Shows where people spend time (hot/cold zones)	S (<5ms)
Customer Flow	`ret_customer_flow.rs`	Counts ins/outs and tracks net occupancy	S (<5ms)
Table Turnover	`ret_table_turnover.rs`	Restaurant table lifecycle: seated, dining, vacated	S (<5ms)
Shelf Engagement	`ret_shelf_engagement.rs`	Detects browsing, considering, and reaching for products	S (<5ms)

🏭 Industrial & Specialized (Category 5) — Safety and compliance

Module	File	What It Does	Budget
Forklift Proximity	`ind_forklift_proximity.rs`	Warns when people get too close to vehicles	S (<5ms)
Confined Space	`ind_confined_space.rs`	OSHA-compliant worker monitoring with extraction alerts	S (<5ms)
Clean Room	`ind_clean_room.rs`	Occupancy limits and turbulent motion detection	S (<5ms)
Livestock Monitor	`ind_livestock_monitor.rs`	Animal presence, stillness, and escape alerts	S (<5ms)
Structural Vibration	`ind_structural_vibration.rs`	Seismic events, mechanical resonance, structural drift	S (<5ms)

🔮 Exotic & Research (Category 6) — Experimental sensing applications

Module	File	What It Does	Budget
Dream Stage	`exo_dream_stage.rs`	Contactless sleep stage classification (wake/light/deep/REM)	S (<5ms)
Emotion Detection	`exo_emotion_detect.rs`	Arousal, stress, and calm detection from micro-movements	S (<5ms)
Gesture Language	`exo_gesture_language.rs`	Sign language letter recognition via WiFi	S (<5ms)
Music Conductor	`exo_music_conductor.rs`	Tempo and dynamic tracking from conducting gestures	S (<5ms)
Plant Growth	`exo_plant_growth.rs`	Monitors plant growth, circadian rhythms, wilt detection	S (<5ms)
Ghost Hunter	`exo_ghost_hunter.rs`	Environmental anomaly classification (draft/insect/wind/unknown)	S (<5ms)
Rain Detection	`exo_rain_detect.rs`	Detects rain onset, intensity, and cessation via signal scatter	S (<5ms)
Breathing Sync	`exo_breathing_sync.rs`	Detects synchronized breathing between multiple people	S (<5ms)

🧠 Self-Learning WiFi AI (ADR-024) — Adaptive recognition, self-optimization, and intelligent anomaly detection

Every WiFi signal that passes through a room creates a unique fingerprint of that space. WiFi-DensePose already reads these fingerprints to track people, but until now it threw away the internal “understanding” after each reading. The Self-Learning WiFi AI captures and preserves that understanding as compact, reusable vectors — and continuously optimizes itself for each new environment.

What it does in plain terms:

Turns any WiFi signal into a 128-number “fingerprint” that uniquely describes what’s happening in a room
Learns entirely on its own from raw WiFi data — no cameras, no labeling, no human supervision needed
Recognizes rooms, detects intruders, identifies people, and classifies activities using only WiFi
Runs on an $8 ESP32 chip (the entire model fits in 55 KB of memory)
Produces both body pose tracking AND environment fingerprints in a single computation

Key Capabilities

What	How it works	Why it matters
Self-supervised learning	The model watches WiFi signals and teaches itself what “similar” and “different” look like, without any human-labeled data	Deploy anywhere — just plug in a WiFi sensor and wait 10 minutes
Room identification	Each room produces a distinct WiFi fingerprint pattern	Know which room someone is in without GPS or beacons
Anomaly detection	An unexpected person or event creates a fingerprint that doesn’t match anything seen before	Automatic intrusion and fall detection as a free byproduct
Person re-identification	Each person disturbs WiFi in a slightly different way, creating a personal signature	Track individuals across sessions without cameras
Environment adaptation	MicroLoRA adapters (1,792 parameters per room) fine-tune the model for each new space	Adapts to a new room with minimal data — 93% less than retraining from scratch
Memory preservation	EWC++ regularization remembers what was learned during pretraining	Switching to a new task doesn’t erase prior knowledge
Hard-negative mining	Training focuses on the most confusing examples to learn faster	Better accuracy with the same amount of training data

Architecture

1
2
3

WiFi Signal [56 channels] → Transformer + Graph Neural Network
                                  ├→ 128-dim environment fingerprint (for search + identification)
                                  └→ 17-joint body pose (for human tracking)

Quick Start

# Step 1: Learn from raw WiFi data (no labels needed)
cargo run -p wifi-densepose-sensing-server -- --pretrain --dataset data/csi/ --pretrain-epochs 50

# Step 2: Fine-tune with pose labels for full capability
cargo run -p wifi-densepose-sensing-server -- --train --dataset data/mmfi/ --epochs 100 --save-rvf model.rvf

# Step 3: Use the model — extract fingerprints from live WiFi
cargo run -p wifi-densepose-sensing-server -- --model model.rvf --embed

# Step 4: Search — find similar environments or detect anomalies
cargo run -p wifi-densepose-sensing-server -- --model model.rvf --build-index env

Training Modes

Mode	What you need	What you get
Self-Supervised	Just raw WiFi data	A model that understands WiFi signal structure
Supervised	WiFi data + body pose labels	Full pose tracking + environment fingerprints
Cross-Modal	WiFi data + camera footage	Fingerprints aligned with visual understanding

Fingerprint Index Types

Index	What it stores	Real-world use
`env_fingerprint`	Average room fingerprint	“Is this the kitchen or the bedroom?”
`activity_pattern`	Activity boundaries	“Is someone cooking, sleeping, or exercising?”
`temporal_baseline`	Normal conditions	“Something unusual just happened in this room”
`person_track`	Individual movement signatures	“Person A just entered the living room”

Model Size

Component	Parameters	Memory (on ESP32)
Transformer backbone	~28,000	28 KB
Embedding projection head	~25,000	25 KB
Per-room MicroLoRA adapter	~1,800	2 KB
Total	~55,000	55 KB (of 520 KB available)

The self-learning system builds on the AI Backbone (RuVector) signal-processing layer — attention, graph algorithms, and compression — adding contrastive learning on top.

See docs/adr/ADR-024-contrastive-csi-embedding-model.md for full architectural details.

📦 Installation

Guided Installer — Interactive hardware detection and profile selection

`1`	`./install.sh`

The installer walks through 7 steps: system detection, toolchain check, WiFi hardware scan, profile recommendation, dependency install, build, and verification.

Profile	What it installs	Size	Requirements
`verify`	Pipeline verification only	~5 MB	Python 3.8+
`python`	Full Python API server + sensing	~500 MB	Python 3.8+
`rust`	Rust pipeline (~810x faster)	~200 MB	Rust 1.70+
`browser`	WASM for in-browser execution	~10 MB	Rust + wasm-pack
`iot`	ESP32 sensor mesh + aggregator	varies	Rust + ESP-IDF
`docker`	Docker-based deployment	~1 GB	Docker
`field`	WiFi-Mat disaster response kit	~62 MB	Rust + wasm-pack
`full`	Everything available	~2 GB	All toolchains

# Non-interactive
./install.sh --profile rust --yes

# Hardware check only
./install.sh --check-only

From Source — Rust (primary) or Python

git clone https://github.com/ruvnet/RuView.git
cd RuView

# Rust (primary — 810x faster)
cd rust-port/wifi-densepose-rs
cargo build --release
cargo test --workspace

# Python (legacy v1)
pip install -r requirements.txt
pip install -e .

# Or via pip
pip install wifi-densepose
pip install wifi-densepose[gpu]   # GPU acceleration
pip install wifi-densepose[all]   # All optional deps

Docker — Pre-built images, no toolchain needed

# Rust sensing server (132 MB — recommended)
docker pull ruvnet/wifi-densepose:latest
docker run -p 3000:3000 -p 3001:3001 -p 5005:5005/udp ruvnet/wifi-densepose:latest

# Python sensing pipeline (569 MB)
docker pull ruvnet/wifi-densepose:python
docker run -p 8765:8765 -p 8080:8080 ruvnet/wifi-densepose:python

# Both via docker-compose
cd docker && docker compose up

# Export RVF model
docker run --rm -v $(pwd):/out ruvnet/wifi-densepose:latest --export-rvf /out/model.rvf

Image	Tag	Platforms	Ports
`ruvnet/wifi-densepose`	`latest`, `rust`	linux/amd64, linux/arm64	3000 (REST), 3001 (WS), 5005/udp (ESP32)
`ruvnet/wifi-densepose`	`python`	linux/amd64	8765 (WS), 8080 (UI)

System Requirements

Rust: 1.70+ (primary runtime — install via rustup)
Python: 3.8+ (for verification and legacy v1 API)
OS: Linux (Ubuntu 18.04+), macOS (10.15+), Windows 10+
Memory: Minimum 4GB RAM, Recommended 8GB+
Storage: 2GB free space for models and data
Network: WiFi interface with CSI capability (optional — installer detects what you have)
GPU: Optional (NVIDIA CUDA or Apple Metal)

Rust Crates — Individual crates on crates.io

The Rust workspace consists of 15 crates, all published to crates.io:

# Add individual crates to your Cargo.toml
cargo add wifi-densepose-core       # Types, traits, errors
cargo add wifi-densepose-signal     # CSI signal processing (6 SOTA algorithms)
cargo add wifi-densepose-nn         # Neural inference (ONNX, PyTorch, Candle)
cargo add wifi-densepose-vitals     # Vital sign extraction (breathing + heart rate)
cargo add wifi-densepose-mat        # Disaster response (MAT survivor detection)
cargo add wifi-densepose-hardware   # ESP32, Intel 5300, Atheros sensors
cargo add wifi-densepose-train      # Training pipeline (MM-Fi dataset)
cargo add wifi-densepose-wifiscan   # Multi-BSSID WiFi scanning
cargo add wifi-densepose-ruvector   # RuVector v2.0.4 integration layer (ADR-017)

Crate	Description	RuVector	crates.io
`wifi-densepose-core`	Foundation types, traits, and utilities	–
`wifi-densepose-signal`	SOTA CSI signal processing (SpotFi, FarSense, Widar 3.0)	`mincut`, `attn-mincut`, `attention`, `solver`
`wifi-densepose-nn`	Multi-backend inference (ONNX, PyTorch, Candle)	–
`wifi-densepose-train`	Training pipeline with MM-Fi dataset (NeurIPS 2023)	All 5
`wifi-densepose-mat`	Mass Casualty Assessment Tool (disaster survivor detection)	`solver`, `temporal-tensor`
`wifi-densepose-ruvector`	RuVector v2.0.4 integration layer — 7 signal+MAT integration points (ADR-017)	All 5
`wifi-densepose-vitals`	Vital signs: breathing (6-30 BPM), heart rate (40-120 BPM)	–
`wifi-densepose-hardware`	ESP32, Intel 5300, Atheros CSI sensor interfaces	–
`wifi-densepose-wifiscan`	Multi-BSSID WiFi scanning (Windows, macOS, Linux)	–
`wifi-densepose-wasm`	WebAssembly bindings for browser deployment	–
`wifi-densepose-sensing-server`	Axum server: UDP ingestion, WebSocket broadcast	–
`wifi-densepose-cli`	Command-line tool for MAT disaster scanning	–
`wifi-densepose-api`	REST + WebSocket API layer	–
`wifi-densepose-config`	Configuration management	–
`wifi-densepose-db`	Database persistence (PostgreSQL, SQLite, Redis)	–
`wifi-densepose-pointcloud`	Real-time dense point cloud from camera + WiFi CSI fusion (Three.js viewer, brain bridge). Workspace-only for now.	–	—
`wifi-densepose-geo`	Geospatial context (Sentinel-2 tiles, SRTM elevation, OSM, weather, night-mode). Workspace-only for now.	–	—

All crates integrate with RuVector v2.0.4 — see AI Backbone below.

rUv Neural — A separate 12-crate workspace for brain network topology analysis, neural decoding, and medical sensing. See rUv Neural in Models & Training.

🚀 Quick Start

First API call in 3 commands

1. Install

# Fastest path — Docker
docker pull ruvnet/wifi-densepose:latest
docker run -p 3000:3000 ruvnet/wifi-densepose:latest

# Or from source (Rust)
./install.sh --profile rust --yes

2. Start the System

from wifi_densepose import WiFiDensePose

system = WiFiDensePose()
system.start()
poses = system.get_latest_poses()
print(f"Detected {len(poses)} persons")
system.stop()

3. REST API

# Health check
curl http://localhost:3000/health

# Latest sensing frame
curl http://localhost:3000/api/v1/sensing/latest

# Vital signs
curl http://localhost:3000/api/v1/vital-signs

# Pose estimation
curl http://localhost:3000/api/v1/pose/current

# Server info
curl http://localhost:3000/api/v1/info

4. Real-time WebSocket

import asyncio, websockets, json

async def stream():
    async with websockets.connect("ws://localhost:3001/ws/sensing") as ws:
        async for msg in ws:
            data = json.loads(msg)
            print(f"Persons: {len(data.get('persons', []))}")

asyncio.run(stream())

📋 Table of Contents

📡 Signal Processing & Sensing — From raw WiFi frames to vital signs

The signal processing stack transforms raw WiFi Channel State Information into actionable human sensing data. Starting from 56-192 subcarrier complex values captured at 20 Hz, the pipeline applies research-grade algorithms (SpotFi phase correction, Hampel outlier rejection, Fresnel zone modeling) to extract breathing rate, heart rate, motion level, and multi-person body pose — all in pure Rust with zero external ML dependencies.

Section	Description	Docs
Key Features	Sensing, Intelligence, and Performance & Deployment capabilities	—
How It Works	End-to-end pipeline: radio waves → CSI capture → signal processing → AI → pose + vitals	—
ESP32-S3 Hardware Pipeline	20 Hz CSI streaming, binary frame parsing, flash & provision	ADR-018 · Tutorial #34
Vital Sign Detection	Breathing 6-30 BPM, heartbeat 40-120 BPM, FFT peak detection	ADR-021
WiFi Scan Domain Layer	8-stage RSSI pipeline, multi-BSSID fingerprinting, Windows WiFi	ADR-022 · Tutorial #36
WiFi-Mat Disaster Response	Search & rescue, START triage, 3D localization through debris	ADR-001 · User Guide
SOTA Signal Processing	SpotFi, Hampel, Fresnel, STFT spectrogram, subcarrier selection, BVP	ADR-014

🧠 Models & Training — DensePose pipeline, RVF containers, SONA adaptation, RuVector integration

The neural pipeline uses a graph transformer with cross-attention to map CSI feature matrices to 17 COCO body keypoints and DensePose UV coordinates. Models are packaged as single-file .rvf containers with progressive loading (Layer A instant, Layer B warm, Layer C full). SONA (Self-Optimizing Neural Architecture) enables continuous on-device adaptation via micro-LoRA + EWC++ without catastrophic forgetting. Signal processing is powered by 5 RuVector crates (v2.0.4) with 7 integration points across the Rust workspace, plus 6 additional vendored crates for inference and graph intelligence.

Section	Description	Docs
RVF Model Container	Binary packaging with Ed25519 signing, progressive 3-layer loading, SIMD quantization	ADR-023
Training & Fine-Tuning	8-phase pure Rust pipeline (7,832 lines), MM-Fi/Wi-Pose pre-training, 6-term composite loss, SONA LoRA	ADR-023
RuVector Crates	11 vendored Rust crates from ruvector: attention, min-cut, solver, GNN, HNSW, temporal compression, sparse inference	GitHub · Source
rUv Neural	12-crate brain topology analysis ecosystem: neural decoding, quantum sensor integration, cognitive state classification, BCI output	README
AI Backbone (RuVector)	5 AI capabilities replacing hand-tuned thresholds: attention, graph min-cut, sparse solvers, tiered compression	crates.io
Self-Learning WiFi AI (ADR-024)	Contrastive self-supervised learning, room fingerprinting, anomaly detection, 55 KB model	ADR-024
Cross-Environment Generalization (ADR-027)	Domain-adversarial training, geometry-conditioned inference, hardware normalization, zero-shot deployment	ADR-027

🖥️ Usage & Configuration — CLI flags, API endpoints, hardware setup

The Rust sensing server is the primary interface, offering a comprehensive CLI with flags for data source selection, model loading, training, benchmarking, and RVF export. A REST API (Axum) and WebSocket server provide real-time data access. The Python v1 CLI remains available for legacy workflows.

Section	Description	Docs
CLI Usage	`--source`, `--train`, `--benchmark`, `--export-rvf`, `--model`, `--progressive`	—
REST API & WebSocket	6 REST endpoints (sensing, vitals, BSSID, SONA), WebSocket real-time stream	—
Hardware Support	ESP32-S3 ($8), Intel 5300 ($15), Atheros AR9580 ($20), Windows RSSI ($0)	ADR-012 · ADR-013

⚙️ Development & Testing — 542+ tests, CI, deployment

The project maintains 542+ pure-Rust tests across 7 crate suites with zero mocks — every test runs against real algorithm implementations. Hardware-free simulation mode (--source simulate) enables full-stack testing without physical devices. Docker images are published on Docker Hub for zero-setup deployment.

Section	Description	Docs
Testing	7 test suites: sensing-server (229), signal (83), mat (139), wifiscan (91), RVF (16), vitals (18)	—
Deployment	Docker images (132 MB Rust / 569 MB Python), docker-compose, env vars	—
Contributing	Fork → branch → test → PR workflow, Rust and Python dev setup	—

📊 Performance & Benchmarks — Measured throughput, latency, resource usage

All benchmarks are measured on the Rust sensing server using cargo bench and the built-in --benchmark CLI flag. The Rust v2 implementation delivers 810x end-to-end speedup over the Python v1 baseline, with motion detection reaching 5,400x improvement. The vital sign detector processes 11,665 frames/second in a single-threaded benchmark.

Section	Description	Key Metric
Performance Metrics	Vital signs, CSI pipeline, motion detection, Docker image, memory	11,665 fps vitals · 54K fps pipeline
Rust vs Python	Side-by-side benchmarks across 5 operations	810x full pipeline speedup

📄 Meta — License, changelog, support

WiFi DensePose is MIT-licensed open source, developed by ruvnet. The project has been in active development since March 2025, with 3 major releases delivering the Rust port, SOTA signal processing, disaster response module, and end-to-end training pipeline.

Section	Description	Link
Changelog	v3.0.0 (AETHER AI + Docker), v2.0.0 (Rust port + SOTA + WiFi-Mat)	CHANGELOG.md
License	MIT License	LICENSE
Support	Bug reports, feature requests, community discussion	Issues · Discussions

🌍 Cross-Environment Generalization (ADR-027 — Project MERIDIAN) — Train once, deploy in any room without retraining

What	How it works	Why it matters
Gradient Reversal Layer	An adversarial classifier tries to guess which room the signal came from; the main network is trained to fool it	Forces the model to discard room-specific shortcuts
Geometry Encoder (FiLM)	Transmitter/receiver positions are Fourier-encoded and injected as scale+shift conditioning on every layer	The model knows where the hardware is, so it doesn’t need to memorize layout
Hardware Normalizer	Resamples any chipset’s CSI to a canonical 56-subcarrier format with standardized amplitude	Intel 5300 and ESP32 data look identical to the model
Virtual Domain Augmentation	Generates synthetic environments with random room scale, wall reflections, scatterers, and noise profiles	Training sees 1000s of rooms even with data from just 2-3
Rapid Adaptation (TTT)	Contrastive test-time training with LoRA weight generation from a few unlabeled frames	Zero-shot deployment — the model self-tunes on arrival
Cross-Domain Evaluator	Leave-one-out evaluation across all training environments with per-environment PCK/OKS metrics	Proves generalization, not just memorization

Architecture

CSI Frame [any chipset]
    │
    ▼
HardwareNormalizer ──→ canonical 56 subcarriers, N(0,1) amplitude
    │
    ▼
CSI Encoder (existing) ──→ latent features
    │
    ├──→ Pose Head ──→ 17-joint pose (environment-invariant)
    │
    ├──→ Gradient Reversal Layer ──→ Domain Classifier (adversarial)
    │         λ ramps 0→1 via cosine/exponential schedule
    │
    └──→ Geometry Encoder ──→ FiLM conditioning (scale + shift)
              Fourier positional encoding → DeepSets → per-layer modulation

Security hardening:

Bounded calibration buffer (max 10,000 frames) prevents memory exhaustion
adapt() returns Result<_, AdaptError> — no panics on bad input
Atomic instance counter ensures unique weight initialization across threads
Division-by-zero guards on all augmentation parameters

See docs/adr/ADR-027-cross-environment-domain-generalization.md for full architectural details.

🔍 Independent Capability Audit (ADR-028) — 1,031 tests, SHA-256 proof, self-verifying witness bundle

A 3-agent parallel audit independently verified every claim in this repository — ESP32 hardware, signal processing, neural networks, training pipeline, deployment, and security. Results:

1
2
3

Rust tests:     1,031 passed, 0 failed
Python proof:   VERDICT: PASS (SHA-256: 8c0680d7...)
Bundle verify:  7/7 checks PASS

33-row attestation matrix: 31 capabilities verified YES, 2 not measured at audit time (benchmark throughput, Kubernetes deploy).

Verify it yourself (no hardware needed):

# Run all tests
cd rust-port/wifi-densepose-rs && cargo test --workspace --no-default-features

# Run the deterministic proof
python v1/data/proof/verify.py

# Generate + verify the witness bundle
bash scripts/generate-witness-bundle.sh
cd dist/witness-bundle-ADR028-*/ && bash VERIFY.sh

Document	What it contains
ADR-028	Full audit: ESP32 specs, signal algorithms, NN architectures, training phases, deployment infra
Witness Log	11 reproducible verification steps + 33-row attestation matrix with evidence per row
`generate-witness-bundle.sh`	Creates self-contained tar.gz with test logs, proof output, firmware hashes, crate versions, VERIFY.sh

📡 Multistatic Sensing (ADR-029/030/031 — Project RuvSense + RuView) — Multiple ESP32 nodes fuse viewpoints for production-grade pose, tracking, and exotic sensing

A single WiFi receiver can track people, but has blind spots — limbs behind the torso are invisible, depth is ambiguous, and two people at similar range create overlapping signals. RuvSense solves this by coordinating multiple ESP32 nodes into a multistatic mesh where every node acts as both transmitter and receiver, creating N×(N-1) measurement links from N devices.

What it does in plain terms:

4 ESP32-S3 nodes ($48 total) provide 12 TX-RX measurement links covering 360 degrees
Each node hops across WiFi channels 1/6/11, tripling effective bandwidth from 20→60 MHz
Coherence gating rejects noisy frames automatically — no manual tuning, stable for days
Two-person tracking at 20 Hz with zero identity swaps over 10 minutes
The room itself becomes a persistent model — the system remembers, predicts, and explains

Three ADRs, one pipeline:

ADR	Codename	What it adds
ADR-029	RuvSense	Channel hopping, TDM protocol, multi-node fusion, coherence gating, 17-keypoint Kalman tracker
ADR-030	RuvSense Field	Room electromagnetic eigenstructure (SVD), RF tomography, longitudinal drift detection, intention prediction, gesture recognition, adversarial detection
ADR-031	RuView	Cross-viewpoint attention with geometric bias, viewpoint diversity optimization, embedding-level fusion

Architecture

4x ESP32-S3 nodes ($48)     TDM: each transmits in turn, all others receive
        │                    Channel hop: ch1→ch6→ch11 per dwell (50ms)
        ▼
Per-Node Signal Processing   Phase sanitize → Hampel → BVP → subcarrier select
        │                    (ADR-014, unchanged per viewpoint)
        ▼
Multi-Band Frame Fusion      3 channels × 56 subcarriers = 168 virtual subcarriers
        │                    Cross-channel phase alignment via NeumannSolver
        ▼
Multistatic Viewpoint Fusion  N nodes → attention-weighted fusion → single embedding
        │                    Geometric bias from node placement angles
        ▼
Coherence Gate               Accept / PredictOnly / Reject / Recalibrate
        │                    Prevents model drift, stable for days
        ▼
Persistent Field Model       SVD baseline → body = observation - environment
        │                    RF tomography, drift detection, intention signals
        ▼
Pose Tracker + DensePose     17-keypoint Kalman, re-ID via AETHER embeddings
                             Multi-person min-cut separation, zero ID swaps

Seven Exotic Sensing Tiers (ADR-030)

Tier	Capability	What it detects
1	Field Normal Modes	Room electromagnetic eigenstructure via SVD
2	Coarse RF Tomography	3D occupancy volume from link attenuations
3	Intention Lead Signals	Pre-movement prediction 200-500ms before action
4	Longitudinal Biomechanics	Personal movement changes over days/weeks
5	Cross-Room Continuity	Identity preserved across rooms without cameras
6	Invisible Interaction	Multi-user gesture control through walls
7	Adversarial Detection	Physically impossible signal identification

Acceptance Test

Metric	Threshold	What it proves
Torso keypoint jitter	< 30mm RMS	Precision sufficient for applications
Identity swaps	0 over 10 minutes (12,000 frames)	Reliable multi-person tracking
Update rate	20 Hz (50ms cycle)	Real-time response
Breathing SNR	> 10 dB at 3m	Small-motion sensitivity confirmed

New Rust modules (9,000+ lines)

Crate	New modules	Purpose
`wifi-densepose-signal`	`ruvsense/` (10 modules)	Multiband fusion, phase alignment, multistatic fusion, coherence, field model, tomography, longitudinal drift, intention detection
`wifi-densepose-ruvector`	`viewpoint/` (5 modules)	Cross-viewpoint attention with geometric bias, diversity index, coherence gating, fusion orchestrator
`wifi-densepose-hardware`	`esp32/tdm.rs`	TDM sensing protocol, sync beacons, clock drift compensation

Firmware extensions (C, backward-compatible)

File	Addition
`csi_collector.c`	Channel hop table, timer-driven hop, NDP injection stub
`nvs_config.c`	5 new NVS keys: hop_count, channel_list, dwell_ms, tdm_slot, tdm_node_count

DDD Domain Model — 6 bounded contexts: Multistatic Sensing, Coherence, Pose Tracking, Field Model, Cross-Room Identity, Adversarial Detection. Full specification: docs/ddd/ruvsense-domain-model.md.

See the ADR documents for full architectural details, GOAP integration plans, and research references.

🔮 Signal-Line Protocol (CRV)

6-Stage CSI Signal Line

Maps the CRV (Coordinate Remote Viewing) signal-line methodology to WiFi CSI processing via ruvector-crv:

Stage	CRV Name	WiFi CSI Mapping	ruvector Component
I	Ideograms	Raw CSI gestalt (manmade/natural/movement/energy)	Poincare ball hyperbolic embeddings
II	Sensory	Amplitude textures, phase patterns, frequency colors	Multi-head attention vectors
III	Dimensional	AP mesh spatial topology, node geometry	GNN graph topology
IV	Emotional/AOL	Coherence gating — signal vs noise separation	SNN temporal encoding
V	Interrogation	Cross-stage probing — query pose against CSI history	Differentiable search
VI	3D Model	Composite person estimation, MinCut partitioning	Graph partitioning

Cross-Session Convergence: When multiple AP clusters observe the same person, CRV convergence analysis finds agreement in their signal embeddings — directly mapping to cross-room identity continuity.

use wifi_densepose_ruvector::crv::WifiCrvPipeline;

let mut pipeline = WifiCrvPipeline::new(WifiCrvConfig::default());
pipeline.create_session("room-a", "person-001")?;

// Process CSI frames through 6-stage pipeline
let result = pipeline.process_csi_frame("room-a", &amplitudes, &phases)?;
// result.gestalt = Movement, confidence = 0.87
// result.sensory_embedding = [0.12, -0.34, ...]

// Cross-room identity matching via convergence
let convergence = pipeline.find_cross_room_convergence("person-001", 0.75)?;

Architecture:

CsiGestaltClassifier — Maps CSI amplitude/phase patterns to 6 gestalt types
CsiSensoryEncoder — Extracts texture/color/temperature/luminosity features from subcarriers
MeshTopologyEncoder — Encodes AP mesh as GNN graph (Stage III)
CoherenceAolDetector — Maps coherence gate states to AOL noise detection (Stage IV)
WifiCrvPipeline — Orchestrates all 6 stages into unified sensing session

📡 Signal Processing & Sensing

📡 ESP32-S3 Hardware Pipeline (ADR-018) — 28 Hz CSI streaming, flash & provision

A single ESP32-S3 board (~$9) captures WiFi signal data 28 times per second and streams it over UDP. A host server can visualize and record the data, but the ESP32 can also run on its own — detecting presence, measuring breathing and heart rate, and alerting on falls without any server at all.

ESP32-S3 node                    UDP/5005        Host server (optional)
┌───────────────────────┐      ──────────>      ┌──────────────────────┐
│ Captures WiFi signals │      binary frames    │ Parses frames        │
│ 28 Hz, up to 192 sub- │      or 32-byte       │ Visualizes poses     │
│ carriers per frame     │      vitals packets   │ Records CSI data     │
│                        │                       │ REST API + WebSocket │
│ On-device (optional):  │                       └──────────────────────┘
│  Presence detection    │
│  Breathing + heart rate│
│  Fall detection        │
│  WASM custom modules   │
└───────────────────────┘

Metric	Measured on hardware
CSI frame rate	28.5 Hz (channel 5, BW20)
Subcarriers per frame	64 / 128 / 192 (depends on WiFi mode)
UDP latency	< 1 ms on local network
Presence detection range	Reliable at 3 m through walls
Binary size	990 KB (8MB flash) / 773 KB (4MB flash)
Boot to ready	~3.9 seconds

Flash and provision

Download a pre-built binary — no build toolchain needed:

Release	What’s included	Tag
v0.7.0	Latest — Camera-supervised WiFlow model (92.9% PCK@20), ground-truth training pipeline, ruvector optimizations	`v0.7.0`
v0.6.0	Pre-trained models on HuggingFace, 17 sensing apps, 51.6% contrastive improvement, 0.008ms inference	`v0.6.0-esp32`
v0.5.5	SNN + MinCut (#348 fix) + CNN spectrogram + WiFlow + multi-freq mesh + graph transformer	`v0.5.5-esp32`
v0.5.4	Cognitum Seed integration (ADR-069), 8-dim feature vectors, RVF store, witness chain, security hardening	`v0.5.4-esp32`
v0.5.0	mmWave sensor fusion (ADR-063), auto-detect MR60BHA2/LD2410, 48-byte fused vitals, all v0.4.3.1 fixes	`v0.5.0-esp32`
v0.4.3.1	Fall detection fix (#263), 4MB flash (#265), watchdog fix (#266)	`v0.4.3.1-esp32`
v0.4.1	CSI build fix, compile guard, AMOLED display, edge intelligence (ADR-057)	`v0.4.1-esp32`
v0.3.0-alpha	Alpha — adds on-device edge intelligence and WASM modules (ADR-039, ADR-040)	`v0.3.0-alpha-esp32`
v0.2.0	Raw CSI streaming, multi-node TDM, channel hopping	`v0.2.0-esp32`

# 1. Flash the firmware to your ESP32-S3 (8MB flash — most boards)
python -m esptool --chip esp32s3 --port COM7 --baud 460800 \
  write_flash --flash-mode dio --flash-size 8MB --flash-freq 80m \
  0x0 bootloader.bin 0x8000 partition-table.bin \
  0xf000 ota_data_initial.bin 0x20000 esp32-csi-node.bin

# 1b. For 4MB flash boards (e.g. ESP32-S3 SuperMini 4MB) — use the 4MB binaries:
python -m esptool --chip esp32s3 --port COM7 --baud 460800 \
  write_flash --flash-mode dio --flash-size 4MB --flash-freq 80m \
  0x0 bootloader.bin 0x8000 partition-table-4mb.bin \
  0xF000 ota_data_initial.bin 0x20000 esp32-csi-node-4mb.bin

# 2. Set WiFi credentials and server address (stored in flash, survives reboots)
python firmware/esp32-csi-node/provision.py --port COM7 \
  --ssid "YourWiFi" --password "secret" --target-ip 192.168.1.20

# 3. (Optional) Start the host server to visualize data
cargo run -p wifi-densepose-sensing-server -- --http-port 3000 --source auto
# Open http://localhost:3000

Multi-node mesh

For better accuracy and room coverage, deploy 3-6 nodes with time-division multiplexing (TDM) so they take turns transmitting:

# Node 0 of a 3-node mesh
python firmware/esp32-csi-node/provision.py --port COM7 \
  --ssid "YourWiFi" --password "secret" --target-ip 192.168.1.20 \
  --node-id 0 --tdm-slot 0 --tdm-total 3

# Node 1
python firmware/esp32-csi-node/provision.py --port COM8 \
  --ssid "YourWiFi" --password "secret" --target-ip 192.168.1.20 \
  --node-id 1 --tdm-slot 1 --tdm-total 3

Nodes can also hop across WiFi channels (1, 6, 11) to increase sensing bandwidth — configured via ADR-029 channel hopping.

Cognitum Seed integration (ADR-069)

Connect an ESP32 to a Cognitum Seed ($131) for persistent vector storage, kNN search, cryptographic witness chain, and AI-accessible MCP proxy:

ESP32-S3 ($9)  ──UDP──>  Host bridge  ──HTTPS──>  Cognitum Seed ($15)
  CSI capture              seed_csi_bridge.py         RVF vector store
  8-dim features @ 1 Hz                              kNN similarity search
  Vitals + presence                                  Ed25519 witness chain
                                                     114-tool MCP proxy

# 1. Provision ESP32 to send features to your laptop
python firmware/esp32-csi-node/provision.py --port COM9 \
  --ssid "YourWiFi" --password "secret" --target-ip 192.168.1.20 --target-port 5006

# 2. Run the bridge (forwards to Seed via HTTPS)
export SEED_TOKEN="your-pairing-token"
python scripts/seed_csi_bridge.py \
  --seed-url https://169.254.42.1:8443 --token "$SEED_TOKEN" --validate

# 3. Check Seed stats
python scripts/seed_csi_bridge.py --token "$SEED_TOKEN" --stats

The 8-dim feature vector captures: presence, motion, breathing rate, heart rate, phase variance, person count, fall detection, and RSSI — all normalized to [0.0, 1.0]. See ADR-069 for the full architecture.

On-device intelligence (v0.3.0-alpha)

The alpha firmware can analyze signals locally and send compact results instead of raw data. This means the ESP32 works standalone — no server needed for basic sensing. Disabled by default for backward compatibility.

Tier	What it does	RAM used
0	Off — streams raw CSI only (same as v0.2.0)	0 KB
1	Cleans up signals, picks the best subcarriers, compresses data (saves 30-50% bandwidth)	~30 KB
2	Everything in Tier 1 + detects presence, measures breathing and heart rate, detects falls	~33 KB
3	Everything in Tier 2 + runs custom WASM modules (gesture recognition, intrusion detection, and 63 more)	~160 KB/module

Enable without reflashing — just reprovision:

# Turn on Tier 2 (vitals) on an already-flashed node
python firmware/esp32-csi-node/provision.py --port COM7 \
  --ssid "YourWiFi" --password "secret" --target-ip 192.168.1.20 \
  --edge-tier 2

# Fine-tune detection thresholds (fall-thresh in milli-units: 15000 = 15.0 rad/s²)
python firmware/esp32-csi-node/provision.py --port COM7 \
  --edge-tier 2 --vital-int 500 --fall-thresh 15000 --subk-count 16

When Tier 2 is active, the node sends a 32-byte vitals packet once per second containing: presence, motion level, breathing BPM, heart rate BPM, confidence scores, fall alert flag, and occupancy count.

See firmware/esp32-csi-node/README.md, ADR-039, ADR-044, and Tutorial #34.

🦀 Rust Implementation (v2) — 810x faster, 54K fps pipeline

Performance Benchmarks (Validated)

Operation	Python (v1)	Rust (v2)	Speedup
CSI Preprocessing (4x64)	~5ms	5.19 µs	~1000x
Phase Sanitization (4x64)	~3ms	3.84 µs	~780x
Feature Extraction (4x64)	~8ms	9.03 µs	~890x
Motion Detection	~1ms	186 ns	~5400x
Full Pipeline	~15ms	18.47 µs	~810x
Vital Signs	N/A	86 µs	11,665 fps

Resource	Python (v1)	Rust (v2)
Memory	~500 MB	~100 MB
Docker Image	569 MB	132 MB
Tests	41	542+
WASM Support	No	Yes

cd rust-port/wifi-densepose-rs
cargo build --release
cargo test --workspace
cargo bench --package wifi-densepose-signal

💓 Vital Sign Detection (ADR-021) — Breathing and heartbeat via FFT

Capability	Range	Method
Breathing Rate	6-30 BPM (0.1-0.5 Hz)	Bandpass filter + FFT peak detection
Heart Rate	40-120 BPM (0.8-2.0 Hz)	Bandpass filter + FFT peak detection
Sampling Rate	20 Hz (ESP32 CSI)	Real-time streaming
Confidence	0.0-1.0 per sign	Spectral coherence + signal quality

1
2

./target/release/sensing-server --source simulate --http-port 3000 --ws-port 3001 --ui-path ../../ui
curl http://localhost:3000/api/v1/vital-signs

See ADR-021.

📡 WiFi Scan Domain Layer (ADR-022/025) — 8-stage RSSI pipeline for Windows, macOS, and Linux WiFi

Stage	Purpose
Predictive Gating	Pre-filter scan results using temporal prediction
Attention Weighting	Weight BSSIDs by signal relevance
Spatial Correlation	Cross-AP spatial signal correlation
Motion Estimation	Detect movement from RSSI variance
Breathing Extraction	Extract respiratory rate from sub-Hz oscillations
Quality Gating	Reject low-confidence estimates
Fingerprint Matching	Location and posture classification via RF fingerprints
Orchestration	Fuse all stages into unified sensing output

`1`	`cargo test -p wifi-densepose-wifiscan`

See ADR-022 and Tutorial #36.

🚨 WiFi-Mat: Disaster Response — Search & rescue, START triage, 3D localization

WiFi signals penetrate non-metallic debris (concrete, wood, drywall) where cameras and thermal sensors cannot reach. The WiFi-Mat module (wifi-densepose-mat, 139 tests) uses CSI analysis to detect survivors trapped under rubble, classify their condition using the START triage protocol, and estimate their 3D position — giving rescue teams actionable intelligence within seconds of deployment.

Capability	How It Works	Performance Target
Breathing Detection	Bandpass 0.07-1.0 Hz + Fresnel zone modeling detects chest displacement of 5-10mm at 5 GHz	4-60 BPM, <500ms latency
Heartbeat Detection	Micro-Doppler shift extraction from fine-grained CSI phase variation	Via ruvector-temporal-tensor
3D Localization	Multi-AP triangulation + CSI fingerprint matching + depth estimation through rubble layers	3-5m penetration
START Triage	Ensemble classifier votes on breathing + movement + vital stability → P1-P4 priority	<1% false negative
Zone Scanning	16+ concurrent scan zones with periodic re-scan and audit logging	Full disaster site

Triage classification (START protocol compatible):

Status	Color	Detection Criteria	Priority
Immediate	Red	Breathing detected, no movement	P1
Delayed	Yellow	Movement + breathing, stable vitals	P2
Minor	Green	Strong movement, responsive patterns	P3
Deceased	Black	No vitals for >30 min continuous scan	P4

Deployment modes: portable (single TX/RX handheld), distributed (multiple APs around collapse site), drone-mounted (UAV scanning), vehicle-mounted (mobile command post).

use wifi_densepose_mat::{DisasterResponse, DisasterConfig, DisasterType, ScanZone, ZoneBounds};

let config = DisasterConfig::builder()
    .disaster_type(DisasterType::Earthquake)
    .sensitivity(0.85)
    .max_depth(5.0)
    .build();

let mut response = DisasterResponse::new(config);
response.initialize_event(location, "Building collapse")?;
response.add_zone(ScanZone::new("North Wing", ZoneBounds::rectangle(0.0, 0.0, 30.0, 20.0)))?;
response.start_scanning().await?;

Safety guarantees: fail-safe defaults (assume life present on ambiguous signals), redundant multi-algorithm voting, complete audit trail, offline-capable (no network required).

WiFi-Mat User Guide | ADR-001 | Domain Model

🔬 SOTA Signal Processing (ADR-014) — 6 research-grade algorithms

The signal processing layer bridges the gap between raw commodity WiFi hardware output and research-grade sensing accuracy. Each algorithm addresses a specific limitation of naive CSI processing — from hardware-induced phase corruption to environment-dependent multipath interference. All six are implemented in wifi-densepose-signal/src/ with deterministic tests and no mock data.

Algorithm	What It Does	Why It Matters	Math	Source
Conjugate Multiplication	Multiplies CSI antenna pairs: `H₁[k] × conj(H₂[k])`	Cancels CFO, SFO, and packet detection delay that corrupt raw phase — preserves only environment-caused phase differences	`CSI_ratio[k] = H₁[k] * conj(H₂[k])`	SpotFi (SIGCOMM 2015)
Hampel Filter	Replaces outliers using running median ± scaled MAD	Z-score uses mean/std which are corrupted by the very outliers it detects (masking effect). Hampel uses median/MAD, resisting up to 50% contamination	`σ̂ = 1.4826 × MAD`	Standard DSP; WiGest (2015)
Fresnel Zone Model	Models signal variation from chest displacement crossing Fresnel zone boundaries	Zero-crossing counting fails in multipath-rich environments. Fresnel predicts where breathing should appear based on TX-RX-body geometry	`ΔΦ = 2π × 2Δd / λ`, `A = \|sin(ΔΦ/2)\|`	FarSense (MobiCom 2019)
CSI Spectrogram	Sliding-window FFT (STFT) per subcarrier → 2D time-frequency matrix	Breathing = 0.2-0.4 Hz band, walking = 1-2 Hz, static = noise. 2D structure enables CNN spatial pattern recognition that 1D features miss	`S[t,f] = \|Σₙ x[n] w[n-t] e^{-j2πfn}\|²`	Standard since 2018
Subcarrier Selection	Ranks subcarriers by motion sensitivity (variance ratio) and selects top-K	Not all subcarriers respond to motion — some sit in multipath nulls. Selecting the 10-20 most sensitive improves SNR by 6-10 dB	`sensitivity[k] = var_motion / var_static`	WiDance (MobiCom 2017)
Body Velocity Profile	Extracts velocity distribution from Doppler shifts across subcarriers	BVP is domain-independent — same velocity profile regardless of room layout, furniture, or AP placement. Basis for cross-environment recognition	`BVP[v,t] = Σₖ \|STFTₖ[v,t]\|`	Widar 3.0 (MobiSys 2019)

Processing pipeline order: Raw CSI → Conjugate multiplication (phase cleaning) → Hampel filter (outlier removal) → Subcarrier selection (top-K) → CSI spectrogram (time-frequency) → Fresnel model (breathing) + BVP (activity)

See ADR-014 for full mathematical derivations.

🧠 Models & Training

🤖 AI Backbone: RuVector — Attention, graph algorithms, and edge-AI compression powering the sensing pipeline

Raw WiFi signals are noisy, redundant, and environment-dependent. RuVector is the AI intelligence layer that transforms them into clean, structured input for the DensePose neural network. It uses attention mechanisms to learn which signals to trust, graph algorithms that automatically discover which WiFi channels are sensitive to body motion, and compressed representations that make edge inference possible on an $8 microcontroller.

Without RuVector, WiFi DensePose would need hand-tuned thresholds, brute-force matrix math, and 4x more memory — making real-time edge inference impossible.

Raw WiFi CSI (56 subcarriers, noisy)
    |
    +-- ruvector-mincut ---------- Which channels carry body-motion signal? (learned graph partitioning)
    +-- ruvector-attn-mincut ----- Which time frames are signal vs noise? (attention-gated filtering)
    +-- ruvector-attention ------- How to fuse multi-antenna data? (learned weighted aggregation)
    |
    v
Clean, structured signal --> DensePose Neural Network --> 17-keypoint body pose
                         --> FFT Vital Signs -----------> breathing rate, heart rate
                         --> ruvector-solver ------------> physics-based localization

The wifi-densepose-ruvector crate (ADR-017) connects all 7 integration points:

AI Capability	What It Replaces	RuVector Crate	Result
Self-optimizing channel selection	Hand-tuned thresholds that break when rooms change	`ruvector-mincut`	Graph min-cut adapts to any environment automatically
Attention-based signal cleaning	Fixed energy cutoffs that miss subtle breathing	`ruvector-attn-mincut`	Learned gating amplifies body signals, suppresses noise
Learned signal fusion	Simple averaging where one bad channel corrupts all	`ruvector-attention`	Transformer-style attention downweights corrupted channels
Physics-informed localization	Expensive nonlinear solvers	`ruvector-solver`	Sparse least-squares Fresnel geometry in real-time
O(1) survivor triangulation	O(N^3) matrix inversion	`ruvector-solver`	Neumann series linearization for instant position updates
75% memory compression	13.4 MB breathing buffers that overflow edge devices	`ruvector-temporal-tensor`	Tiered 3-8 bit quantization fits 60s of vitals in 3.4 MB

See issue #67 for a deep dive with code examples, or cargo add wifi-densepose-ruvector to use it directly.

📦 RVF Model Container — Single-file deployment with progressive loading

The RuVector Format (RVF) packages an entire trained model — weights, HNSW indexes, quantization codebooks, SONA adaptation deltas, and WASM inference runtime — into a single self-contained binary file. No external dependencies are needed at deployment time.

Container structure:

┌──────────────────────────────────────────────────────┐
│ RVF Container (.rvf)                                  │
│                                                       │
│  ┌─────────────┐  64-byte header per segment          │
│  │ Manifest     │  Magic: 0x52564653 ("RVFS")         │
│  ├─────────────┤  Type + content hash + compression   │
│  │ Weights      │  Model parameters (f32/f16/u8)      │
│  ├─────────────┤                                      │
│  │ HNSW Index   │  Vector search index                │
│  ├─────────────┤                                      │
│  │ Quant        │  Quantization codebooks              │
│  ├─────────────┤                                      │
│  │ SONA Profile │  LoRA deltas + EWC++ Fisher matrix  │
│  ├─────────────┤                                      │
│  │ Witness      │  Ed25519 training proof              │
│  ├─────────────┤                                      │
│  │ Vitals Config│  Breathing/HR filter parameters     │
│  └─────────────┘                                      │
└──────────────────────────────────────────────────────┘

Deployment targets:

Target	Quantization	Size	Load Time	Use Case
ESP32 / IoT	int4	~0.7 MB	<5ms (Layer A)	Presence + breathing only
Mobile / WebView	int8	~6 MB	~200ms (Layer B)	Pose estimation on phone
Browser (WASM)	int8	~10 MB	~500ms (Layer B)	In-browser demo
Field (WiFi-Mat)	fp16	~62 MB	~2s (Layer C)	Full DensePose + disaster triage
Server / Cloud	f32	~50+ MB	~3s (Layer C)	Training + full inference

Property	Detail
Format	Segment-based binary, 20+ segment types, CRC32 integrity per segment
Progressive Loading	Layer A (<5ms): manifest + entry points → Layer B (100ms-1s): hot weights + adjacency → Layer C (seconds): full graph
Signing	Ed25519 training proofs for verifiable provenance — chain of custody from training data to deployed model
Quantization	Per-segment temperature-tiered: f32 (full), f16 (half), u8 (int8), int4 — with SIMD-accelerated distance computation
CLI	`--export-rvf` (generate), `--load-rvf` (config), `--save-rvf` (persist), `--model` (inference), `--progressive` (3-layer load)

# Export model package
./target/release/sensing-server --export-rvf wifi-densepose-v1.rvf

# Load and run with progressive loading
./target/release/sensing-server --model wifi-densepose-v1.rvf --progressive

# Export via Docker
docker run --rm -v $(pwd):/out ruvnet/wifi-densepose:latest --export-rvf /out/model.rvf

Built on the rvf crate family (rvf-types, rvf-wire, rvf-manifest, rvf-index, rvf-quant, rvf-crypto, rvf-runtime). See ADR-023.

🧬 Training & Fine-Tuning — MM-Fi/Wi-Pose pre-training, SONA adaptation

The training pipeline implements 8 phases in pure Rust (7,832 lines, zero external ML dependencies). It trains a graph transformer with cross-attention to map CSI feature matrices to 17 COCO body keypoints and DensePose UV coordinates — following the approach from the CMU “DensePose From WiFi” paper (arXiv:2301.00250). RuVector crates provide the core building blocks: ruvector-attention for cross-attention layers, ruvector-mincut for multi-person matching, and ruvector-temporal-tensor for CSI buffer compression.

Three-tier data strategy:

Tier	Method	Purpose	RuVector Integration
1. Pre-train	MM-Fi + Wi-Pose public datasets	Cross-environment generalization (multi-subject, multi-room)	`ruvector-temporal-tensor` compresses CSI windows (114→56 subcarrier resampling)
2. Fine-tune	ESP32 CSI + camera pseudo-labels	Environment-specific multipath adaptation	`ruvector-solver` for Fresnel geometry, `ruvector-attn-mincut` for subcarrier gating
3. SONA adapt	Micro-LoRA (rank-4) + EWC++	Continuous on-device learning without catastrophic forgetting	SONA architecture (Self-Optimizing Neural Architecture)

Training pipeline components:

Phase	Module	What It Does	RuVector Crate
1	`dataset.rs` (850 lines)	MM-Fi `.npy` + Wi-Pose `.mat` loaders, subcarrier resampling (114→56, 30→56), windowing	ruvector-temporal-tensor
2	`graph_transformer.rs` (855 lines)	COCO BodyGraph (17 kp, 16 edges), AntennaGraph, multi-head CrossAttention, GCN message passing	ruvector-attention
3	`trainer.rs` (881 lines)	6-term composite loss (MSE, CE, UV, temporal, bone, symmetry), SGD+momentum, cosine+warmup, PCK/OKS	ruvector-mincut (person matching)
4	`sona.rs` (639 lines)	LoRA adapters (A×B delta), EWC++ Fisher regularization, EnvironmentDetector (3-sigma drift)	sona
5	`sparse_inference.rs` (753 lines)	NeuronProfiler hot/cold partitioning, SparseLinear (skip cold rows), INT8/FP16 quantization	ruvector-sparse-inference
6	`rvf_pipeline.rs` (1,027 lines)	Progressive 3-layer loader, HNSW index, OverlayGraph, `RvfModelBuilder`	ruvector-core (HNSW)
7	`rvf_container.rs` (914 lines)	Binary container format, 6+ segment types, CRC32 integrity	rvf
8	`main.rs` integration	`--train`, `--model`, `--progressive` CLI flags, REST endpoints	—

SONA (Self-Optimizing Neural Architecture) — the continuous adaptation system:

Component	What It Does	Why It Matters
Micro-LoRA (rank-4)	Trains small A×B weight deltas instead of full weights	100x fewer parameters to update → runs on ESP32
EWC++ (Fisher matrix)	Penalizes changes to important weights from previous environments	Prevents catastrophic forgetting when moving between rooms
EnvironmentDetector	Monitors CSI feature drift with 3-sigma threshold	Auto-triggers adaptation when the model is moved to a new space
Best-epoch snapshot	Saves best validation loss weights, restores before export	Prevents shipping overfit final-epoch parameters

# Pre-train on MM-Fi dataset
./target/release/sensing-server --train --dataset data/ --dataset-type mmfi --epochs 100

# Train and export to RVF in one step
./target/release/sensing-server --train --dataset data/ --epochs 100 --save-rvf model.rvf

# Via Docker (no toolchain needed)
docker run --rm -v $(pwd)/data:/data ruvnet/wifi-densepose:latest \
  --train --dataset /data --epochs 100 --export-rvf /data/model.rvf

See ADR-023 · SONA crate · arXiv:2301.00250

🔩 RuVector Crates — 11 vendored signal intelligence crates from github.com/ruvnet/ruvector

5 directly-used crates (v2.0.4, declared in Cargo.toml, 7 integration points):

Crate	What It Does	Where It’s Used in WiFi-DensePose	Source
`ruvector-attention`	Scaled dot-product attention, MoE routing, sparse attention	`model.rs` (spatial attention), `bvp.rs` (sensitivity-weighted velocity profiles)	crate
`ruvector-mincut`	Subpolynomial dynamic min-cut O(n^1.5 log n)	`metrics.rs` (DynamicPersonMatcher — multi-person assignment), `subcarrier_selection.rs` (sensitive/insensitive split)	crate
`ruvector-attn-mincut`	Attention-gated spectrogram noise suppression	`model.rs` (antenna attention gating), `spectrogram.rs` (gate noisy time-frequency bins)	crate
`ruvector-solver`	Sparse Neumann series solver O(sqrt(n))	`fresnel.rs` (TX-body-RX geometry), `triangulation.rs` (3D localization), `subcarrier.rs` (sparse interpolation 114→56)	crate
`ruvector-temporal-tensor`	Tiered temporal compression (8/7/5/3-bit)	`dataset.rs` (CSI buffer compression), `breathing.rs` + `heartbeat.rs` (compressed vital sign spectrograms)	crate

6 additional vendored crates (used by training pipeline and inference):

Crate	What It Does	Source
`ruvector-core`	VectorDB engine, HNSW index, SIMD distance functions, quantization codebooks	crate
`ruvector-gnn`	Graph neural network layers, graph attention, EWC-regularized training	crate
`ruvector-graph-transformer`	Proof-gated graph transformer with cross-attention	crate
`ruvector-sparse-inference`	PowerInfer-style hot/cold neuron partitioning, skip cold rows at runtime	crate
`ruvector-nervous-system`	PredictiveLayer, OscillatoryRouter, Hopfield associative memory	crate
`ruvector-coherence`	Spectral coherence monitoring, HNSW graph health, Fiedler connectivity	crate

The full RuVector ecosystem includes 90+ crates. See github.com/ruvnet/ruvector for the complete library, and vendor/ruvector/ for the vendored source in this project.

🧠 rUv Neural — Brain topology analysis ecosystem for neural decoding and medical sensing

rUv Neural is a 12-crate Rust ecosystem that extends RuView’s signal processing into brain network topology analysis. It transforms neural magnetic field measurements from quantum sensors (NV diamond magnetometers, optically pumped magnetometers) into dynamic connectivity graphs, using minimum cut algorithms to detect cognitive state transitions in real time. The ecosystem includes crates for signal processing (ruv-neural-signal), graph construction (ruv-neural-graph), HNSW-indexed pattern memory (ruv-neural-memory), graph embeddings (ruv-neural-embed), cognitive state decoding (ruv-neural-decoder), and ESP32/WASM edge targets. Medical and research applications include early neurological disease detection via topology signatures, brain-computer interfaces, clinical neurofeedback, and non-invasive biomedical sensing – bridging RuView’s RF sensing architecture with the emerging field of quantum biomedical diagnostics.

🏗️ System Architecture — End-to-end data flow from CSI capture to REST/WebSocket API

End-to-End Pipeline

  graph TB
    subgraph HW ["📡 Hardware Layer"]
        direction LR
        R1["WiFi Router 1<br/><small>CSI Source</small>"]
        R2["WiFi Router 2<br/><small>CSI Source</small>"]
        R3["WiFi Router 3<br/><small>CSI Source</small>"]
        ESP["ESP32-S3 Mesh<br/><small>20 Hz · 56 subcarriers</small>"]
        WIN["Windows WiFi<br/><small>RSSI scanning</small>"]
    end

    subgraph INGEST ["⚡ Ingestion"]
        AGG["Aggregator<br/><small>UDP :5005 · ADR-018 frames</small>"]
        BRIDGE["Bridge<br/><small>I/Q → amplitude + phase</small>"]
    end

    subgraph SIGNAL ["🔬 Signal Processing — RuVector v2.0.4"]
        direction TB
        PHASE["Phase Sanitization<br/><small>SpotFi conjugate multiply</small>"]
        HAMPEL["Hampel Filter<br/><small>Outlier rejection · σ=3</small>"]
        SUBSEL["Subcarrier Selection<br/><small>ruvector-mincut · sensitive/insensitive split</small>"]
        SPEC["Spectrogram<br/><small>ruvector-attn-mincut · gated STFT</small>"]
        FRESNEL["Fresnel Geometry<br/><small>ruvector-solver · TX-body-RX distance</small>"]
        BVP["Body Velocity Profile<br/><small>ruvector-attention · weighted BVP</small>"]
    end

    subgraph ML ["🧠 Neural Pipeline"]
        direction TB
        GRAPH["Graph Transformer<br/><small>17 COCO keypoints · 16 edges</small>"]
        CROSS["Cross-Attention<br/><small>CSI features → body pose</small>"]
        SONA["SONA Adapter<br/><small>LoRA rank-4 · EWC++</small>"]
    end

    subgraph VITAL ["💓 Vital Signs"]
        direction LR
        BREATH["Breathing<br/><small>0.1–0.5 Hz · FFT peak</small>"]
        HEART["Heart Rate<br/><small>0.8–2.0 Hz · FFT peak</small>"]
        MOTION["Motion Level<br/><small>Variance + band power</small>"]
    end

    subgraph API ["🌐 Output Layer"]
        direction LR
        REST["REST API<br/><small>Axum :3000 · 6 endpoints</small>"]
        WS["WebSocket<br/><small>:3001 · real-time stream</small>"]
        ANALYTICS["Analytics<br/><small>Fall · Activity · START triage</small>"]
        UI["Web UI<br/><small>Three.js · Gaussian splats</small>"]
    end

    R1 & R2 & R3 --> AGG
    ESP --> AGG
    WIN --> BRIDGE
    AGG --> BRIDGE
    BRIDGE --> PHASE
    PHASE --> HAMPEL
    HAMPEL --> SUBSEL
    SUBSEL --> SPEC
    SPEC --> FRESNEL
    FRESNEL --> BVP
    BVP --> GRAPH
    GRAPH --> CROSS
    CROSS --> SONA
    SONA --> BREATH & HEART & MOTION
    BREATH & HEART & MOTION --> REST & WS & ANALYTICS
    WS --> UI

    style HW fill:#1a1a2e,stroke:#e94560,color:#eee
    style INGEST fill:#16213e,stroke:#0f3460,color:#eee
    style SIGNAL fill:#0f3460,stroke:#533483,color:#eee
    style ML fill:#533483,stroke:#e94560,color:#eee
    style VITAL fill:#2d132c,stroke:#e94560,color:#eee
    style API fill:#1a1a2e,stroke:#0f3460,color:#eee

Signal Processing Detail

  graph LR
    subgraph RAW ["Raw CSI Frame"]
        IQ["I/Q Samples<br/><small>56–192 subcarriers × N antennas</small>"]
    end

    subgraph CLEAN ["Phase Cleanup"]
        CONJ["Conjugate Multiply<br/><small>Remove carrier freq offset</small>"]
        UNWRAP["Phase Unwrap<br/><small>Remove 2π discontinuities</small>"]
        HAMPEL2["Hampel Filter<br/><small>Remove impulse noise</small>"]
    end

    subgraph SELECT ["Subcarrier Intelligence"]
        MINCUT["Min-Cut Partition<br/><small>ruvector-mincut</small>"]
        GATE["Attention Gate<br/><small>ruvector-attn-mincut</small>"]
    end

    subgraph EXTRACT ["Feature Extraction"]
        STFT["STFT Spectrogram<br/><small>Time-frequency decomposition</small>"]
        FRESNELZ["Fresnel Zones<br/><small>ruvector-solver</small>"]
        BVPE["BVP Estimation<br/><small>ruvector-attention</small>"]
    end

    subgraph OUT ["Output Features"]
        AMP["Amplitude Matrix"]
        PHASE2["Phase Matrix"]
        DOPPLER["Doppler Shifts"]
        VITALS["Vital Band Power"]
    end

    IQ --> CONJ --> UNWRAP --> HAMPEL2
    HAMPEL2 --> MINCUT --> GATE
    GATE --> STFT --> FRESNELZ --> BVPE
    BVPE --> AMP & PHASE2 & DOPPLER & VITALS

    style RAW fill:#0d1117,stroke:#58a6ff,color:#c9d1d9
    style CLEAN fill:#161b22,stroke:#58a6ff,color:#c9d1d9
    style SELECT fill:#161b22,stroke:#d29922,color:#c9d1d9
    style EXTRACT fill:#161b22,stroke:#3fb950,color:#c9d1d9
    style OUT fill:#0d1117,stroke:#8b949e,color:#c9d1d9

Deployment Topology

  graph TB
    subgraph EDGE ["Edge (ESP32-S3 Mesh)"]
        E1["Node 1<br/><small>Kitchen</small>"]
        E2["Node 2<br/><small>Living room</small>"]
        E3["Node 3<br/><small>Bedroom</small>"]
    end

    subgraph SERVER ["Server (Rust · 132 MB Docker)"]
        SENSE["Sensing Server<br/><small>:3000 REST · :3001 WS · :5005 UDP</small>"]
        RVF["RVF Model<br/><small>Progressive 3-layer load</small>"]
        STORE["Time-Series Store<br/><small>In-memory ring buffer</small>"]
    end

    subgraph CLIENT ["Clients"]
        BROWSER["Browser<br/><small>Three.js UI · Gaussian splats</small>"]
        MOBILE["Mobile App<br/><small>WebSocket stream</small>"]
        DASH["Dashboard<br/><small>REST polling</small>"]
        IOT["Home Automation<br/><small>MQTT bridge</small>"]
    end

    E1 -->|"UDP :5005<br/>ADR-018 frames"| SENSE
    E2 -->|"UDP :5005"| SENSE
    E3 -->|"UDP :5005"| SENSE
    SENSE <--> RVF
    SENSE <--> STORE
    SENSE -->|"WS :3001<br/>real-time JSON"| BROWSER & MOBILE
    SENSE -->|"REST :3000<br/>on-demand"| DASH & IOT

    style EDGE fill:#1a1a2e,stroke:#e94560,color:#eee
    style SERVER fill:#16213e,stroke:#533483,color:#eee
    style CLIENT fill:#0f3460,stroke:#0f3460,color:#eee

Component	Crate / Module	Description
Aggregator	`wifi-densepose-hardware`	ESP32 UDP listener, ADR-018 frame parser, I/Q → amplitude/phase bridge
Signal Processor	`wifi-densepose-signal`	SpotFi phase sanitization, Hampel filter, STFT spectrogram, Fresnel geometry, BVP
Subcarrier Selection	`ruvector-mincut` + `ruvector-attn-mincut`	Dynamic sensitive/insensitive partitioning, attention-gated noise suppression
Fresnel Solver	`ruvector-solver`	Sparse Neumann series O(sqrt(n)) for TX-body-RX distance estimation
Graph Transformer	`wifi-densepose-train`	COCO BodyGraph (17 kp, 16 edges), cross-attention CSI→pose, GCN message passing
SONA	`sona` crate	Micro-LoRA (rank-4) adaptation, EWC++ catastrophic forgetting prevention
Vital Signs	`wifi-densepose-signal`	FFT-based breathing (0.1-0.5 Hz) and heartbeat (0.8-2.0 Hz) extraction
REST API	`wifi-densepose-sensing-server`	Axum server: `/api/v1/sensing`, `/health`, `/vital-signs`, `/bssid`, `/sona`
WebSocket	`wifi-densepose-sensing-server`	Real-time pose, sensing, and vital sign streaming on `:3001`
Analytics	`wifi-densepose-mat`	Fall detection, activity recognition, START triage (WiFi-Mat disaster module)
Web UI	`ui/`	Three.js scene, Gaussian splat visualization, signal dashboard

🖥️ CLI Usage

Rust Sensing Server — Primary CLI interface

# Start with simulated data (no hardware)
./target/release/sensing-server --source simulate --ui-path ../../ui

# Start with ESP32 CSI hardware
./target/release/sensing-server --source esp32 --udp-port 5005

# Start with Windows WiFi RSSI
./target/release/sensing-server --source wifi

# Run vital sign benchmark
./target/release/sensing-server --benchmark

# Export RVF model package
./target/release/sensing-server --export-rvf model.rvf

# Train a model
./target/release/sensing-server --train --dataset data/ --epochs 100

# Load trained model with progressive loading
./target/release/sensing-server --model wifi-densepose-v1.rvf --progressive

Flag	Description
`--source`	Data source: `auto`, `wifi`, `esp32`, `simulate`
`--http-port`	HTTP port for UI and REST API (default: 8080)
`--ws-port`	WebSocket port (default: 8765)
`--udp-port`	UDP port for ESP32 CSI frames (default: 5005)
`--benchmark`	Run vital sign benchmark (1000 frames) and exit
`--export-rvf`	Export RVF container package and exit
`--load-rvf`	Load model config from RVF container
`--save-rvf`	Save model state on shutdown
`--model`	Load trained `.rvf` model for inference
`--progressive`	Enable progressive loading (Layer A instant start)
`--train`	Train a model and exit
`--dataset`	Path to dataset directory (MM-Fi or Wi-Pose)
`--epochs`	Training epochs (default: 100)

REST API & WebSocket — Endpoints reference

REST API (Rust Sensing Server)

GET  /api/v1/sensing              # Latest sensing frame
GET  /api/v1/vital-signs          # Breathing, heart rate, confidence
GET  /api/v1/bssid                # Multi-BSSID registry
GET  /api/v1/model/layers         # Progressive loading status
GET  /api/v1/model/sona/profiles  # SONA profiles
POST /api/v1/model/sona/activate  # Activate SONA profile

WebSocket: ws://localhost:3001/ws/sensing (real-time sensing + vital signs)

Default ports (Docker): HTTP 3000, WS 3001. Binary defaults: HTTP 8080, WS 8765. Override with --http-port / --ws-port.

Hardware Support — Devices, cost, and guides

Hardware	CSI	Cost	Guide
ESP32-S3	Native	~$8	Tutorial #34
Intel 5300	Firmware mod	~$15	Linux `iwl-csi`
Atheros AR9580	ath9k patch	~$20	Linux only
Any Windows WiFi	RSSI only	$0	Tutorial #36
Any macOS WiFi	RSSI only (CoreWLAN)	$0	ADR-025
Any Linux WiFi	RSSI only (`iw`)	$0	Requires `iw` + `CAP_NET_ADMIN`

QEMU Firmware Testing (ADR-061) — 9-Layer Platform

Test ESP32-S3 firmware without physical hardware using Espressif’s QEMU fork. The platform provides 9 layers of testing capability:

Layer	Capability	Script / Config
1	Mock CSI generator (10 physics-based scenarios)	`firmware/esp32-csi-node/main/mock_csi.c`
2	Single-node QEMU runner + UART validation (16 checks)	`scripts/qemu-esp32s3-test.sh`, `scripts/validate_qemu_output.py`
3	Multi-node TDM mesh simulation (TAP networking)	`scripts/qemu-mesh-test.sh`, `scripts/validate_mesh_test.py`
4	GDB remote debugging (VS Code integration)	`.vscode/launch.json`
5	Code coverage (gcov/lcov via apptrace)	`firmware/esp32-csi-node/sdkconfig.coverage`
6	Fuzz testing (libFuzzer + ASAN/UBSAN)	`firmware/esp32-csi-node/test/fuzz_*.c`
7	NVS provisioning matrix (14 configs)	`scripts/generate_nvs_matrix.py`
8	Snapshot regression (sub-second VM restore)	`scripts/qemu-snapshot-test.sh`
9	Chaos testing (fault injection + health monitoring)	`scripts/qemu-chaos-test.sh`, `scripts/inject_fault.py`, `scripts/check_health.py`

# Quick start: build + run + validate
cd firmware/esp32-csi-node
idf.py -D SDKCONFIG_DEFAULTS="sdkconfig.defaults;sdkconfig.qemu" build

# Single-node test (builds, merges flash, runs QEMU, validates output)
bash scripts/qemu-esp32s3-test.sh

# Multi-node mesh test (3 QEMU instances with TDM)
sudo bash scripts/qemu-mesh-test.sh 3

# Fuzz testing (60 seconds per target)
cd firmware/esp32-csi-node/test && make all CC=clang && make run_serialize FUZZ_DURATION=60

# Chaos testing (fault injection resilience)
bash scripts/qemu-chaos-test.sh --faults all --duration 120

10 test scenarios: empty room, static person, walking, fall, multi-person, channel sweep, MAC filter, ring overflow, boundary RSSI, zero-length frames.

14 NVS configs: default, WiFi-only, full ADR-060, edge tiers 0/1/2, TDM mesh, WASM signed/unsigned, 5GHz, boundary max/min, power-save, empty-strings.

CI: GitHub Actions workflow runs 7 NVS matrix configs, 3 fuzz targets, and NVS binary validation on every push to firmware/.

See ADR-061 for the full architecture.

QEMU Swarm Configurator (ADR-062)

Test multiple ESP32-S3 nodes simultaneously using a YAML-driven orchestrator. Define node roles, network topologies, and validation assertions in a config file.

# Quick smoke test (2 nodes, 15 seconds)
python3 scripts/qemu_swarm.py --preset smoke

# Standard 3-node test (coordinator + 2 sensors)
python3 scripts/qemu_swarm.py --preset standard

# See all presets
python3 scripts/qemu_swarm.py --list-presets

# Preview without running
python3 scripts/qemu_swarm.py --preset standard --dry-run

Topologies: star (sensors → coordinator), mesh (fully connected), line (relay chain), ring (circular).

Node roles: sensor (generates CSI), coordinator (aggregates), gateway (bridges to host).

7 presets: smoke, standard, ci-matrix, large-mesh, line-relay, ring-fault, heterogeneous.

9 swarm assertions: boot check, crash detection, TDM collision, frame production, coordinator reception, fall detection, frame rate, boot time, heap health.

See ADR-062 and the User Guide for step-by-step instructions.

Python Legacy CLI — v1 API server commands

wifi-densepose start                    # Start API server
wifi-densepose -c config.yaml start     # Custom config
wifi-densepose -v start                 # Verbose logging
wifi-densepose status                   # Check status
wifi-densepose stop                     # Stop server
wifi-densepose config show              # Show configuration
wifi-densepose db init                  # Initialize database
wifi-densepose tasks list               # List background tasks

Documentation Links

User Guide — installation, first run, API, hardware setup, QEMU testing
WiFi-Mat User Guide | Domain Model
ADR-061 QEMU platform | ADR-062 Swarm configurator
ADR-021 | ADR-022 | ADR-023

🧪 Testing

542+ tests across 7 suites — zero mocks, hardware-free simulation

# Rust tests (primary — 542+ tests)
cd rust-port/wifi-densepose-rs
cargo test --workspace

# Sensing server tests (229 tests)
cargo test -p wifi-densepose-sensing-server

# Vital sign benchmark
./target/release/sensing-server --benchmark

# Python tests
python -m pytest v1/tests/ -v

# Pipeline verification (no hardware needed)
./verify

Suite	Tests	What It Covers
sensing-server lib	147	Graph transformer, trainer, SONA, sparse inference, RVF
sensing-server bin	48	CLI integration, WebSocket, REST API
RVF integration	16	Container build, read, progressive load
Vital signs integration	18	FFT detection, breathing, heartbeat
wifi-densepose-signal	83	SOTA algorithms, Doppler, Fresnel
wifi-densepose-mat	139	Disaster response, triage, localization
wifi-densepose-wifiscan	91	8-stage RSSI pipeline

🚀 Deployment

Docker deployment — Production setup with docker-compose

# Rust sensing server (132 MB)
docker pull ruvnet/wifi-densepose:latest
docker run -p 3000:3000 -p 3001:3001 -p 5005:5005/udp ruvnet/wifi-densepose:latest

# Python pipeline (569 MB)
docker pull ruvnet/wifi-densepose:python
docker run -p 8765:8765 -p 8080:8080 ruvnet/wifi-densepose:python

# Both via docker-compose
cd docker && docker compose up

# Export RVF model
docker run --rm -v $(pwd):/out ruvnet/wifi-densepose:latest --export-rvf /out/model.rvf

Environment Variables

RUST_LOG=info                    # Logging level
WIFI_INTERFACE=wlan0             # WiFi interface for RSSI
POSE_CONFIDENCE_THRESHOLD=0.7    # Minimum confidence
POSE_MAX_PERSONS=10              # Max tracked individuals

📊 Performance Metrics

Measured benchmarks — Rust sensing server, validated via cargo bench

Rust Sensing Server

Metric	Value
Vital sign detection	11,665 fps (86 µs/frame)
Full CSI pipeline	54,000 fps (18.47 µs/frame)
Motion detection	186 ns (~5,400x vs Python)
Docker image	132 MB
Memory usage	~100 MB
Test count	542+

Python vs Rust

Operation	Python	Rust	Speedup
CSI Preprocessing	~5 ms	5.19 µs	1000x
Phase Sanitization	~3 ms	3.84 µs	780x
Feature Extraction	~8 ms	9.03 µs	890x
Motion Detection	~1 ms	186 ns	5400x
Full Pipeline	~15 ms	18.47 µs	810x

🤝 Contributing

Dev setup, code standards, PR process

git clone https://github.com/ruvnet/RuView.git
cd RuView

# Rust development
cd rust-port/wifi-densepose-rs
cargo build --release
cargo test --workspace

# Python development
python -m venv venv && source venv/bin/activate
pip install -r requirements-dev.txt && pip install -e .
pre-commit install

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes
Push and open a Pull Request

📄 Changelog

Release history

v3.2.0 — 2026-03-03

Edge intelligence: 24 hot-loadable WASM modules for on-device CSI processing on ESP32-S3.

ADR-041 Edge Intelligence Modules — 24 no_std Rust modules compiled to wasm32-unknown-unknown, loaded via WASM3 on ESP32; 8 categories covering signal intelligence, adaptive learning, spatial reasoning, temporal analysis, AI security, quantum-inspired, autonomous systems, and exotic algorithms
Vendor Integration — Algorithms ported from midstream (DTW, attractors, Flash Attention, min-cut, optimal transport) and sublinear-time-solver (PageRank, HNSW, sparse recovery, spiking NN)
On-device gesture learning — User-teachable DTW gesture recognition with 3-rehearsal protocol and 16 template slots
Lifelong learning (EWC++) — Elastic Weight Consolidation prevents catastrophic forgetting when learning new tasks
AI security modules — FNV-1a replay detection, injection/jamming detection, 6D behavioral anomaly profiling with Mahalanobis scoring
Self-healing mesh — 8-node mesh with health tracking, degradation/recovery hysteresis, and coverage redistribution
Common utility library — vendor_common.rs shared across all 24 modules: CircularBuffer, EMA, WelfordStats, DTW, FixedPriorityQueue, vector math
243 tests passing — All modules include comprehensive inline tests; 0 failures
Security audit — 15 findings addressed (1 critical, 3 high, 6 medium, 5 low)

v3.1.0 — 2026-03-02

Multistatic sensing, persistent field model, and cross-viewpoint fusion — the biggest capability jump since v2.0.

Project RuvSense (ADR-029) — Multistatic mesh: TDM protocol, channel hopping (ch1/6/11), multi-band frame fusion, coherence gating, 17-keypoint Kalman tracker with re-ID; 10 new signal modules (5,300+ lines)
RuvSense Persistent Field Model (ADR-030) — 7 exotic sensing tiers: field normal modes (SVD), RF tomography, longitudinal drift detection, intention prediction, cross-room identity, gesture classification, adversarial detection
Project RuView (ADR-031) — Cross-viewpoint attention with geometric bias, Geometric Diversity Index, viewpoint fusion orchestrator; 5 new ruvector modules (2,200+ lines)
TDM Hardware Protocol — ESP32 sensing coordinator: sync beacons, slot scheduling, clock drift compensation (±10ppm), 20 Hz aggregate rate
Channel-Hopping Firmware — ESP32 firmware extended with hop table, timer-driven channel switching, NDP injection stub; NVS config for all TDM parameters; fully backward-compatible
DDD Domain Model — 6 bounded contexts, ubiquitous language, aggregate roots, domain events, full event bus specification
ruvector-crv 6-stage CRV signal-line integration (ADR-033) — Maps Coordinate Remote Viewing methodology to WiFi CSI: gestalt classification, sensory encoding, GNN topology, SNN coherence gating, differentiable search, MinCut partitioning; cross-session convergence for multi-room identity continuity
ADR-032 multistatic mesh security hardening — HMAC-SHA256 beacon auth, SipHash-2-4 frame integrity, NDP rate limiter, coherence gate timeout, bounded buffers, NVS credential zeroing, atomic firmware state
ADR-032a QUIC transport layer — midstreamer-quic TLS 1.3 AEAD for aggregator nodes, dual-mode security (ManualCrypto/QuicTransport), QUIC stream mapping, connection migration, congestion control
ADR-033 CRV signal-line sensing integration — Architecture decision record for the 6-stage CRV pipeline mapping to ruvector components
Temporal gesture matching — midstreamer-temporal-compare DTW/LCS/edit-distance gesture classification with quantized feature comparison
Attractor drift analysis — midstreamer-attractor Takens’ theorem phase-space embedding with Lyapunov exponent regime detection (Stable/Periodic/Chaotic)
v0.3.0 published — All 15 workspace crates published to crates.io with updated dependencies
28,000+ lines of new Rust code across 26 modules with 400+ tests
Security hardened — Bounded buffers, NaN guards, no panics in public APIs, input validation at all boundaries

v3.0.0 — 2026-03-01

Major release: AETHER contrastive embedding model, AI signal processing backbone, cross-platform adapters, Docker Hub images, and comprehensive README overhaul.

Project AETHER (ADR-024) — Self-supervised contrastive learning for WiFi CSI fingerprinting, similarity search, and anomaly detection; 55 KB model fits on ESP32
AI Backbone (wifi-densepose-ruvector) — 7 RuVector integration points replacing hand-tuned thresholds with attention, graph algorithms, and smart compression; published to crates.io
Cross-platform RSSI adapters — macOS CoreWLAN and Linux iw Rust adapters with #[cfg(target_os)] gating (ADR-025)
Docker images published — ruvnet/wifi-densepose:latest (132 MB Rust) and :python (569 MB)
Project MERIDIAN (ADR-027) — Cross-environment domain generalization: gradient reversal, geometry-conditioned FiLM, virtual domain augmentation, contrastive test-time training; zero-shot room transfer
10-phase DensePose training pipeline (ADR-023/027) — Graph transformer, 6-term composite loss, SONA adaptation, RVF packaging, hardware normalization, domain-adversarial training
Vital sign detection (ADR-021) — FFT-based breathing (6-30 BPM) and heartbeat (40-120 BPM), 11,665 fps
WiFi scan domain layer (ADR-022/025) — 8-stage signal intelligence pipeline for Windows, macOS, and Linux
700+ Rust tests — All passing, zero mocks

v2.0.0 — 2026-02-28

Complete Rust sensing server, SOTA signal processing, WiFi-Mat disaster response, ESP32 hardware, RuVector integration, guided installer, and security hardening.

Rust sensing server — Axum REST API + WebSocket, 810x speedup over Python, 54K fps pipeline
RuVector integration — 11 vendored crates for HNSW, attention, GNN, temporal compression, min-cut, solver
6 SOTA signal algorithms (ADR-014) — SpotFi, Hampel, Fresnel, spectrogram, subcarrier selection, BVP
WiFi-Mat disaster response — START triage, 3D localization, priority alerts — 139 tests
ESP32 CSI hardware — Binary frame parsing, $54 starter kit, 20 Hz streaming
Guided installer — 7-step hardware detection, 8 install profiles
Three.js visualization — 3D body model, 17 joints, real-time WebSocket
Security hardening — 10 vulnerabilities fixed

📄 License

MIT License — see LICENSE for details.

📞 Support

GitHub Issues | Discussions | PyPI

WiFi DensePose — Privacy-preserving human pose estimation through WiFi signals.

Human Pose on Producthunt daily

RuView

ruvnet/RuView

π RuView

See through walls with WiFi

π RuView is a WiFi sensing platform that turns radio signals into spatial intelligence.

Built for low-power edge applications

Real-Time Dense Point Cloud (NEW)

What’s New in v0.7.0

Pre-Trained Models (v0.6.0) — No Training Required

17 Sensing Applications (v0.6.0)

What’s New in v0.5.5

What’s New in v0.5.4

📖 Documentation

🚀 Key Features

Sensing

Intelligence

Performance & Deployment

🔬 How It Works

🏢 Use Cases & Applications

Edge Intelligence (ADR-041)

📦 Installation

🚀 Quick Start

1. Install

2. Start the System

3. REST API

4. Real-time WebSocket

📋 Table of Contents

6-Stage CSI Signal Line

📡 Signal Processing & Sensing

Flash and provision

Multi-node mesh

Cognitum Seed integration (ADR-069)

On-device intelligence (v0.3.0-alpha)

Performance Benchmarks (Validated)

🧠 Models & Training

End-to-End Pipeline

Signal Processing Detail

Deployment Topology

🖥️ CLI Usage

REST API (Rust Sensing Server)

🧪 Testing

🚀 Deployment

Environment Variables

📊 Performance Metrics

Rust Sensing Server

Python vs Rust

🤝 Contributing

📄 Changelog

v3.2.0 — 2026-03-03

v3.1.0 — 2026-03-02

v3.0.0 — 2026-03-01

v2.0.0 — 2026-02-28

📄 License

📞 Support