DEV Community: James D. Bartlett III

I gave my messy photo archive a spirit guide — an offline, open-weight AI that learns your family, names your places, and finds any memory

James D. Bartlett III — Sat, 31 Oct 2026 17:13:01 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

Alebrije (github.com/JamesDBartlett3/Alebrije) is a local-first archive spirit-guide for your photos, videos, and audio clips. Alebrijes are the brightly colored creatures of Mexican folk art that guide souls where they need to go — this one guides you through thousands of memories that would otherwise sit in folders with names like DCIM_0947.

You point it at a messy directory. It then:

Meets your people. You introduce a friend or family member from a sample photo (alebrije person add Abuela --photo abuela.jpg), and Alebrije builds a private people book: the face is embedded locally by open face models (SCRFD detection + AdaFace recognition via onnxruntime) and described in words by the vision model — no cloud, no face database handed to a third party.
Recognizes them everywhere, and names every place. Every photo is scanned for faces; each becomes a 512-d vector stored locally. Faces close to someone in your people book are matched automatically, borderline ones are double-checked by Gemma, and recurring strangers cluster into "Unnamed" people you name with one rename. It also tags every photo and video with objects, clothing, animals, food, and the mood of the moment. If a photo carries GPS coordinates, it finds the closest point of interest (a park, museum, landmark — nearest by real haversine distance, via the OpenStreetMap Overpass API) and always appends the municipality chain: Civic Center Park — Denver, Colorado, USA, or with no landmark in range simply City of Golden, Jefferson County, Colorado, USA.
Remembers by feeling, not filename. Everything is embedded with an open model into a local SQLite index, so you can search in plain language — "dog on the beach at sunset" — sorted by relevance, newest, media type, or name.

Everything runs on your machine: an open-weight multimodal model (Gemma 3 4B via llama.cpp) looks at your media, open face models (SCRFD + AdaFace via onnxruntime) recognize your people, an open embedding model (nomic-embed-text) indexes it, and a Día de los Muertos–themed local web app — papel picado banner, marigold glow — serves the whole collection to any phone or laptop on your network. Nothing about your family ever leaves your hardware (the only outbound calls, and only for GPS-tagged files, are the two open-data OpenStreetMap geocoders, which receive coordinates, never images).

I built this for the #GhostInTheMachine theme the way Día de los Muertos itself treats it: the dead stay alive as long as their stories are told. A hard drive full of untagged photos is a room full of ancestors waiting to be introduced. Alebrije is the marigold path through it.

Demo

Everything below is from a live run on an ordinary 4-core desktop, CPU only:

Six files went in named IMG_4031.png … IMG_4043.jpg. Alebrije tagged all six (captions, objects, clothing, mood), recognized and named a person across four of them from a single sample photo, and reverse-geocoded the two that carried GPS. Then, in plain language:

"dog on the beach at sunset" puts the three beach-dog photos on top — including one taken before the archive's newest party photos — because ranking is by meaning, not date.

The CLI speaks the same language:

And it's the same app on a phone, served from your own desk over the LAN:

Code

https://github.com/JamesDBartlett3/Alebrije

Install and run (Python 3.10+ and pipx are the only prerequisites — Alebrije installs everything else):

pipx install git+https://github.com/JamesDBartlett3/Alebrije.git@v0.2.0
alebrije setup        # downloads llama.cpp + the open-weight models, auto-detects your GPU
alebrije init ~/Pictures/family
alebrije up           # starts the two local model servers
alebrije scan         # index files, read EXIF dates + GPS
alebrije tag          # vision-tag everything (CPU: ~1 min/photo, GPU: seconds)
alebrije serve        # http://localhost:8799 — also on your LAN
alebrije update       # later: checks GitHub releases, upgrades in place

No pipx? git clone + python alebrije.py <command> works straight from the repo — friendliest option on Windows.

How I Built It

Vision + language: Gemma 3 4B IT (open weights, Gemma license) served by llama.cpp's llama-server with its multimodal projector. Every caption, object list, clothing item, animal, mood, person description, and gray-band identity double-check comes from this one local model.
Embeddings & search: nomic-embed-text v1.5 (Apache-2.0), via llama.cpp's OpenAI-compatible embeddings endpoint. Vectors live as float32 blobs in SQLite; cosine ranking is a few lines of Python.
Faces, without the cloud: v0.1 matched people by Gemma descriptions alone — we shipped it, watched it conflate lookalike relatives and miss people across decades, measured the failure, and rebuilt identity on real face embeddings. SCRFD-10GF detects every face (five landmarks each) and AdaFace ir101 — trained specifically to handle low-quality faces, i.e. old family photos — turns each aligned crop into a 512-d identity vector, both on onnxruntime (MIT) on CPU. Detection runs a letterboxed whole-image pass plus overlapping native-resolution tiles on large photos, so faces never get lost to downsampling; alignment crops are always warped from the full-resolution original. Matching uses measured thresholds (same person ≈ 0.56–0.95, different people ≈ 0.0), with Gemma confirming borderline cases and strangers auto-clustering into nameable "Unnamed" people.
The app itself is nearly all Python standard library — a scanner (with a hand-rolled EXIF parser that pulls capture dates and GPS coordinates out of JPEG APP1 segments), a tagging pipeline, a people book, a vector index, a CLI, and a threaded web server with an embedded single-page UI. The only pip dependencies are onnxruntime and Pillow. No framework, no account.
Fully self-installing, fully cross-platform. alebrije setup works on Linux, macOS, and Windows: it queries the llama.cpp GitHub releases API and downloads the prebuilt build matching your OS, CPU architecture, and accelerator — NVIDIA (nvidia-smi), AMD ROCm (rocm-smi), Vulkan (vulkaninfo), Apple Metal on any Mac, or plain CPU — then fetches the five open models (three GGUFs from Hugging Face, two face ONNXs from GitHub releases) with resume support. When a GPU is present, alebrije up launches the models with full layer offload (-ngl 999).
Tests: 182 offline tests (alebrije selftest) cover the scanner (including a synthetic JPEG with hand-built EXIF + GPS binary), the face pipeline (letterbox/tiling math, SCRFD decoding, similarity alignment, threshold bands, clustering, v0.1-database migration), tag coercion, people matching, vector math, search sorting, the bootstrap asset picker for every OS/GPU combo, server lifecycle, the web API (real HTTP on an ephemeral port), and the CLI — all against fake model servers, no network or GPU required.

Why Does Open Innovation Matter?

Your family photos are the last data you'd ever hand to a stranger, and the first data that gets uploaded without thinking the moment you use a cloud "AI photo assistant." Open weights flip that: the same Gemma model a giant cloud product would run is running on your desk, inspectable, with your files never leaving the room.

Openness also made this project possible at all. llama.cpp's OpenAI-compatible server meant the whole app is one urllib call away from vision and embeddings; the GGUF ecosystem meant a 4B model runs on an ordinary 4-core CPU; permissive licenses meant everything here ships without negotiation; and OpenStreetMap's open geodata meant place names without a paid maps API. If the models were closed, an offline family-archive assistant simply couldn't exist — and if they were free-but-closed, it couldn't be audited, fine-tuned, or trusted with something as personal as a memorial archive.

The Spirit of It

The moment it landed: I fed it six files named IMG_40xx and asked, out loud, "dog on the beach at sunset" — and the first three results were exactly the three photos I'd have picked, one of them taken years before the others. A folder became a memory. That's the whole ofrenda: the tech is just the marigold petals; what they guide home is your own past.

Prize Categories

Gemma (Featured) — Alebrije is built around Gemma 3 4B: every caption, tag, person description, and borderline identity double-check comes from the open-weight Gemma model running locally through llama.cpp.

I rode out two hurricanes with a Discord bot. Here's the open-source, offline-first version anyone can run.

James D. Bartlett III — Mon, 26 Oct 2026 05:43:08 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Earlier this month I closed on a house in coastal Mexico, got hit by Hurricane Simon before I'd even unpacked, and rode out Hurricane Trudy the following weekend. Between board-up runs I ran a little Discord bot that watched the National Hurricane Center for me every two hours, logged every advisory, and screamed only when something actually mattered. It worked. The house is fine, and I never opened a cone map once.

Batten (verb: to batten down the hatches) is that bot rebuilt for everyone else — generalized, hardened, and with an open-weight model at its core:

Watches NOAA for you. NHC storm trackers for your part of the world, NWS alerts for your exact coordinates (US), configurable alert feeds for anywhere else. It fires on the things that matter — new storms, category changes, rapid intensification, landfall statements, proximity crossings at 300/150 nm — and stays quiet otherwise. Routine updates respect quiet hours; real triggers break through.
Keeps working when the internet dies. This is the whole point. The first failed check tells you what broke ("DNS failing — internet down or captive portal" vs "connections timing out — weak signal"). It keeps retrying in the background, and if NOAA stays unreachable for 6 hours it builds a worst-case 48-hour outlook from the last good advisory — persistence track extrapolation, one category of assumed intensification, wind-field arrival times, rainfall bands — every line labeled ESTIMATE, timestamped to the last good data.
Talks to you through a local model. Chat, briefings, and the worst-case action plan run on an open-weight model via Ollama on your own machine. When a storm takes your internet down — the exact moment you want a weather assistant — the AI is the part that still works.
Three ways to see it: a plain CLI, a cross-platform TUI (PC/Mac/Linux), and a local web dashboard served on your LAN — open it on your phone while you're boarding up the windows, no cloud involved.
Tracks your supplies against a ready.gov-derived checklist that scales to your household, so "are we ready?" is one command, not a 2 a.m. inventory.
Speaks metric and imperial, takes your location as GPS coordinates or ZIP code, and frames everything relative to your position: how far, which direction, and whether the storm is headed toward you or moving away.

Who gets to be lazier: anyone in a storm's path who currently has twelve browser tabs of cone maps open and a not-app storm checklist in their head. You set Batten up once; it does the watching, the remembering, and the "what does this advisory actually mean for my address" translation.

Demo

Batten is deliberately local (that's the thesis — it has to work when the internet doesn't), so instead of a hosted demo the repo ships a fully offline storm replay:

git clone https://github.com/JamesDBartlett3/Batten && cd Batten
python3 -m batten demo

This replays a real hurricane's full lifecycle — advisories transcribed from an actual storm watcher's log — including a simulated internet outage. You'll watch it detect the storm, fire category-change and rapid-intensification triggers, warn "cannot reach NOAA" when the outage hits, and at the six-hour mark produce the worst-case 48-hour outlook from stale data. No network needed, runs in about fifteen seconds.

Screenshots (from the repo's screenshots/ folder):

Code

Repo: https://github.com/JamesDBartlett3/Batten

The entire thing is Python stdlib — zero pip dependencies (~4k lines, 155 offline tests):

noaa.py + providers/ — NHC trackers, and a pluggable alert-provider layer: built-ins for NWS, CAP 1.2 feeds (the format most national weather services publish), and a generic JSON endpoint with field mapping, so you can point it at any alert service with a connection string
worstcase.py — the offline 48-hour extrapolation engine with documented, deliberately pessimistic assumptions
brain.py — the Ollama client (plain urllib, ~40 lines) and the prompts
watcher.py — the trigger state machine, adaptive cadence, quiet hours, outage fires
tui.py — ANSI terminal dashboard; web.py — stdlib HTTP server + mobile-first single-page dashboard for the LAN
tests/ — a full offline suite; nothing in CI touches the network

How I Built It

The open-source AI core: an open-weight model (default llama3.2:3b, any Ollama-pulled model works) doing local inference for everything conversational — chat, briefings, and narrating the worst-case plan. It talks to Ollama over plain HTTP; no SDKs, no accounts, no API keys.

The design rule that shaped everything else: the model is never a single point of failure. The safety loop — trigger detection, connectivity monitoring, worst-case math — is deterministic Python. The model turns numbers into judgment; if the model is cold or the laptop is struggling, the numbers still get delivered. The model gets only data Batten fetched or computed, with source timestamps, so it can't hallucinate an advisory that doesn't exist. Data in, judgment out, all on one machine.

The data half is open too: NOAA/NHC/NWS are public-domain open data. The alert-provider layer means the same binary works in Mexico on a CAP feed or against your municipality's JSON endpoint, not just US NWS.

Why Does Open Innovation Matter?

Because the failure mode this tool exists for is the internet being gone.

A closed API assistant goes dark exactly when you need it most. Storm knocks out connectivity — a cloud-model chat is unreachable, and your conversation history is on someone else's server. Batten's model runs on the laptop next to the flashlights. The chat that answered "should I cover the windows now?" at noon answers it at hour six of the outage, working from the last good advisory and its own log.
Your data stays yours. Coordinates, household size, supply list, and every anxious 3 a.m. question live in ~/.batten/. There is no telemetry, because there's nowhere to send it.
Cost nothing, forever. No subscription, no per-query meter, no tier where alerts become a paid feature. Set it up once; it runs on a decade-old laptop.
Inspectable and swappable. Worst-case doctrine too conservative for your coast? It's a documented module with the assumptions written at the top. Prefer Qwen to Llama? One flag. Try asking a closed weather assistant to change its forecasting philosophy.
Open compounds. The cone-image download workaround, the trigger thresholds, the quiet-hours rules — all of that came from an open-source storm bot's fix history, and now it's in a generalized tool anyone can fork for their own coast.

The Lazy Payoff

During the real week this tool is based on, the storm it watched meandered offshore for five days. Manually checking the NHC that responsibly means roughly 60+ cone-map refreshes across a work week while also doing actual storm prep — and the checks you skip at 4 a.m. are exactly the ones where rapid intensification happens.

Batten's deal: it checks on cadence (tightening to 30 minutes when things get close), pages you only on triggers that matter, and stops nagging during quiet hours. You get pinged four or five times across a five-day event — new storm, category change, "it's within 300 nm, finish outdoor prep," "it's within 150 nm, go inside" — instead of refreshing a map sixty times. The supply list is built once and re-scores itself every season. And the worst-case outlook means an internet outage during the storm stops being "am I blind now?" and becomes "here's the plausible worst case, here's what to finish first."

The original bot ran through the real Trudy week; zero house damage, and its human spent the whole storm swinging a hammer instead of watching maps. That's the lazy payoff: the bot does the watching so you can do the boarding.

My Coworkers Pay Monthly to Stream Their Voice to a Datacenter. So I Built Them Loquacio: a Free Dictation App That Never Phones Home

James D. Bartlett III — Mon, 05 Oct 2026 04:46:58 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

This one's for my coworkers at P3 Adaptive. Many of them dictate every day, and many of them pay a monthly subscription for commercial apps that don't even process the audio locally — so there's always a "who's potentially reading this?" question looming over everything. Their voice, recorded at their own desk, streamed to somebody else's datacenter. Some of them live with it; the rest just kept typing.

So I built them Loquacio: a desktop dictation app where every millisecond of audio stays on the machine it was spoken into, and which costs exactly nothing. That last part matters: since it's built entirely from open-source components — Whisper, local LLM servers, .NET itself — the subscription apps they've been paying for really ought to be free. Loquacio is me making that true. Speech recognition runs on a local Whisper model through Whisper.net. If they want punctuation and filler-word cleanup, that goes through their own local LLM — LM Studio or Ollama on localhost. The only network connection the app ever needs is to download the Whisper model files the first time. After that, it works just as well on a desert island with no Wi-Fi as it does at the office.

It's not a toy voice-note recorder — it's a real dictation workflow:

Continuous mode listens and transcribes as you speak, chunking on silence
Push-to-talk holds a hotkey for precise, on-demand capture
Keyword activation toggles listening with a spoken wake word
Custom vocabulary teaches it the names and jargon Whisper would otherwise mangle
Local LLM post-processing fixes capitalization, punctuation, "um"s, and misheard words — offline

The architecture is what makes it pleasant to live with: a small headless daemon owns the microphone and the model, and any controller — a full Avalonia GUI, a keyboard-only TUI, or the Windows WPF app — attaches to it over a private socket. Start the daemon once; dictate from whichever surface you're in.

Demo

The app itself ships as self-contained desktop builds (no runtime installation needed):

Platform	Build
Linux	`.AppImage`, `.deb` (with a systemd user service), portable `.tar.gz`
Windows 10/11	portable `.zip` with daemon auto-start script; MSIX buildable on a Windows host

Code

The full source is on GitHub: JamesDBartlett3/Loquacio

git clone https://github.com/JamesDBartlett3/Loquacio.git
dotnet build -c Release
dotnet test Loquacio.Tests -c Release   # 373 tests, all platforms

.NET 10, C#, MIT licensed. The test suite runs on Linux and Windows alike — including the daemon, IPC, and transcription pipeline.

How I Built It

The core AI is Whisper, OpenAI's open-source speech recognition model, running inference locally via Whisper.net — no API, no account, no per-minute billing. The app downloads whichever open-weight model size fits the user's hardware (tiny through large-v3) and validates checksums, so a corrupted model can't silently produce garbage.

The post-processing layer leans on the open OpenAI-compatible API shape that LM Studio and Ollama expose locally: the same protocol the cloud services use, pointed at localhost. That means the "smart cleanup" pass is swappable — any model they run locally works, and nothing is locked to one vendor.

On the engineering side, the interesting decisions:

Daemon-first architecture. Audio capture and inference live in one long-running process; GUIs are thin clients. The dictation state machine (sessions, stage timeouts) means a controller crash never interrupts a transcription.
Cross-platform by construction. The core library is plain .NET; platform code (WASAPI on Windows, D-Bus desktop integration on Linux) is isolated at the edges. The whole test suite runs on Linux even though one controller is WPF.
Honest packaging. Linux builds are cross-published on Linux (AppImage validated without FUSE, deb, tarball); the Windows zip is cross-built with EnableWindowsTargeting and every .exe verified as a real PE32+ binary before shipping.

Why Does Open Innovation Matter?

Because voice is the most sensitive data type most people ever produce, and the default options all route it through someone's cloud. Open-source AI at the core changes that equation completely:

Privacy isn't a policy, it's a property. There is no server to trust, no retention policy to read, no training opt-out to hunt for. The audio physically cannot leave the machine.
It works offline, forever. No subscription, no rate limit, no deprecation. The app my coworkers run today will work identically in ten years.
The model is a setting, not a lock-in. Whisper model sizes are a dropdown. The LLM cleanup layer speaks a standard local API. When a better open model ships next year, it's a swap, not a migration.
Zero marginal cost. My coworkers can dictate all day without anyone's meter running.

My Agent Session

This project was built pair-programming style with local AI agents. The agents planned phases, wrote and reviewed code through a real PR process (every change merged via review, including a dependency CVE adjudication), ran the 373-test suite, and built the release artifacts — while the human steered. Fitting, for an app about talking to your computer instead of typing at it.

Prize Categories

Overall
Featured: Best use of open-source AI / local inference