RuView

1. What is RuView?

RuView is an open-source project that uses WiFi signals to sense people in a room without any camera. The principle: WiFi fills a room with radio waves, and when someone moves, or even just breathes, those waves are disturbed in measurable ways. RuView reads the disturbances to work out whether someone is present, how they are moving, and to estimate breathing and heart rate.

Three things need saying plainly before you install anything:

• It is beta, research-grade software. The author states that APIs and firmware may still change.
• Real sensing requires extra hardware. You need ESP32-S3 boards (small WiFi-capable microcontroller boards, about 9 US dollars each according to the README). An ordinary laptop can only measure signal strength, which is enough for coarse presence and motion detection.
• The Docker version runs on simulated data. It shows you the interface and how the system behaves; it is not looking through the walls of your home.

The project is MIT licensed and free. The author has also walked back earlier overstated numbers: the 17-point skeleton model running live on a single ESP32 is still a first cut, with accuracy below the project's own target.

Note: The README says these are research and prototype applications, not medical devices, emergency systems or safety-certified controls. Do not rely on it to watch over someone's health.

A good fit if:

• You are curious and want to see for yourself what a "WiFi that sees people" interface looks like.
• You enjoy tinkering with hardware and are happy to buy a few ESP32-S3 boards and flash firmware.
• You work on research or smart-home projects and need camera-free presence sensing.

Not a good fit if:

• You expect your phone or laptop to see through walls once it is installed. That will not happen.
• You need a finished, plug-and-play product with a warranty.

2. What do you need?

To view the web demo: just a browser. A phone works too.

To run the simulation on your computer:

Requirement	Minimum	Recommended
Operating system	Windows 10/11, macOS 10.15, Ubuntu 18.04	Latest stable release
RAM	4 GB	8 GB or more
Free disk space	2 GB	5 GB
Docker	Version 20 or newer	Version 24 or newer

• Docker: software that runs an application inside a ready-made "container", so you do not have to install each component yourself. Windows and macOS users get Docker Desktop at https://www.docker.com/products/docker-desktop/
• No account and no API key.

For real sensing (optional, advanced):

• ESP32-S3 boards. The documentation prices a mesh of 3 to 6 boards at roughly 54 US dollars. A single board works but has limited spatial resolution; the author recommends two or more.
• A WiFi router and a computer running the receiving software.
• Python, to run the firmware flashing and board setup tools. Download: https://www.python.org/downloads/

Note: The README states that the ESP32-C3 and the original ESP32 are not supported. Check the exact board name before buying.

3. Step-by-step installation

Method 1: View the demo on the web (nothing to install)

Step 1: Open the demo page

Go to https://ruvnet.github.io/RuView/ in your browser. This is the "Live Observatory Demo" hosted by the author.

You are on track when: you see a 3D interface with a human skeleton and readings. It is a demonstration visualization, not data from your home.

If all you want is to see what RuView looks like, you can stop here.

Method 2: Run the simulation locally with Docker

Step 1: Install and start Docker Desktop

Download the installer from https://www.docker.com/products/docker-desktop/, install it like any other program and open it. Wait until Docker reports that it is running.

Check with:

docker --version

You are on track when: it prints a version number of 20 or higher.

Step 2: Download the RuView image

docker pull ruvnet/wifi-densepose:latest

wifi-densepose is the project's earlier name and is still used for the image. It runs on Intel / AMD machines as well as Apple Silicon Macs.

You are on track when: the download bars complete and you are back at the prompt without an error.

Step 3: Run it

docker run -p 3000:3000 -p 3001:3001 ruvnet/wifi-densepose:latest

The two -p parts open two ports so your browser can talk to the program: port 3000 for the web page, port 3001 for the live data stream.

You are on track when: the terminal shows log lines and does not exit. Leave this window open.

Step 4: Open the interface

In your browser, go to:

http://localhost:3000

You are on track when: you see a 3D skeleton (17 keypoints), a signal amplitude heatmap, a phase plot and a panel with breathing and heart rate.

Method 3: Real sensing with ESP32-S3 boards (advanced)

This part is for people who have flashed microcontroller firmware before. In outline:

1. Download prebuilt firmware from the Releases page: https://github.com/ruvnet/RuView/releases. The documentation says to always use v0.4.3.1 or later; older versions raise false fall alerts or ship with sensing disabled.
2. Flash the board with the esptool utility. The full flash command and the file names are in the "ESP32-S3 Mesh" section of the User Guide: https://github.com/ruvnet/RuView/blob/main/docs/user-guide.md
3. Download the RuView source code (this needs Git, from https://git-scm.com/downloads), because the board setup tool lives inside it:

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

4. Give the board your WiFi details and the address of the computer that will receive its data. Replace COM7, the network name, the password and the IP address with your own values:

python firmware/esp32-csi-node/provision.py --port COM7 --ssid "YourWiFi" --password "YourPassword" --target-ip 192.168.1.20

5. Start RuView in the mode that listens for the boards:

docker run -p 3000:3000 -p 3001:3001 -p 5005:5005/udp -e CSI_SOURCE=esp32 ruvnet/wifi-densepose:latest

You are on track when: the interface at http://localhost:3000 shows readings that change as you move around the room.

4. First use

With the simulation (Method 2), try three things:

Look at the dashboard. Open http://localhost:3000/ui/index.html. It is a tabbed monitoring view with a rotatable 3D body model, a signal heatmap, a phase plot and live breathing and heart-rate readouts. In simulated mode the vital signs appear after a few seconds of warm-up.

Look at the Observatory. Open http://localhost:3000/ui/observatory.html for a 3D room with wireframe figures.

Confirm the program is healthy. Open a second terminal window and type:

curl http://localhost:3000/health

The correct result is a line containing "status":"ok" and "source":"simulated". The word simulated confirms you are looking at synthetic data.

When you are done, go back to the window running Docker and press Ctrl+C to stop it.

5. Common problems and fixes

Symptom	Cause	Fix
docker gives "command not found" / "not recognized", or says it cannot connect to Docker	Docker is not installed, or Docker Desktop is not open	Install Docker Desktop, start it, wait until it is running and try again
The browser shows "Connection refused" at localhost:3000	The port mapping was left out	Run the exact command from Step 3, including -p 3000:3000 -p 3001:3001
The interface loads but nothing moves	The live data port 3001 is missing	Stop the program and rerun it with -p 3001:3001
On a Mac: "no matching manifest for linux/arm64"	Docker is holding stale information about the image	Run docker pull ruvnet/wifi-densepose:latest again. If it persists, use the command below the table
Breathing and heart rate show 0	Simulated mode needs a few seconds to warm up; signal-strength-only laptop sensing lacks the resolution	Wait a few seconds. Real measurements need ESP32 hardware
The Observatory says DEMO instead of LIVE	You opened the page as a local file, or the browser kept old settings	Open it through http://localhost:3000/ui/observatory.html and press Ctrl+Shift+R for a hard refresh
The ESP32 is flashed but no data arrives	The board is on a different WiFi network, the target address is wrong, or a firewall is blocking it	Make sure the board and computer share one WiFi network, rerun provision.py with the computer's correct IP address, and allow UDP port 5005 through the firewall

Pull command for Apple Silicon Macs when you hit "no matching manifest":

docker pull --platform linux/arm64 ruvnet/wifi-densepose:latest

Anything else: search or ask at https://github.com/ruvnet/RuView/issues

6. Uninstalling / updating

Updating the Docker version: pull the newer image and run it as before.

docker pull ruvnet/wifi-densepose:latest

Removing the Docker version:

1. Stop the program with Ctrl+C in its window.
2. List the leftover containers:

docker ps -a

3. Remove each entry whose image is ruvnet/wifi-densepose, using the ID in the first column:

docker rm CONTAINER_ID

4. Delete the image to free the disk space:

docker rmi ruvnet/wifi-densepose:latest

If you have no other use for Docker, uninstall Docker Desktop like any other program.

Firmware on ESP32 boards: update by flashing a newer build from the Releases page. The newest firmware at the time of writing is 0.8.13 (29 September 2026), marked as a pre-release. Its release notes say that flashing the update keeps your saved WiFi settings. The stable version the User Guide recommends for an ESP32-S3 mesh is v0.5.0.

7. Frequently asked questions

Does it cost money? The software is free under the MIT license. The web demo and the Docker simulation cost nothing. You only pay if you buy ESP32-S3 boards for real sensing.

Do I need an internet connection? You need one to download Docker and the image. Once it is running, the README says the system runs entirely on local edge hardware with no cloud and no internet required.

Is any data sent anywhere? According to the README, RuView processes everything locally and uses no camera, so no images are ever captured. Extra integrations such as Home Assistant or the Cognitum Seed device are optional and have to be switched on by you.

What can I do with just a laptop and no boards? You can watch the simulation. Beyond that, a laptop can do coarse presence and motion detection from signal strength, but that route means building the program from source, and it cannot produce a skeleton or a trustworthy heart rate.

Does it really see through walls? The README lists through-wall sensing at up to about 5 metres, depending on the signal. That means detecting presence and movement, not a picture like a camera gives. The author has retracted the earlier "100% presence" figure and replaced it with a more cautious measurement.