This is a submission for the GitHub Finish-Up-A-Thon Challenge
Around June 2025, I built a face recognition attendance system in my terminal. It worked with just python command to draw janky bounding boxes. It was laggy and unusable.
I knew no one would ever run a Python script in the real world. So I rewrote it. Then rewrote it again. Then spent 8 months telling myself "one more refactor" before showing it to anyone. I experimented with everything: Haar Cascade, YOLOv8n, then SCRFD. YuNet and EdgeFace replaced the old stack... A custom ONNX anti-spoofing model replaced MediaPipe. Electron + React replaced the terminal. AES-256-GCM replaced pickle files. The architecture grew from 200 lines to 50,000+ lines of code over the span of a year!
Me telling myself "it's just one tiny architectural change" for the 14th consecutive month.
I know what you're thinking: "Classic case of severe over-engineering." And you're 100% right. I got so caught up in making the local AI architecture "flawless" that I completely froze.
I never shipped. Perfectionism had me stuck at 80% for months.
The GitHub Finish-Up-A-Thon deadline finally broke the loop. Today I'm pushing Facenox Desktop v1.0.0-beta.1. My first ever beta release after a year of building in silence.
What I Built
Offline-first face recognition for real-time attendance tracking. No cloud biometric matching. No vendor hardware. No internet required. No raw photos stored. Only encrypted face codes that cannot be reversed.
Most traditional systems:
- โ Cloud-Dependent: Store your biometric data on someone else's servers.
- โ Proprietary: Require expensive, vendor-locked hardware or scanners.
- โ Fragile: Stop working entirely the moment the internet goes down.
Facenox flips the script. All AI inference and biometric matching stays 100% local. It's encrypted at rest with AES-256-GCM and runs flawlessly on any standard webcam (built-in, USB, or capture card).
Just Download. Install. Point a camera at people. That's it.
๐ข Note: Unlike typical consumer desktop utilities, Facenox is architected as a local-first B2B solution. Itโs designed to run on-premise for businesses, environments, or organizations that need enterprise-grade biometric tracking without leaking data to third-party cloud vendors.
Facenox Desktop is fully open-source under the AGPL-3.0 license. You can download the installer, grab the latest release, or build it directly from source.
- ๐ Website: facenox.com
- ๐ GitHub Repository:
Facenox is offline-first face recognition software for real-time attendance tracking.
Built for privacy: Biometric templates are end-to-end encrypted (E2EE)
Caution
This is the official open source repository for Facenox. Treat other repositories, installers, and downloads as unverified unless they come from official sources.
Note
Privacy First: Facenox processes face detection, tracking, and template matching locally. Encrypted face templates can optionally sync between your devices, with decryption keys stored exclusively on your paired hardware.
Why Facenox
Most face recognition systems rely on cloud-based biometrics. Facenox doesn't. Biometric matching stays local on the desktop.
Feature
Facenox
Cloud-Based Systems
Data Residency
Encrypted End-to-End with Optional Cross-Device Sync
Remote Cloud
Internet Dependency
Optional
Mandatory
Latency
Real-time
Network Dependent
Privacy Risk
Minimized
High
Features
- Local Biometrics: Face detection, ByteTrack subject tracking, and ONNX liveness verification.
- Cross-Platform: Native support for Windows, macOS, and Linux.
- Consent-Aware: Built-in support for biometric enrollment and deletion consent.
- Subject Management: Fullโฆ
Demo
๐ธ View Desktop App Screenshots & Features
Main panel
Live View (Demo)
Overview
Reports Management & Export
Adding Member & Enrollment
General Settings
Security & Encryption
Local Database
The Comeback Story
The original prototype was 200 lines of Python that technically worked but fell apart the moment you tried to use it in a real room โ bad lighting, side profiles, someone holding a photo of the person they're impersonating. It wasn't a product. It was a proof of concept I was too afraid to show to anyone.
| Feature | Prototype (2025) | Facenox Desktop v1.0.0-beta |
|---|---|---|
| Interface | CLI / Terminal (python main.py) |
Electron + React Desktop App |
| Face Detection | Haar Cascade / YOLOv8n | Yunet (Optimized for edge detection) |
| Recognition Model | DeepFace | EdgeFace (Optimized for local CPU/GPU) |
| Anti-Spoofing | MediaPipe (Lacked depth check) | Custom ONNX Model (Liveness detection) |
| Data Storage | Python .pickle files (Unsecure) |
AES-256-GCM Encrypted Local DB |
| Codebase Size | ~200 lines | 50,000+ lines (1,700+ commits) |
I spent months buried in rabbit holes. Optimizing my AI implementation architecture. Replacing DeepFace with EdgeFace for better accuracy. Building a custom ONNX anti-spoofing model face-antispoof-onnx because MediaPipe couldn't handle real-world spoofing, phones, printed photos, screen reflections. That liveness problem alone took weeks of pre-processing datas, ONNX export debugging, and temporal fusion tuning to get right.
I actually shared a raw demo of this custom liveness detection mechanism on LinkedIn, and the post completely blew up!!!
Seeing hundreds of developers validate the architecture and obsess over the local edge performance was the exact spark I needed. It made me realize that people actually wanted this technology.
Improving Face Anti-Spoofing with Miniface | John Raiven Olazo posted on the topic | LinkedIn
I thought fixing this would be a quick weekend task. ๐ ๐๐ฎ๐ ๐๐ฟ๐ผ๐ป๐ด. While building an AI-powered attendance system, I ran into a ๐บ๐ฎ๐๐๐ถ๐๐ฒ ๐๐ฒ๐ฐ๐๐ฟ๐ถ๐๐ ๐ต๐ผ๐น๐ฒ: it was way too easy to trick the camera just by holding up a photo or a phone screen. I quickly realized that generic models like MobileNetV4 aren't built for security, they're built for recognition. To solve this, I had to dive deep into face anti-spoofing and eventually ditched the "all-rounders" for ๐ ๐ถ๐ป๐ถ๐๐๐ฆ. This is a specialized architecture that actually understands the difference between a human face and a piece of paper. The breakdown: Tiny but accurate: The model is only ๐ฒ๐ฌ๐ฌ๐๐. Despite the size, it hits ~๐ต๐ด% ๐ฎ๐ฐ๐ฐ๐๐ฟ๐ฎ๐ฐ๐ on the CelebA benchmark (70k+ samples). Texture-based logic: Instead of just looking at facial features, it uses ๐๐ผ๐๐ฟ๐ถ๐ฒ๐ฟ ๐ง๐ฟ๐ฎ๐ป๐๐ณ๐ผ๐ฟ๐บ ๐น๐ผ๐๐ to detect the microscopic texture patterns of real skin versus printed paper or digital pixels. Runs on a "literal potato": I used INT8 quantization so it can run anywhere. No GPU or expensive cloud server is needed. and as a proof, I tested it on a 2011 laptop. Even on a ๐ญ๐ฐ-๐๐ฒ๐ฎ๐ฟ-๐ผ๐น๐ฑ ๐๐ฃ๐จ, it handles inference in ๐๐ป๐ฑ๐ฒ๐ฟ ๐ฎ๐ฌ๐บ๐ thanks to INT8 quantization. No expensive cloud server required. Iโve decoupled this from my main project, train it from scratch and ๐ผ๐ฝ๐ฒ๐ป-๐๐ผ๐๐ฟ๐ฐ๐ฒ๐ฑ it as a standalone security layer. If you're building an app that uses a camera and needs lightweight liveness detection, feel free to use it. ๐๐ผ๐ป๐๐ฟ๐ถ๐ฏ๐๐๐ถ๐ผ๐ป๐ ๐ฎ๐ฟ๐ฒ ๐๐ฒ๐น๐ฐ๐ผ๐บ๐ฒ! If youโre a CV researcher, or just someone who knows a better way to handle liveness detection, Iโd love to see your input. ๐ฟ๐ฒ๐ฝ๐ผ: https://lnkd.in/gPZSrMbT #MachineLearning #ComputerVision #OpenSource #Python #CyberSecurity #AI | 47 comments on LinkedIn
linkedin.com
But the hardest part wasn't the ML. It was realizing that no matter how accurate the model was, people weren't going to run python inference.py in a terminal anyway. So I scrapped everything and started over with Electron + React. Then scrapped that architecture and rewrote it again. And again.
1700+ commits. 50,000+ lines. One year of building in silence.
The Finish-Up-A-Thon didn't make me build Facenox. It made me stop hiding it.
My Experience with GitHub Copilot
Copilot handled the grunt work.
Whenever I needed to write schemas for the sync contract between the desktop app and dashboard, Copilot would infer the types from my existing interfaces and generate the validation layer in seconds. Same with Pydantic models. I just described what I wanted, and it wrote the boilerplate.
The Tailwind classes? I'd type the layout intent, Copilot would autocomplete the utility chain. Framer Motion animations? It remembered the exact spring configs I always forget. Writing test files for the FastAPI endpoints and the WebSocket pipeline went from tedious to fast! Copilot saw the pattern after two examples and filled in the rest. It caught inconsistencies I would have missed.
Copilot kept me in flow state by destroying the boilerplate, while I focused entirely on the high-level architecture. The pipeline orchestration, system integrations, encryption layer, and WebSocket frame protocolโthose required human architectural decisions. Copilot made sure I spent my engineering cycles there instead of reading Electron IPC docs or debugging Tailwind layouts for the 50th time.
Top comments (1)
Some comments may only be visible to logged-in visitors. Sign in to view all comments.