Projects
Focused on network engineering, autonomous systems, and signal processing.
Recent Activity
- 2026-03-11: Network Analysis Engine — plans, 4 files)
- 2026-03-11: Overtone — Completed (Module-Level Rustdocs).
- 2026-03-10: Spectrum Analysis — Completed (3D Propagation Bounce Visualization).
- 2026-03-09: matrix-profile-rs — Completed 15-01-PLAN.md: MultiStreamingState core + Join distance kernels + Batch Join STOMP
- 2026-03-09: Signal Reflection - KrakenSDR Multi-Beam System — Completed 40-04-PLAN.md
Network Engineering
Brownfield Ingestion
Vendor translation layer that decouples network configuration from vendor-specific syntax. Uses LLM-powered RAG to extract network-level intent and topology relationships from vendor documentation and CLI configurations, normalizing them into a vendor-neutral topology graph model. The intermediate representation is topology-centric (protocol adjacencies, link roles, VLAN membership) rather than device-centric like YANG, enabling genuine vendor abstraction.
CLI Parser
Parsing engine for network device CLI output. Transforms semi-structured text (show commands, routing tables, BGP summaries) into structured data (JSON/YAML) using an optimized Rust state machine. Provides full compatibility with the industry-standard ntc-templates library while offering 10–50x faster execution than Python-based alternatives like TextFSM.
Configuration Generation (AutoNetkit)
A compiler-based framework for automated network provisioning. AutoNetkit transforms high-level network designs into validated device configurations across heterogeneous hardware and protocol environments. Traditional network configuration is manual and vendor-specific.
Device Interaction Framework
A Rust library and CLI for network device interaction and automated testing. Provides the essential PyATS capabilities — testbed management, CLI output parsing, and state verification — without the complexity. Connects to devices (real, simulated, or mocked), executes commands, parses structured output, and verifies correctness with the type safety of compiled Rust.
Network Analysis Engine
Graph Neural Network (GNN) based network analytics module that extends topology analysis with real-time learning and prediction. Subscribes to the Network Topology Engine's WebSocket stream for live topology updates, runs GNN models on graph data, and exposes analytics through multiple interfaces (WebSocket streaming, REST API, Rust library, event queue). Built on an existing Rust+Python analysis toolkit that includes formal verification (Z3 SMT solver), graph algorithms (centrality, community detection, cascade modeling), and Python bindings via PyO3.
Network Automation Ecosystem - Overall Architecture Definition
This project defines the architecture of the Network Automation Ecosystem: how its tools connect, what data flows between them, and where the system is headed. The ecosystem comprises nine repositories that form a composable toolchain. Each tool handles one concern -- topology generation, simulation, configuration parsing, visualization, analysis -- and communicates through pinned contract schemas (RFC-01, RFC-02).
Network Automation Workbench
Orchestration platform that integrates the ANK ecosystem tools — [Topology Generator](/projects/topogen), [Network Modeling & Configuration Library](/projects/ank-pydantic), [Network Simulator](/projects/netsim), [Network Visualization Engine](/projects/netvis) — into a single web interface. Engineers define topologies, generate configurations, run simulations, and inspect results without switching between CLI tools. ``` ┌──────────────────────────────────────────────────────────────────┐ │ Network Automation Workbench │ │ (Orchestration · Web UI · Workflow Management) │ │ ┌──────────────┬──────────────┬──────────────┬──────────────┐ │ │ │ TopoGen │ [ank-pydantic](../ank-pydantic)│ Simulator │ NetVis │ │ │ └──────────────┴──────────────┴──────────────┴──────────────┘ │ └──────────────────────────────────────────────────────────────────┘ ``` The workflow follows a linear pipeline: generate or model a topology, run a simulation against it, visualize the results, and export device configurations.
Network Configuration Framework
Network Configuration Framework is a Rust CLI that compiles declarative YAML blueprints into vendor-neutral configuration artifacts. A single binary orchestrates the full pipeline: blueprint parsing, topology transformation, DeviceIR generation, template rendering, and traceable config file emission. The core problem is determinism.
Network Modeling & Configuration Library
The Network Modeling & Configuration Library represents network topologies as typed Python objects backed by a Rust graph engine. You define nodes, edges, and layers using Pydantic models. The library stores them in the [Network Topology Engine](/projects/ank-nte) and exposes a composable query API that builds lazy evaluation plans in Python and executes them in Rust.
Network Simulator
Deterministic tick-based network protocol simulator validating configurations before production deployment. It provides protocol-level fidelity with same-topology-same-results guarantees, allowing engineers to verify control-plane behavior without the overhead of full VM emulation. Unlike packet-level simulators that focus on bit-level accuracy, this engine focuses on **protocol convergence and state validation**.
Network Topology Engine
Rust-based graph topology engine with Python bindings via PyO3. Takes network topologies — nodes, edges, layers, metadata — and stores them in a dual-write architecture: structural graph (petgraph StableDiGraph) plus columnar attribute store (Polars DataFrames). Mutations update both atomically; if either write fails, the transaction rolls back.
Network Visualization Engine
Rust-based network topology layout and visualization engine. Takes multi-layer network topologies (via petgraph) and renders them using layout algorithms that minimize edge crossings, bundle related connections, and respect hierarchical or geographic structure. Outputs SVG, PDF, and PNG with interactive browser embedding via WASM.
Orchestrator (Device Interaction Runner)
Orchestration engine for coordinating device interactions across real and testbed networks. Executes runs with retries, timeouts, bounded concurrency, and durable artifacts (logs, results, snapshots). Uses [Device Interaction Framework](../deviceinteraction) as a library for transports, parsing, and test primitives — the orchestrator owns run coordination, persistence, and event streaming.
Performance Simulator
Network Flow Simulator uses analytic queuing models and Monte Carlo simulation to evaluate network performance without packet-level discrete event simulation. Given a topology and traffic demands, it pushes billions of flow iterations through queuing models in seconds, identifying congestion bottlenecks probabilistically and projecting capacity headroom across carrier-scale networks (100k+ nodes). The core tradeoff: sacrifice per-packet fidelity for orders-of-magnitude speed improvement.
Topology Generator
Rust-based network topology generator with Python bindings. Takes a declarative YAML config describing the desired topology type, scale, and parameters, and produces a validated network graph with realistic structure — proper tier hierarchies, vendor-specific interface naming, geographic placement, and bandwidth profiles. Consolidates topology generation logic that was previously scattered across AutoNetKit, the [Network Simulator](/projects/netsim), and the [Network Visualization Engine](/projects/netvis) into a single library.
Radio Systems
Radio Streaming Server
Cross-platform server (targeting Raspberry Pi) that manages multiple SDR devices (RTL-SDR, AirSpy HF+) and streams raw IQ samples over the network using the `rtl_tcp` protocol. A single binary replaces multiple C-based streaming tools, adding a TUI for live device management, TOML configuration, and safe concurrency across all connected radios. Existing C implementations (`rtl_tcp`, `hfp_tcp`) are single-threaded and require separate processes per device.
Signal Reflection - KrakenSDR Multi-Beam System
Distributed multi-beam signal reflection analysis system built on KrakenSDR hardware. A Raspberry Pi handles data acquisition and streams IQ data over UDP; a Mac or Linux workstation runs compute-intensive DSP. All four surveillance channels process in parallel with independent Range-Doppler visualization, per-beam configuration, and real-time performance monitoring.
Sound Array
Audio processing system using Raspberry Pi and microphone arrays for spatial sound analysis. Captures multi-channel audio from USB/HAT arrays (ReSpeaker, Matrix), computes Time of Arrival (ToA) for sound localization, and applies beamforming for directional isolation. Classifies sources — vehicles (engine sounds), aircraft, wildlife (birds) — and streams processed audio or metadata to a remote desktop for analysis.
Spectrum Analysis
Automated signal census system that transforms raw radio spectrum data into classified, searchable signal inventories. Combines SDR acquisition, ML classification, and vector search to detect, identify, and catalog signals across monitored bands.
Wi-Fi Signal Reflection (KrakenSDR)
Through-wall human detection and localization using existing Wi-Fi [signals](../signals) as illumination sources. Built on the KrakenSDR five-channel coherent receiver, processing Heimdall DAQ IQ streams to detect movement through obstacles in indoor environments. Bridges theoretical signal reflection research with a portable, real-time hardware implementation.
Health & Biometrics
HealthyPi Ecosystem
Modular health monitoring ecosystem that translates raw biometric data from HealthyPi hardware (Pi HAT and wearable) into structured metrics for agent-driven analysis. Swift collectors on Apple devices capture HealthKit data, publish to a NATS broker, and Python agents in containers run analysis pipelines — all coordinated by the [multi-agent](../multi-agent) orchestrator.
Astrophotography
Aurora Advisor
Decision tool for Australian aurora observers that answers "should I drive 60 minutes to a dark site tonight?" Combines real-time solar wind data (NOAA SWPC), substorm trigger detection (Bz drops + hemispheric power jumps), and local weather forecasts (ACCESS-G model via Open-Meteo) into a single Go/No-Go score that accounts for both space weather potential and terrestrial conditions (cloud cover, moon phase, travel time).
AuroraPhoto
Automated astrophotography system for capturing aurora and night sky imagery. Raspberry Pi nodes connect via USB to Sony a7R V / a7 IV cameras, controlled by an iPhone companion app over Wi-Fi. The system provides automated focus using Half-Flux Radius (HFR) star sharpness monitoring, exposure sequencing optimized for aurora bursts, and multi-node coordination from a single mobile interface.
EclipsePhoto
Autonomous solar eclipse photography controller for Raspberry Pi. Coordinates a camera (via gphoto2) and equatorial mount (ZWO AM5 / Benro Polaris via INDI) to capture a complete eclipse sequence from first contact (C1) to fourth contact (C4) without manual intervention. The system handles solar guiding, exposure ramping, and error recovery so the photographer can watch the eclipse while the hardware secures the data.
EclipseStack
Alignment tool for solar eclipse HDR composites. Takes hundreds of RAW frames captured during totality and produces sub-pixel-aligned output ready for HDR stacking in PixInsight. Addresses tracker drift by combining solar disk detection (computer vision) with temporal drift modeling from EXIF timestamps — the constant drift rate fills alignment gaps between confident frames.
OpenAstro Core
Rust library providing shared astronomical logic, hardware drivers, and protocol implementations for the OpenAstro ecosystem. Keeps coordinate math, imaging intelligence, and device behavior consistent across downstream applications (OpenAstro Node, Photo Tour). Pure Rust stack — no C toolchain required, testable without hardware.
<div class=”project-card” data-search=”openastro node headless, autonomous astrophotography controller for low-power linux devices (raspberry pi, jetson). manages camera and mount hardware, executes imaging sequences, and ensures rig safety through a “goodnight” protocol for unattended overnight sessions. uses openastro core for coordinate math, imaging intelligence, and device drivers. rust typescript open-astro-node”>
OpenAstro Node
Headless, autonomous astrophotography controller for low-power Linux devices (Raspberry Pi, Jetson). Manages camera and mount hardware, executes imaging sequences, and ensures rig safety through a "Goodnight" protocol for unattended overnight sessions. Uses OpenAstro Core for coordinate math, imaging intelligence, and device drivers.
</div>
Satellites
Terminal-based satellite tracker that displays real-time positions on a world map, predicts passes over the user's location, and shows transmission frequencies. Built with Rust and ratatui, using the SGP4 orbital propagation algorithm to compute positions from Two-Line Element (TLE) data. A single binary with no GUI dependencies — aimed at amateur radio operators and space enthusiasts.
</div>
Photography
ASIAIR Import Tool
Python script that automates post-imaging file organization for astrophotography. Scans ASIAIR backup locations (Udisk/EMMC across Autorun, Preview, Plan, and Live folders), reads FITS headers to extract metadata, and organizes hundreds of frames by target and observation night into a directory structure ready for PixInsight's Weighted Batch Preprocessing (WBPP) workflow.
Photo Tour
Interactive photography assistant for field use on iOS and iPadOS. Provides live camera preview, manual motor control for landscape rigs, and a plugin architecture for composition overlays, exposure ramping, and intelligent triggering. Built with SwiftUI and designed around a real-time control loop — see what the camera sees and act on it fast enough to improve the shot.
Autonomous Systems
Cycle Agent
Native SwiftUI training application for iPad and Apple TV that bridges a Wahoo KICKR Core smart trainer with AI-driven workout logic. The app communicates with the trainer over Bluetooth (FTMS protocol) for real-time resistance control and telemetry, while a NATS message bridge connects to an external agent for dynamic workout decisions. A SceneKit-rendered infinite terrain visualization runs at 60fps on Apple TV, with heart rate relay from Apple Watch completing the sensor loop.
Secure Multi-Agent Personal Assistant
A security-first multi-agent system that coordinates specialized containerized agents through a NATS message broker. Each agent runs in isolation with minimal privileges — separate containers, scoped credentials, no direct agent-to-agent communication. The orchestrator uses cloud LLM reasoning (GPT-4/Claude) while agents remain lightweight and deterministic.
Data & Utilities
NAS Cleanup & Intelligence
Rust CLI for managing large-scale Synology NAS file systems. Performs duplicate detection (bit-for-bit and fuzzy), astrophotography file optimization (ASIair workflow cleanup), conventional RAW/sidecar management, and intelligent organization. Designed for Docker or native execution on DSM to minimize network latency during scanning.
OmniFocus DB CLI (omnifocus-db)
Python CLI that reads directly from the OmniFocus 4 SQLite database on macOS, bypassing AppleScript and Omni Automation layers. Provides near-instant retrieval of projects, inbox items, and tasks in structured, token-efficient formats (JSON/text) for agent consumption. Read-only access by default to prevent database corruption while OmniFocus is active.
Tileserver Polars (Rust Optimized)
Dynamic vector tile server for massive geospatial datasets. Serves Mapbox Vector Tiles (MVT) from millions of points with sub-second latency, enabling interactive visualization in Kepler.gl without pre-rendering static tilesets. Python (FastAPI) handles the API layer; Rust (via PyO3) handles coordinate transformation and MVT encoding; Polars provides in-memory filtering and aggregation.
Weather (BOM ACCESS Pipeline)
Data engineering pipeline that fetches, processes, and serves weather model data from the Australian Bureau of Meteorology. Targets ACCESS (Australian Community Climate and Earth-System Simulator) model outputs, bypassing BOM's FTP delivery and binary formats (GRIB2/NetCDF) to provide a queryable interface for localized weather forecasts. Initial geographic focus on South Australia.
matrix-profile-rs
Matrix Profile algorithms (STOMP, SCRIMP++, SCAMP) in native Rust for motif discovery and anomaly detection in time series data. Achieves 2.5x speedup via SIMD (AVX2/NEON), handles datasets exceeding RAM through memory-budgeted tiling, and integrates with Polars as a native DataFrame operation. 8,700 lines of Rust.
Wellness & Sound
Overtone
Generative psytrance synthesis engine with real-time TUI controls. Creates complete tracks driven by a multi-level energy model (macro, meso, micro), with live playback, step editing, and WAV export. Procedural synthesis generates kick, bass, hihat, and clap patterns; an effects chain (sidechain compression, delay, reverb, HPF, limiter) and humanization (velocity jitter, micro-timing) produce output that sounds like a produced track rather than a sequencer demo.
Wave (StillState & FlowState)
Ambient audio ecosystem spanning Apple Watch and Mac, designed for sleep and deep work. **StillState** (watchOS) is an adaptive sleep sounds app that generates procedural noise (white, brown, blended) with binaural beats, personalized frequency calibration, and heartbeat synchronization. Microphone monitoring detects environmental noise for adaptive masking.
Experimental
Rust TUI GTD Todo (OmniFocus-inspired)
Keyboard-driven Rust TUI task manager built around a GTD workflow. Stores tasks in a local SQLite database with support for projects, hierarchical tags, and availability-based next-action computation. Optimized for rapid inbox processing — single-key field mode for triage, project/tag assignment, and batch operations with sub-second interactions at 10,000+ actions.