ESPectre is a production-grade Wi-Fi motion sensing system that runs on ESP32 microcontrollers. It captures Channel State Information (CSI) from Wi-Fi packets and runs on-device detection algorithms (Lightweight turbulence-based and High Accuracy neural network) to detect human motion without cameras or microphones. The system is designed for local-first operation with no cloud dependency, integrating with Home Assistant via ESPHome, MQTT, or Matter. The architecture is layered: a core sensing layer handles CSI capture, filtering, and feature extraction; a runtime layer manages lifecycle, configuration, and diagnostics; and multiple frontend adapters (native MQTT/HTTP, ESPHome, Matter, MicroPython) expose motion events to home automation systems. A Python CLI provides device discovery, flashing, monitoring, and dataset analysis tools. A web interface at espectre.dev offers browser-based device management. The repository also includes a significant data/research component: a published dataset of CSI recordings, ML training infrastructure, dataset quality validation pipelines, and performance benchmarking tools. These support the development and validation of the detection algorithms and ensure cross-language parity between C++ firmware and Python reference implementations. The codebase demonstrates strong engineering practices: interface-based design for testability, extensive unit and integration tests with coverage gates, cross-language parity enforcement, and a comprehensive CI/CD pipeline. Multiple frontends share a common core SDK, reducing duplication while allowing platform-specific optimizations.
This is a large polyglot monorepo for WiFi-based human sensing (WiFi-DensePose) that turns commodity WiFi routers into spatial intelligence systems. It captures Channel State Information (CSI) from ESP32 nodes to detect presence, estimate 17-keypoint body pose, measure breathing and heart rate, and track movement through walls without cameras or wearables. The system integrates deeply with Home Assistant via MQTT and Matter, provides a HomeKit bridge, and exposes multiple surfaces: a Rust backend workspace (v2/crates) with 50+ crates for signal processing, privacy shielding (VEIL/BFLD), pose physics, and home automation; Python bindings (PyO3) for ML training and inference; TypeScript CLI and MCP tools for AI agent integration; ESP32-C6/S3 firmware with adaptive sensing; React Native mobile app; Lit-based dashboard; and Tauri desktop app. The architecture is event-driven with a streaming engine, coherence-gated privacy layers, and deterministic verification via SHA-256 golden files. The codebase is heavily ADR-driven with extensive test coverage including cross-language parity gates. While primarily an application, it also contains substantial research code (benchmarks, physics simulations, SOTA surveys) and is best described as a research-informed production platform.
The pyespargos repository provides a Python library for interacting with ESPARGOS WiFi channel sounder hardware to capture, process, and deliver Channel State Information (CSI) data. The library handles low-level communication with single or multiple ESPARGOS boards, clusters CSI data from distributed antennas, applies calibration to compensate for hardware imperfections, and offers signal processing utilities for beamforming, polarization analysis, and direction-of-arrival estimation. The architecture is modular, with core components separated into board communication (board.py), multi-board pooling and clustering (pool.py), calibration management (calibration.py), and signal processing (util.py). A demo framework (demos/common/) provides reusable Qt/QML-based applications for various WiFi sensing tasks, including MUSIC spectrum analysis, polarization visualization, radar CSI processing, and camera-based beamforming overlays. The demos inherit from a base application class and combine mixins for backlog handling, combined array configuration, and CSI format selection. While the library is tightly coupled to the ESPARGOS hardware firmware (particularly the CSI packet formats and controller API), it encapsulates this complexity behind a clean interface. The signal processing utilities in util.py are hardware-agnostic and represent the most reusable component, offering implementations of advanced algorithms like MUSIC and MVDR beamforming. The clustering logic in cluster.py provides a general pattern for fusing sensor data from multiple distributed nodes. The repository shows active maintenance with recent commits and a linting CI workflow, though it carries some technical debt in the form of incomplete features and hardware-specific calibration complexity.
The openwifi repository provides a full-stack IEEE 802.11 (Wi-Fi) implementation for Software Defined Radio (SDR) hardware, specifically targeting Xilinx Zynq/ZynqMP SoCs with AD9361/AD9364 RF transceivers. It consists of a Linux kernel driver (split into multiple modules for OFDM, TX/RX interfaces, and side-channel processing) and user-space tools for hardware configuration, FPGA bitstream loading, and Wi-Fi interface management. The system supports standard Wi-Fi modes (AP, STA, ad-hoc, monitor) and experimental features like Channel State Information (CSI) extraction, packet injection/fuzzing, and radar sensing. The build system uses Buildroot to generate bootable SD card images, and the project includes extensive documentation for experimentation and hardware bring-up.
NETworkManager is a comprehensive Windows-based network administration and troubleshooting tool built with WPF and the MVVM pattern. It provides an integrated suite of network utilities including remote access (RDP, PowerShell, PuTTY, TigerVNC, WebConsole), network diagnostics (WiFi scanner, IP/port scanners, ping monitor, traceroute, DNS lookup), configuration tools (firewall, hosts file editor), and various network utilities (subnet calculator, bit calculator, OUI/port lookup, RDAP/Whois, IP geolocation). The application features a tabbed interface where each tool operates as a separate tab, profile-based configuration management for saving host/group settings, settings persistence with system-wide policy support, localization for 16+ languages, and data export capabilities (CSV, XML, JSON). The architecture follows clean separation of concerns with dedicated projects for Controls, Converters, Models, Profiles, Settings, Utilities, and ViewModels/View pairs.
ESP3D is a feature-rich embedded firmware for ESP8266/ESP32 microcontrollers, designed to serve as a Wi-Fi/Ethernet bridge and full-featured controller for 3D printers, CNCs, and similar equipment. The firmware provides a modular architecture with support for multiple network protocols (HTTP, WebDAV, FTP, Telnet, WebSocket, Bluetooth), a web-based user interface, file system management (SD card, flash filesystems like LittleFS/SPIFFS), sensor integration (DHT, BMP280), Lua scripting, and graphical displays via LVGL or TFT_eSPI. It includes a comprehensive command system (ESPxxx commands) for configuration and control, with authentication levels and persistent settings. The codebase demonstrates solid engineering for an embedded Arduino project, with clear separation of concerns between core services (serial, network, display, filesystem) and a message-passing inter-module communication pattern. It bundles many well-known third-party libraries (LVGL 8.2.0, TFT_eSPI 2.5.43, SdFat 2.2.3, EspLuaEngine, arduinoWebSockets) directly in the repository, ensuring reproducible builds but also creating a maintenance burden. The firmware is actively maintained with a responsive issue tracker and regular commits, though the reliance on pinned library versions and heavy conditional compilation introduces some technical drift.
FISSURE is a modular RF signal-intelligence and reverse-engineering framework. In production it provides a PyQt5 dashboard for spectrum survey, IQ capture/playback, burst conditioning, signal classification, protocol discovery, targeted transmission, and fuzzing across SDR hardware such as USRP, HackRF, LimeSDR, RTL-SDR, PlutoSDR, and bladeRF. It coordinates distributed sensor nodes through a HIPRFISR hub over ZMQ, integrates with TAK via Cursor-on-Target messaging, and supports plugin-based automation operations. The repository also contains a very large GNU Radio flow graph library (maintained for GR 3.8 and 3.10), custom OOT blocks for ADS-B, Bluetooth, ACARS, X10, Z-Wave, fuzzing, and wideband detection, plus packet-crafting and replay tooling for security research.
This repository provides a Dockerized implementation of RaspAP, a wireless router software for Debian-based devices. The container runs systemd to manage multiple services including hostapd (for Wi-Fi access point), dnsmasq (for DHCP/DNS), and the RaspAP web interface. It uses the host's network stack and requires privileged access to configure network interfaces and firewall rules. The setup process involves installing RaspAP via the official installer script, then applying environment-specific configurations through shell scripts that map environment variables to configuration files. The architecture is a single-container design that leverages systemd for process management inside the container. Key components include an environment setup script (env-setup.sh) that dynamically updates configuration files based on prefixed environment variables, a firewall script (firewall-rules.sh) that configures NAT and forwarding rules, and a simple PHP password generator (password-generator.php) for securely hashing web GUI credentials. The container exposes the RaspAP web interface on port 80 (mapped to 8081 on the host) and relies on the host's wireless and Ethernet interfaces for operation. Notable reusable components demonstrate solid engineering practices: the env-setup.sh script implements a clean pattern for mapping environment variables to configuration file key-value pairs using associative arrays and sed-based updates, which could be adapted to other applications with minimal changes. The password-generator.php correctly uses PHP's password_hash function with BCRYPT, showcasing secure password handling. While the Dockerfile follows common patterns for running systemd in containers and the firewall script contains interface-specific assumptions, the overall maintainability is strong with recent commits, active CI/CD workflows, and no reported dependency issues.