Camera frames go in, cheat-detection events come out. Five ONNX models run on their own worker threads at different rates: face detection (YuNet) and head pose at 15 Hz, gaze with eye-in-head subtraction at 15 Hz, prohibited-object detection (YOLOX-Nano) at 1 Hz, and ArcFace identity verification at 0.2 Hz. A temporal fusion layer turns those raw signals into debounced violations using hold timers, hysteresis bands, and decaying scores.

The gaze handling is the part I'd point at first. Subtracting head pose from raw gaze isolates where the eyes are actually pointed, so someone glancing down at a phone on the desk without moving their head still registers.

The other decision that paid off: fusion is a pure function of its inputs and a discrete timestamp. Recorded sessions replay to bit-identical events with no inference at all, which turned threshold tuning from a slow re-inference loop into an 87ms replay.

It replaced a MediaPipe-in-the-browser pipeline that managed 5 to 12 fps because ML inference and the React render loop were fighting over one thread. Current numbers: p50 27ms detection latency held at 15 Hz, around 190 MB RAM, a 70 MB installer, 119 tests passing. A custom trimmed ffmpeg build handles camera capture in about 3 MB instead of the 128 MB bundled dependency it replaced.

Stack  ·  Rust, ONNX Runtime, Tauri, PyO3, WebAssembly, crossbeam, ArcSwap

Repos  ·  Vigilo (desktop app)  ·  vigilo-core (engine)  ·  vigilo-stream (Python bindings)  ·  vigilo-wasm (in-browser)

One engine, four delivery targets: a Rust crate, Python bindings that hand NumPy a view into Rust-owned frame memory without copying, a WebAssembly build for in-browser proctoring, and the desktop app.

Upload one product photo, get back a full market strategy. Five specialized agents reason over the image concurrently through asyncio: a vision analyst pulls product attributes, a market researcher runs competitive comparison, a customer psychologist simulates buyer personas, a pricing strategist works out positioning, and an ad strategist writes multi-channel campaigns.

Vision runs on Llama 4 Scout 17B served on Groq's LPU, which is what makes five parallel agents feel responsive rather than sluggish. Product images are embedded with CLIP ViT-L/14 and indexed in Qdrant Cloud for similarity search.

Stack  ·  FastAPI, Groq (Llama 4 Scout), CLIP ViT-L/14, Qdrant, Next.js, Docker

Repos  ·  API  ·  Frontend  ·  Live demo

A practical look at how vision models, embeddings, and a vector database fit together into one service rather than three disconnected experiments.

A package's requires_python is often a lie of omission. mediapipe 0.10.9 declares >=3.8 but only ships wheels for cp39 through cp312, so on 3.13 pip goes hunting for a source distribution and dies with a metadata error that never once mentions Python versions.

PyPilot reads both signals. It takes requires_python as a starting range, then intersects it with the interpreter versions that actually have prebuilt wheels for your OS and CPU architecture, repeated across every dependency in the workspace. What survives is the set of interpreters that can run the whole project. When that set comes back empty, it names the two packages whose constraints collide, which is the thing pip never tells you and the reason dependency conflicts eat an afternoon.

It also catches the failures that happen after a successful install. mediapipe 0.10.35 installs fine and then crashes on module 'mediapipe' has no attribute 'solutions' because Google removed the legacy API, so PyPilot inspects the installed package on disk and flags mp.solutions in the editor while you're writing it. For GPU frameworks it reads nvidia-smi, maps the driver to its highest supported CUDA runtime, and pins torch to the matching index (cu124 instead of a default that doesn't fit the machine).

Everything resolves from PyPI metadata and bundled lookup tables. No AI, no API keys, no external services.

Stack  ·  Rust, LSP, WebAssembly (wasm32-wasip2), TypeScript, Bun, uv

Repos  ·  pypilot (Zed + engine)  ·  pypilot-vscode  ·  pypilot-pip (CLI)

One Rust binary, four ways to get it: pip install pypilot-cli, the VS Code Marketplace, Open VSX for VSCodium and Cursor, and the Zed extension registry. The editor extensions hold no business logic, so churn in an editor's extension API can't break environment resolution.

A document database written in C++20 with no third-party storage or networking libraries. Hardened BSON codec, append-only collection store, hand-written on-disk B+Tree, an index-aware query planner with explain plans, and a TCP daemon speaking a documented framed-BSON protocol with TLS and Argon2id authentication.

Prairie is the companion desktop client, a Compass-style GUI built with Tauri 2 and React. It browses documents, runs filters with explain plans, and manages indexes. It bundles the bisond engine as a sidecar, so it can open a local database directory with no daemon to start first.

Stack  ·  C++20, custom BSON, on-disk B+Tree, TCP, TLS 1.2, Argon2id, Tauri 2, React

Repos  ·  Bisondb  ·  Prairie  ·  Docs site

This is the project I point to when someone asks whether I understand what a database does under the hood. Every layer, from how a document hits the disk to how an index lookup resolves, is something I wrote and can explain.

A dark-themed music player that started on Android and got rebuilt for the desktop. My most-starred repo.

The Flutter app plays your local library through on_audio_query against the device MediaStore, with background playback wired through audio_service so the notification, lock screen, and headset buttons all work the way people expect. just_audio handles decoding and gapless transitions, and its AndroidEqualizer gave a native per-band equalizer without bolting on a separate audio-effects plugin. A Discover tab chains Last.fm search to a YouTube video match to an MP3 resolver, downloading into the local library.

The desktop version is a from-scratch Rust rebuild on GPUI Kit, not a stretched phone layout. Navigation rail, dockable queue, transport bar. Lofty scans multiple library folders recursively and reads embedded artwork, Rodio handles playback with ALAC and AIFF decoding, and there's a 5-band graphic equalizer from 60 Hz to 14 kHz.

Stack  ·  Flutter, Dart, audio_service, just_audio  /  Rust, GPUI Kit, Rodio, Lofty

Repos  ·  NoirPlayer (Android)  ·  noir-player-desktop-app

The desktop build ships per-platform installers rather than one generic bundle: WiX MSI and NSIS on Windows, a .dmg on macOS, and .deb, .rpm, and .pkg.tar.zst on Linux, each with a SHA-256 sidecar.

A multi-tenant SaaS platform built on Django and DRF, covering the parts a real product needs: JWT auth, role-based access, Stripe billing, async notifications through Celery, real-time task updates over Channels, and a Dockerized CI/CD pipeline with a test suite behind it.

It ships as four coordinated apps: a Next.js frontend with drag-and-drop Kanban and optimistic updates, the Django API, a Tauri desktop shell wrapping the same frontend, and a VitePress documentation site.

Stack  ·  Django, DRF, PostgreSQL, Redis, Celery, Channels, Next.js, Tauri

Repos  ·  Backend  ·  Frontend  ·  Desktop  ·  Docs

The architecture is the point here. Tenancy, billing, async jobs, and real-time messaging are what separate a demo from something you could actually deploy.

A live driver-monitoring system that fuses three signals: MediaPipe face mesh for eye and head state, YOLOv8 for phone detection, and a PyTorch LSTM reading the temporal pattern of those landmarks. A Streamlit UI runs it against a live webcam.

The temporal model is what makes it usable. A single-frame classifier can't tell a blink from a microsleep, so the LSTM reads the sequence instead of the snapshot.

Stack  ·  MediaPipe, YOLOv8, PyTorch LSTM, OpenCV, Streamlit

Repo  ·  Real-Time-Driver-Drowsiness---Distraction-Detection

Three models doing different jobs, joined into one real-time decision instead of a single classifier guessing at everything.