RuView by ruv

RuView by ruv

Small models that read WiFi signal changes from an ESP32 chip to estimate pose, movement and presence without a camera, plus a script set to train your own. Suits makers and researchers who test on consenting subjects.

Made by ruv on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: RuView is a set of small models that read changes in WiFi signals from an ESP32 chip to sense people. The card lists presence, movement, breathing, heart rate, pose, head count and fall alerts, all without a camera. It holds a pose model and a compact contrastive sensing model.

Who it suits: Makers and researchers who want to experiment with camera-free sensing on cheap hardware. The card prices one ESP32-S3 board at about $9. Use it only in places where the people present know about it and agree.

Industry | Who uses it | How they use it | Example
Research | Wireless sensing researchers | Study pose and presence from WiFi signal data | Train a pose model from a short recording
Smart home | Hobbyist makers | Sense activity in a room without a camera | Detect movement with an ESP32 board
Care settings | Prototype builders | Explore fall alerts and breathing checks | Test a fall alert with consenting volunteers
Embedded systems | Edge developers | Run tiny models on a microcontroller | Fit the 4-bit sensing model on a board

Anyone who needs a verified, production-grade presence detector can skip it, because the card retracts its earlier presence accuracy claim.

Where to use it:

• ESP32-S3 boards that stream WiFi channel state data
• The RuView sensing pipeline, which the card says these models plug into
• Computers such as a Mac mini for training, with no GPU needed according to the card
• Windows, macOS or Linux, after downloading with Hugging Face's hub tool

Use case | Who | What they get back
Pose estimation | Researchers | 17 keypoints per frame from WiFi data, at 92.9% PCK@20 per the card
Presence and motion | Makers | A reading of whether someone is there and whether they move
Breathing and heart rate | Prototype builders | Contactless estimates, which the card lists as 6 to 30 and 40 to 120 beats per minute
Per-room tuning | Edge developers | Small adapter files for individual rooms or nodes

How to set it up:

• Python with pip
• An ESP32-S3 board for live sensing, and a checkout of the RuView project
• A few minutes of recording, since the card says 5 minutes of data and 19 minutes of training gives the pose model

1. Install the Hugging Face hub package.
2. Download the model files into a models folder.
3. Flash the board and, if you want your own pose model, run the collection and training scripts.

pip install -U huggingface_hub
hf download ruv/ruview

# Download all models
pip install huggingface_hub
huggingface-cli download ruv/ruview --local-dir models/

How to use it: Flash the ESP32-S3 with the firmware files, then run the project's scripts. The first command writes the firmware, and the last four collect paired data and train a pose model.

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 scripts/collect-ground-truth.py --duration 300 --preview
python scripts/record-csi-udp.py --duration 300
node scripts/align-ground-truth.js --gt data/ground-truth/*.jsonl --csi data/recordings/*.csi.jsonl
node scripts/train-wiflow-supervised.js --data data/paired/*.jsonl --scale lite

Tool | What it does
esptool | Writes the firmware to the ESP32-S3
collect-ground-truth.py | Records camera keypoints used as training labels
record-csi-udp.py | Records the WiFi signal data
align-ground-truth.js | Pairs the camera labels with the signal recordings
train-wiflow-supervised.js | Trains the lite pose model

Example: You record five minutes of WiFi data while a webcam captures your movement for labels. After about 19 minutes of training you get a small pose model that estimates 17 body keypoints from WiFi signals alone.

For newcomers and experts: If you are new, start by downloading the models and reading the repository files before buying hardware. Treat every accuracy number as a claim to test in your own room.

Experts will note the pose model feeds amplitude data through two dilated causal convolution blocks and two dense layers to 17 normalized keypoints. It has about 189K parameters. The sensing model produces 128-dimension embeddings, with 4-bit and 2-bit versions for small chips.

Title: Sensing model file size in KB
2-bit file: 4 KB
4-bit file: 8 KB
8-bit file: 16 KB
Full safetensors: 48 KB

An ESP32 records WiFi signal data
Models read the signal changes
The pipeline outputs pose or presence
You test the result in your own room

Good to know:

• Correction: an earlier 100 percent presence accuracy figure was retracted because it came from a single-class recording, so treat presence accuracy as unverified
• Sizes: the pose model is 974 KB and the 4-bit sensing model is 8 KB
• Privacy: sensing people without a camera is still monitoring, so get consent from everyone present
• License: MIT
• Cost to run: no API key or account is named, and the board costs about $9 per the card
• Data it reaches: it reads WiFi signal data from your own board, plus webcam keypoints if you train a pose model
• Not for: the card names no limits, but covert monitoring or any claim of verified accuracy is outside what it supports

On Hugging Face, 13 November 2026

• Task: other
• Library: onnxruntime
• Formats: Safetensors
• Downloads in the last 30 days: 69
• Likes: 37
• License: mit
• Languages: en
• Tags: onnxruntime, safetensors, sona-lora, wifi-sensing, vital-signs, presence-detection, pose-estimation, edge-ai, esp32, self-supervised, camera-supervised, cognitum

Links

• Model: https://huggingface.co/ruv/ruview
• Files: https://huggingface.co/ruv/ruview/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download ruv/ruview

Then follow the usage in its model card. Nothing in this kit runs by itself.