I Built a System That Detects Human Poses Through Walls Using WiFi
No cameras. No wearables. Just $5 ESP32 microcontrollers and a Rust engine running 810x faster than Python.
14 min read
Imagine an elderly person who lives alone and falls in the middle of the night. A camera in the bedroom is a privacy nightmare. A wearable only works if they remember to put it on. But WiFi signals pass through walls, reflect off human bodies, and carry information about movement and pose. Silently. Continuously. Without any privacy-invasive visual data.
That is what I built. A system that can track up to 3 people through solid walls using nothing but WiFi signals and $5 ESP32 microcontrollers. The Rust engine I wrote from scratch processes each frame in approximately 18 microseconds. That is 810x faster than the Python prototype.
The applications are real and urgent: fall detection for elderly care, search-and-rescue in collapsed buildings, hospital monitoring where cameras are inappropriate. This is what happens when signal processing, embedded systems, and Rust come together in the same project.
Why I Built This
The engineering challenge fascinated me. WiFi Channel State Information (CSI) is noisy, multipath-heavy, and incredibly sensitive to environmental changes. Extracting human pose from that signal requires a pipeline of sophisticated digital signal processing, all running fast enough for real-time tracking.
Python could not come close to the performance requirements. I chose Rust because I needed the speed of C with the safety guarantees of a modern language. The result is 10 modular crates covering everything from signal processing to neural networks to a Three.js real-time dashboard.
Core Concepts
Channel State Information (CSI)
Every WiFi packet carries hidden metadata that most people never think about. When a WiFi signal travels from your router to your laptop, it bounces off walls, furniture, and people. By the time it arrives, the signal has been modified by everything it interacted with.
CSI is a detailed measurement of exactly how the signal was modified across different frequency subcarriers. Think of it as a detailed fingerprint of the environment between the transmitter and receiver. When a person moves, walks, or falls, the CSI fingerprint changes. My system reads those changes and interprets them as human motion.
The Digital Signal Processing Pipeline
Raw CSI data is messy. Imagine trying to listen to a whispered conversation in a noisy stadium. You need serious filtering. My DSP pipeline is a sequence of cleaning and analysis steps:
Phase Sanitization removes hardware artifacts from raw phase measurements. Think of it like removing the wobble from a camera before you can read the scene. Hampel Filtering is outlier removal. It catches wildly wrong readings caused by interference or hardware glitches and replaces them with the local median. FFT (Fast Fourier Transform) converts time-domain signals to frequency-domain, which is where human activities have distinct signatures. Breathing is around 0.1 to 0.5 Hz. Walking is 1 to 2 Hz. Falling is a sudden broadband spike.
Fresnel Zone Tracking handles localization. A Fresnel zone is the cigar-shaped region between a WiFi transmitter and receiver where signal reflection is strongest. By modeling the Fresnel zones between multiple transmitter-receiver pairs, I can triangulate a person's position in 3D space. Think of it like crossing laser beams in a heist movie, except the beams are WiFi signals.
Rust's Ownership Model
I chose Rust for more than raw speed. Rust's ownership model guarantees memory safety at compile time. No null pointer dereferences. No data races. No use-after-free bugs. In a real-time signal processing system where data flows between threads at high speed, this is not a nice-to-have. It is essential.
Think of it like a traffic system where the compiler physically prevents car crashes rather than just posting speed limit signs and hoping for the best. Every one of the 10 crates in this project benefits from Rust's zero-cost abstractions: the safety of a high-level language with the performance of C.
ESP32 Microcontrollers
The ESP32 is a $5 microcontroller with built-in WiFi. I wrote C++ firmware that runs on these tiny chips, extracts CSI data from incoming WiFi packets, and streams it over UDP to the Rust engine. These are commodity hardware, not specialized laboratory equipment. I use multiple boards positioned around a space to create overlapping Fresnel zones, giving the system spatial resolution.
WebAssembly for Edge Deployment
One of the 10 crates compiles to WebAssembly, which means the signal processing can run inside a web browser. A nurse's station could run the pose detection locally in their browser without sending data to a server, preserving patient privacy. WASM runs at near-native speed, and Rust is one of the best languages for targeting it.
How It Works
ESP32 Boards (around the room)
Capture WiFi packets, extract CSI
|
UDP Streaming
|
v
+------ Rust Engine ------+
| |
| Phase Sanitization |
| | |
| Hampel Filtering |
| | |
| FFT (frequency domain) |
| | |
| Fresnel Zone Modeling |
| | |
| Neural Network (pose) |
+-------------------------+
| |
v v
PostgreSQL Three.js Dashboard
+ Redis (60fps 3D rendering)
(history)
|
v
Prometheus + Grafana
(system monitoring)
ESP32 microcontrollers are placed around a room. They passively capture WiFi packets and extract CSI data for each frequency subcarrier. UDP streaming sends raw data to the central Rust engine in real-time. The engine feeds it through the DSP pipeline: phase sanitization, Hampel filtering, FFT, and Fresnel zone modeling.
The neural network crate takes the processed signal features and estimates human pose: body position, limb orientation, activity type. PostgreSQL with Redis caching stores historical data. The API crate serves results over HTTP and WebSocket to the Three.js dashboard, which renders 3D pose estimates at 60fps. Prometheus and Grafana track system performance.
The 10 Crate Architecture
core: shared types and pipeline coordination. signal: all DSP operations. nn: neural network inference. db: PostgreSQL and Redis. hardware: ESP32 communication and UDP streams. config: configuration management. api: REST and WebSocket endpoints. mat: optimized matrix operations. cli: command-line control and diagnostics. wasm: WebAssembly compilation target.
What I Learned
- Systems thinking at scale. Coordinating 10 crates, hardware firmware, database layers, and real-time visualization taught me how to design systems where components are loosely coupled but tightly coordinated.
- Rust is worth the learning curve. The compiler fights you at first. But once you internalize ownership and borrowing, you write code that is both fast and provably safe. The 810x speedup is not a benchmark trick. It is the difference between "works in a lab" and "works in real-time."
- DSP is a superpower. Understanding FFT, filtering, and frequency-domain analysis opens doors far beyond WiFi sensing. The math is the same in audio processing, radar, communications, and medical imaging.
- Hardware integration is humbling. Working with ESP32 firmware, dealing with clock drift, packet loss, and hardware variability taught me respect for the physical layer that most software engineers never touch.
- Performance profiling is an art. Getting to 18 microseconds per frame required profiling every allocation, minimizing copies, and understanding CPU cache behavior. I learned more about computer architecture from this project than from any textbook.
- Privacy-preserving AI is a design choice. The system detects pose and movement, not identity. There is no visual data to leak. Ethics shaped the architecture from day one.
Why This Matters for Your Career
Systems engineering, embedded programming, and Rust are some of the hottest skills in the market. Here is how this project prepares you for tough interview questions:
Q1: Why Rust over C++ for real-time signal processing?
Rust gives C++-level performance with memory safety guaranteed at compile time. In a system processing live sensor data across multiple threads, data races and null pointer bugs are not just inconvenient. They can crash the system and miss a fall detection. Rust's ownership model eliminates these classes of bugs entirely.
Q2: Explain your DSP pipeline and why each step is necessary.
Phase sanitization corrects hardware artifacts. Hampel filtering removes outlier spikes. FFT converts to frequency domain where human activities have distinct signatures. Fresnel zone modeling provides spatial localization. Each step builds on the previous one. Skip any step and the downstream results degrade significantly.
Q3: How does WiFi-based pose detection work without cameras?
WiFi signals reflect off the human body. Different body positions create different reflection patterns in the Channel State Information. The neural network learns the mapping from CSI features to human pose through supervised training on labeled data.
Q4: How did you achieve 810x speedup over Python?
Three factors: Rust compiles to native machine code with no garbage collector overhead. I used zero-copy data structures and minimized heap allocations in the hot path. I leveraged Rust's fearless concurrency to parallelize independent pipeline stages across CPU cores.
Q5: What are the ethical considerations of through-wall tracking?
The system detects pose and movement, not identity. There is no visual data. For production deployment, I would add encryption to the data stream, strict access controls, and consent frameworks. The technology is designed around privacy-preserving applications where cameras are inappropriate.
Try It Yourself
The complete system is open source. Build the Rust engine, flash the ESP32 firmware, and start experimenting:
git clone https://github.com/tolani007/Steeview-wifi-densepose-rs.git
cd Steeview-wifi-densepose-rs
# Build the Rust engine (requires Rust 1.70+)
cargo build --release
# Run tests across all 10 crates
cargo test
# Start the system
cargo run --release -- --config config/default.toml
# For the Three.js dashboard
cd dashboard && npm install && npm startRequirements: Rust 1.70+, Docker (for PostgreSQL, Redis, Prometheus, Grafana), Node.js (for dashboard), PlatformIO (for ESP32 firmware).
Find the full repository here: github.com/tolani007/Steeview-wifi-densepose-rs
About the Author
I am Tolani Akinola, also known as Eigentiki. I build at the intersection of machine learning, data engineering, systems programming, and creative tech. I believe the best way to learn anything is to build it, break it, and then explain it to someone else as simply as possible.
Find this project and all my work on GitHub. Let us connect:
