RuView GitHub: A Complete Guide to the Repo

RuView is not just a software application; it is an open-source ecosystem built by a global community of developers, signal processing engineers, and hardware enthusiasts. By hosting the project on GitHub, we aim to build an open, transparent, and collaborative environment where anyone can contribute to the future of privacy-friendly WiFi sensing.

Whether you are a web developer looking to improve the dashboard, a Rust systems programmer interested in optimizing the processing pipeline, or a hardware engineer writing ESP32 firmware, there is a place for you in the RuView codebase.

In this guide, we will walk you through the structural layout of the RuView GitHub repository, explain how to compile the modules from source, and outline our contribution workflows.

The RuView repository is organized as a monorepo containing multiple independent modules. Understanding this structure will make it much easier to find the files you want to modify.

Here is the directory structure:

• **`/firmware`**: Written in C using Espressif's ESP-IDF. This directory contains the code that runs on the ESP32 sensor nodes, handling Wi-Fi packet sniffing, CSI extraction, and UDP streaming.
• **`/engine`**: Written in Rust. This is the core of the RuView system. It receives raw UDP packets from the sensor nodes, performs denoising, executes PCA, and runs AI inference using ONNX Runtime.
• **`/dashboard`**: A web application (typically React/TypeScript) that connects to the Rust engine over WebSockets, displaying real-time signal heatmaps, Doppler spectrograms, and event logs.
• **`/models`**: Contains pre-trained ONNX neural network models for activity classification, static presence detection, and respiration tracking.

To learn how to choose and set up the hardware for this repository, see the Best ESP32 Boards guide or view our Hardware Section.

The `/engine` directory is the most active part of the codebase. It is designed for maximum throughput and low latency, taking advantage of Rust's concurrency model.

Key source files include:

• `src/main.rs`: The main entry point that loads configurations, binds to the UDP port, and initializes the WebSocket server.
• `src/dsp.rs`: Digital Signal Processing module containing implementation of Butterworth filters, PCA, and phase calibration algorithms.
• `src/inference.rs`: Handles the loading and execution of ONNX models.

To compile the engine, navigate to `/engine` and use Cargo:

For a step-by-step tutorial on flashing and running this engine, read our ESP32 WiFi Radar Guide.

We welcome contributions of all sizes, from fixing typos in the documentation to adding support for new hardware boards.

To contribute to RuView, follow this workflow:

1. **Find an Issue**: Browse the open issues on our GitHub page. Issues labeled "good first issue" are excellent starting points for new contributors.
2. **Fork and Clone**: Fork the repository to your own GitHub account and clone it locally.
3. **Create a Branch**: Create a descriptive feature branch: `git checkout -b feature/your-feature-name`.
4. **Write Tests**: If you are modifying the DSP algorithms or Rust engine, write unit tests in the appropriate module to prevent regressions.
5. **Submit a PR**: Push your changes to your fork and open a Pull Request (PR) against our main branch.

All code modifications are automatically built and tested using GitHub Actions, ensuring high code quality. To see what AI features you can help build, explore our Features Page.

To maintain a healthy and welcoming community, all contributors are expected to adhere to our Code of Conduct. We value constructive feedback, collaboration, and mutual respect.

If you need help setting up the system or have questions about the codebase, you can join our developer Discord server or ask in the GitHub Discussions tab.

Thank you for helping us build a more private, open-source future! If you run into troubleshooting issues, consult the FAQ Page or get in Contact.