π 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 (2.5% PCK@20) — camera-labeled data significantly improves accuracy

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

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

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.

# 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):

17 Sensing Applications (v0.6.0)

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

Health & Wellness:

Environment & Security:

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

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

What's New in v0.5.5

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

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

What's New in v0.5.4

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.

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):

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

📖 Documentation

<em>Real-time pose skeleton from WiFi CSI signals — no cameras, no wearables</em>

<a href="https://ruvnet.github.io/RuView/"><strong>▶ Live Observatory Demo</strong></a>  |  <a href="https://ruvnet.github.io/RuView/pose-fusion.html"><strong>▶ Dual-Modal Pose Fusion Demo</strong></a>

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.

Intelligence

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

Performance & Deployment

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

🔬 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.

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.

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.

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.

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.

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):

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

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

🧠 Adaptive Learning — On-device learning without cloud connectivity

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

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

🛡️ AI Security — Tamper detection and behavioral anomaly profiling

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

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

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

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

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

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

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

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

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

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

Architecture

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

Fingerprint Index Types

Model Size

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

./install.sh

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

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

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

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

# 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

• 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)

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)

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

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

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.

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.

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.

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.

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.

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.

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.

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

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

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:

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)

Acceptance Test

New Rust modules (9,000+ lines)

Firmware extensions (C, backward-compatible)

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.

6-Stage CSI Signal Line

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

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

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   │
└───────────────────────┘

Flash and provision

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

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

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.

Performance Benchmarks (Validated)

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

./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.

cargo test -p wifi-densepose-wifiscan

See ADR-022 and Tutorial #36.

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.

Triage classification (START protocol compatible):

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

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.

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

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:

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

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:

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

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:

Training pipeline components:

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

# 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

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

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

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 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.

End-to-End Pipeline

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

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

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

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

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

    subgraph API ["🌐 Output Layer"]
        direction LR
        REST["REST API
<small>Axum :3000 · 6 endpoints</small>"]
        WS["WebSocket
<small>:3001 · real-time stream</small>"]
        ANALYTICS["Analytics
<small>Fall · Activity · START triage</small>"]
        UI["Web UI
<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
<small>56–192 subcarriers × N antennas</small>"]
    end

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

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

    subgraph EXTRACT ["Feature Extraction"]
        STFT["STFT Spectrogram
<small>Time-frequency decomposition</small>"]
        FRESNELZ["Fresnel Zones
<small>ruvector-solver</small>"]
        BVPE["BVP Estimation
<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
<small>Kitchen</small>"]
        E2["Node 2
<small>Living room</small>"]
        E3["Node 3
<small>Bedroom</small>"]
    end

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

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

    E1 -->|"UDP :5005
ADR-018 frames"| SENSE
    E2 -->|"UDP :5005"| SENSE
    E3 -->|"UDP :5005"| SENSE
    SENSE <--> RVF
    SENSE <--> STORE
    SENSE -->|"WS :3001
real-time JSON"| BROWSER & MOBILE
    SENSE -->|"REST :3000
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

🖥️ CLI Usage

# 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

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.

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

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

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.

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

• 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

# 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

🚀 Deployment

# 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

Rust Sensing Server

Python vs Rust

🤝 Contributing

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

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

📄 Changelog

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.