RuView

What it is

RuView is an open source WiFi sensing platform made by ruvnet. A router fills a room with radio waves, and people change them when they move or breathe. A low-cost ESP32 board records those changes as Channel State Information (CSI). RuView’s software turns the record into presence, movement, breathing and heart-rate estimates, with no camera. This listing covers the software and the part that touches your coding agent. That part is a Claude Code plugin, Codex prompts, an npm toolkit with an MCP server and a live sensing pane.

1. A router fills the room with radio waves
2. An ESP32 board records how people change them
3. Signal processing estimates presence, motion and vitals
4. The server shares them over REST, WebSocket and MQTT
5. A dashboard, Home Assistant or your agent reads them

Who it suits

Makers and developers who want to sense a room without a camera and have an ESP32 board or will buy one. Home Assistant users get presence and motion from the MQTT feed. Researchers get a Rust and Python codebase with a published benchmark and a one-command proof. Developers who work with Claude Code or Codex get commands that walk through flashing, provisioning, sensing apps, training and verification, and the npm toolkit adds a room-calibration tool. The README labels the project beta and says its applications are research and prototypes.

Skip it if you need a medical-grade reading. The README says vital-sign and pose output needs independent validation on your own hardware, room and people before any operational use. It also calls the live 17-keypoint pose model first-cut and below its own target, so skip it if pose from one board is the point.

Where to use it

The docs write full steps for Claude Code and Codex, and give ChatGPT and other MCP clients a way in. The sensing server itself runs in Docker or from a Rust build.

• Claude Code: a plugin from the maker’s marketplace with seven commands, nine skills and three agents. The npm toolkit’s MCP server and a live sensing pane called ruview-live are separate installs
• Codex: the same seven commands as prompts you copy into its prompt folder, an AGENTS.md of project rules, and a read-only agent run from the npm toolkit
• ChatGPT: the MCP server over HTTP through an HTTPS tunnel, with a console widget that shows captures
• Cursor and other MCP clients: the stdio MCP server, and a second one, rvagent, that the user guide says Cursor can call
• Home Assistant: an MQTT feed that makes one device for each node
• Python: two PyPI packages with the signal-processing code and clients

Hardware commands only work on the machine the board is plugged into. A cloud agent cannot reach your USB ports.

How to set it up

Get it saves a zip of Mindket’s setup notes in your downloads folder, with each agent’s and platform’s steps from the maker’s docs. The quickest start needs no hardware: a Docker image that runs on simulated data.

1. Run the Docker demo below. The container exits with code 64 unless RUVIEW_API_TOKEN is set.
2. Open http://localhost:3000 and look at the dashboard.
3. In Claude Code, add the plugin marketplace and install the plugin.
4. Type /ruview-start and pick the Docker demo, a repo build or a live ESP32.

export RUVIEW_API_TOKEN=$(openssl rand -hex 32)
docker run -p 127.0.0.1:3000:3000 -p 127.0.0.1:3001:3001 -e RUVIEW_API_TOKEN ruvnet/wifi-densepose:latest

/plugin marketplace add ruvnet/RuView
/plugin install ruview@ruview

Claude Code can also take the MCP server, with the line the user guide gives.

claude mcp add ruview -- npx -y @ruvnet/ruview@0.9.1 mcp start

For a live board, the firmware README has you flash a release bundle with esptool, then give the board your WiFi details without reflashing it.

printf '%s\n' 'YourPass' > ~/.wifi-pass && chmod 600 ~/.wifi-pass
python firmware/esp32-csi-node/provision.py --port COM7 \
  --ssid "YourSSID" --password-file ~/.wifi-pass --target-ip 192.168.1.20

How to use it

In Claude Code, the plugin’s commands run the work. The Codex prompts mirror them. The README gives each one’s job.

Outside the agent, the npm toolkit has its own commands. Run them on the machine the board is plugged into.

npx @ruvnet/ruview doctor
npx @ruvnet/ruview devices
npx @ruvnet/ruview esp32 --seconds 10

The first checks your setup and prints a fix for each failing check. The second lists what is plugged in. The third captures what your nodes stream to this machine, with each node’s rate, loss and signal strength.

Example

You have the Docker demo running and want to see what the server answers. In a second terminal, you ask it for its health and its vital signs.

curl http://localhost:3000/health
curl http://localhost:3000/api/v1/vital-signs

The user guide says the health call answers like this in simulated mode:

{"status":"ok","source":"simulated","clients":0}

The source field says simulated, so every number on the dashboard is synthetic. The container also demands a token, so a call may need the header the guide shows on its nodes call: -H "Authorization: Bearer $RUVIEW_API_TOKEN". This demo container hears no board. The user guide says ESP32 nodes in Docker need the UDP port published, CSI_SOURCE=esp32 and a source guard such as RUVIEW_UDP_ALLOW.

For newcomers and experts

If you are new. WiFi is radio, and a body in a room changes how that radio bounces. CSI is the detailed record of those changes that some chips can report, and an ESP32-S3 is a small board that does. RuView reads the record and estimates who is there and how they breathe. Start with the Docker demo, which needs no board. It shows the dashboard and the API on simulated data, so it says nothing about how well sensing works in your room.

For experts. The server is a Rust workspace under v2. Its UDP listener binds to 127.0.0.1 by default, so nodes on your network need --udp-bind 0.0.0.0 and either --udp-allow with their address or --udp-insecure-lan. The UDP data plane is not authenticated, and the guide says to keep it off untrusted networks.

The calibration guide takes a room through an empty-room baseline of at least 600 frames, eight guided anchors, a bank of trained specialists and a live watch. A partial anchor set trains a bank with some specialists missing, and room-status shows which ones trained.

wifi-densepose calibrate --port <PORT>
wifi-densepose enroll --room <NAME>
wifi-densepose train-room --room <NAME>
wifi-densepose room-watch --room <NAME>

The npm toolkit refuses to overstate accuracy in code. Its claim-check command lints a report for untagged accuracy claims. The train-gate command refuses a score with no mean-pose baseline or a leaky split, then returns the only wording a result may be published with.

Over MCP, grants split the authority. Hardware reads need device-access, flashing needs hardware-write with confirm, and calibration and training need workspace-write with confirm. Flashing and calibration are never honoured over the HTTP transport.

Good to know

Most of it runs on your own machine, and a few paths reach out.

• Status: the README marks the project beta, says APIs and firmware may change, and names the ESP32-C3 and the original ESP32 as unsupported
• Not a medical device: the README calls its applications research and prototypes, not medical devices, emergency systems or safety-certified controls. The firmware README calls its breathing and heart-rate output experimental, says to calibrate the breathing estimate against a reference before use, and says the heart-rate estimate is not a medical measurement
• People: it senses people without a camera. Mindket’s note, not the maker’s: tell the people in a room you sense. Privacy mode strips heart rate, breathing and pose from MQTT, Matter, REST, WebSocket and recordings, and the guide says it does not by itself make a deployment compliant with any regulation
• Network: the demo container refuses to start without an API token. Node data arrives over unauthenticated UDP, so use the source allowlist
• Your board: flashing writes to it. The npm toolkit plans first, checks each image against its checksums and writes only when you pass --confirm
• Calls out: the model weights come from Hugging Face, the image from Docker Hub, the packages from npm and PyPI, and an optional Cognitum Spaces sign-in reaches api.cognitum.one
• Cognitum: the README recommends Cognitum Seed hardware for the full setup and runs an affiliate program that pays creators on Cognitum sales. RuView itself is MIT licensed, and the ESP32 route works without them
• The Claude Code pane: like every mod, it runs with Claude Code’s access, so install it only from a source you trust
• License: MIT, with the copyright held by rUv