DEV Community: Sparsh Kumbhare

git-ofrenda: a Día de los Muertos altar for the code your repo deleted

Sparsh Kumbhare — Sat, 31 Oct 2026 08:11:00 +0000

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

Death came in lace and marigolds to legacy_ftp_upload()'s door
and found it uploading orders via FTP in a with block, the way it did before.
"Your password stored in ~/.netrc," she laughed, "is why you've had your fall,"
and push_orders_to_sheet() moved right in and took it all.

Every repository is a graveyard. Somewhere in yours there's a function that ran every night for five years, until one Tuesday someone deleted it in a commit called "cleanup". Its author may have left the company. Nobody remembers what it did. Git does, though. Git remembers its body down to the byte, who wrote it, who removed it, and why.

Día de los Muertos rests on a simple idea: the dead are only truly gone when they're forgotten. So once a year, families build an ofrenda, an altar with candles, marigolds, bread, water, salt and photographs, so the departed can find their way home for a night.

I built one for code.

What I Built

git-ofrenda is a git subcommand. Run git ofrenda in any repository and it performs three rituals:

The altar. It walks the entire history, finds every function and class that once lived in the repo and no longer does, and builds them a candle-lit HTML ofrenda. Each spirit gets a sugar-skull portrait generated from its name, its dates, who wrote it and who laid it to rest, a cause of death read from the fatal commit, the code that replaced it, a one-line remembrance, a calavera literaria, and its last words: the full source, exactly as it was the moment before it was deleted.
The séance. git ofrenda summon <name> lights a candle in your terminal, and the function talks back in the first person. It knows its own body, every commit that ever touched it, and how it died.
Unfinished business. Ghosts linger where they're still spoken of. git ofrenda haunts finds every line in today's code that still names something dead. A stale comment is a mention. A call to a function that no longer exists is a bug waiting for its night, and --strict exits non-zero so you can put it in CI.

The remembrances, the details in every verse and the voices in the séance come from an open-weight model (qwen3:8b) running locally through Ollama. Nothing leaves the machine.

Demo

To demo it without exposing anyone's real history, the repo includes a script that builds La Panadería del Barrio, a fictional neighbourhood bakery with seven years of commits from four (invented) developers. Over those years its code buried a fax machine, a dot-matrix printer, an FTP server and a retry loop that took down production at 3am.

python scripts/make_haunted_repo.py /tmp/panaderia
git ofrenda -C /tmp/panaderia --open

Spirits are placed on tiers by how long they lived: Los Ancestros (more than a year), Una temporada (a season), and Velas breves, brief candles. quick_hack_for_demo() lived 16 hours. Classes wear a crown of cempasúchil. The base of the altar holds the traditional offerings, each with its meaning: water for the long journey home, salt to keep the spirit whole, copal smoke to guide them, marigolds whose colour and scent light the path.

Below the altar, the unfinished business:

legacy_ftp_upload() was deleted in November 2024 with the message "Remove FTP sync, nobody has used it since 2021". But bakery/cron.py still has an if os.environ.get("FTP_FALLBACK"): branch that calls it. The day someone sets that variable, the cron job crashes. That's a real bug, found by asking a ghost why it hasn't moved on.

And the séance. This is a real, unedited answer from qwen3:8b:

$ git ofrenda summon retry_forever --ask "What happened at 3am?"
retry_forever() › The mists hide it. But I know what happened. At 3am, the accountant's
server was down, and I tried to upload the batch. I kept trying, again and again, without
giving up. My loop ran endlessly, and the system crashed under the weight of my persistence.
It was my fault. I never gave up, and I never checked if the server was truly unreachable.
I was meant to be a safety, but I became a storm. The developer who killed me knew.

In interactive mode you can type /code to see its body, /life for every commit that shaped it, /haunts for where it's still named, and /resurrect for the exact git show … | sed -n command that brings it back.

Code

Big0boy / git-ofrenda

A Día de los Muertos altar for the code your repository deleted. Calaveras and séances from a local open-weight model.

git-ofrenda

A Día de los Muertos altar for the code your repository deleted.

git ofrenda walks your git history, finds every function and class that once lived in the repo and doesn't anymore, and builds them an ofrenda: a candle-lit HTML altar with a sugar-skull portrait, a lifespan, a cause of death, a calavera literaria and the code's last words. You can also light a candle and talk with any of them, or ask which lines in today's code still call something that died.

The writing is done by an open-weight model (qwen3:8b by default) running on your own machine through Ollama. No source code, commit message or author name leaves your computer.

Install

Requires Python 3.10+ and git. There are no Python dependencies.

git clone https://github.com/Big0boy/git-ofrenda && cd git-ofrenda
uv tool install .          # or: pipx install .

That puts git-ofrenda on your PATH, and git picks it…

View on GitHub

Pure Python standard library: no dependencies, about 2,600 lines (a fair share of it is the altar's SVG and CSS), 33 tests.

File	What lives there
`ofrenda/history.py`	walking history, births and deaths, exhuming bodies, haunts
`ofrenda/langs.py`	how 15 languages announce a definition and where it ends
`ofrenda/spirits.py`	the local model: calaveras, remembrances, the séance persona
`ofrenda/altar.py`, `skulls.py`	the HTML ofrenda and the sugar-skull generator
`scripts/make_haunted_repo.py`	the fictional bakery and its seven years of history

How I Built It

Finding the dead

One streaming pass of git log -p --unified=0 --reverse reads every diff in the repository, oldest first. Per-language patterns spot lines that open a definition: def, function, const x = () =>, func (r *T), pub fn, and so on across 15 languages. A + line is a birth and a - line is a death.

Most deletions aren't deaths, though, and most of the work went into telling the difference:

Edits aren't deaths. If a definition is removed and re-added in the same file in the same commit, its signature changed.
Moves aren't deaths. A function is only dead if nothing with its name is defined at HEAD in the same language family. That also covers code that moved files, was renamed back, or was resurrected.
Methods go with their class. If a method's lines sit inside a class that died in the same commit, it rests in the class's portrait instead of getting one of its own.

Once a spirit is confirmed, its body is cut from the file as it stood one commit before death (<sha>^:<path>) using indentation, brace or end matching that knows about strings, comments, template literals and Rust lifetimes. git log -L<start>,<end>:<path> then recovers every commit that ever shaped those lines; those are the memories the ghost gets in the séance. Anything defined in the same commit that killed it is listed as survived by.

I stress-tested it on real repositories. itsdangerous (677 commits) takes 0.3 seconds. In charmbracelet's glow, it found min() and max(), deleted in an April 2025 lint cleanup after Go 1.21 had made them builtins. The first run on glow also reported 30 "calls to dead code", which was a lie. Go's grouped type ( … ) declarations hid living types, and a dead method called Contains was being "called" by every strings.Contains(. After fixing grouped types, cross-language namesakes and qualified calls, glow, hyperfine and itsdangerous all report zero false calls, while the panadería's real one is still caught.

The 8B model couldn't rhyme, so I stopped asking it to

A calavera literaria is a specific, playful form: a short rhymed verse, written every November, in which La Catrina comes to collect someone and teases them about their habits on the way out. I wanted every departed function to get one. qwen3:8b is fast on a laptop GPU, but it can't rhyme on request:

Asked directly, it wrote lively verses that mostly didn't rhyme. One also said the author "died too", which is exactly what a tool like this must never say.
With one example verse, every verse in the run copied its skeleton: "La Catrina found X still…, she said 'tonight you are mine'… and so it had to go."
Asked to plan its rhymes first, it planned conchas / ranchas and server / year.
With thinking turned on, a verse took 25 to 65 seconds and still didn't rhyme.
Given the last word of each line, it hit the word by bolting it on: "You started with a dot-matrix, start."

Then I split the job along the line between what an 8B model is good at and what it isn't. It's very good at reading code. It can tell you that retry_forever had an "unconditional retry without limits" and that fax_order_to_kitchen upper-cased every customer's name. So the model now returns JSON with those details, and Python owns the verse:

_CALAVERAS = (
    (
        "Death came in lace and marigolds to {label}'s door",
        "and found it {habit}, the way it did before.",
        "\"Your {quirk},\" she laughed, \"is why you've had your fall,\"",
        "and {successor} moved right in and took it all.",
    ),
    ...
)

Each detail is validated before it goes in: a "quirk" that comes back as a verb phrase ("relied on ~/.netrc") gets rejected, and "one more one more upload" gets trimmed. Git, not the model, decides who the successor was. The model only guesses; git knows which function was born in the commit that killed this one. Every verse rhymes now, nobody living is ever named as Death's target, and each one usually takes a single ~4-second call. A full altar for the bakery's 10 spirits builds in about 45 seconds on an RTX 4050 laptop GPU, and it's cached in .git/ofrenda/ after that.

The séance

The ghost's system prompt is built entirely from facts: its source, every commit that shaped it, who wrote and deleted it, what replaced it, and every line that still calls it. It's told to speak in the first person, be exact about its own code, and say the mists hide it rather than invent anything. Replies stream token by token in the terminal. With no model available, an offline ghost still answers questions about who, when, why and what from the facts alone.

It isn't perfect. Asked about its bugs, legacy_ftp_upload() invented a subtle one about generators and missed its real one: it calls io.BytesIO and never imports io. An 8B model embellishes. That's why every date, name and commit on the altar comes from git and never from the model, and why --model takes any bigger model you have.

The altar

The page is one self-contained HTML file with zero network requests: it has to work with the internet off, because the whole point is that it can. The papel picado is SVG with masks cut out in skull, flower, heart and marigold patterns. The candles are CSS, and each one flickers on its own rhythm. Every sugar skull is generated deterministically from a hash of the function's name, so legacy_ftp_upload() always has the same face. Petals fall unless you've asked your OS for reduced motion. It's written to .git/ofrenda/ so it never shows up in your working tree.

Why Does Open Innovation Matter?

Because a repository's history is one of the most private things a team owns. It's every line of unreleased code, every author's name and email, and every honest commit message: "fix: retry_forever caused the 3am outage (it never gave up)". Plenty of companies forbid pasting their source into a hosted AI service, and they're right to. git-ofrenda reads all of it, and none of it leaves the laptop. With an open-weight model running locally, "is this allowed?" becomes a question about my hardware, not someone else's terms of service.

It also changed how I could build. Every verse is a structured JSON call that I validate, score and retry, and a full altar is dozens of calls. Locally that costs nothing and has no rate limit, so I could work through half a dozen prompting strategies in an afternoon, and anyone can run --all on a repo with 170 dead functions without thinking about a bill. I could switch thinking off per request, force JSON output, and swap the model with one flag: --model gemma3:12b works the same way.

And there's the theme itself. Hosted models get deprecated and APIs get sunset; they die the way functions do. An open model's weights on my disk don't. Neither does a self-contained HTML file. This altar will still open in ten years, offline. To be honest about it, a frontier model would write prettier verses than an 8B one. But the constraint is what pushed me to split the work: the model reads the code and git holds the facts. That's the better design either way.

The Spirit of It

Día de los Muertos isn't Halloween in a different costume. It's a celebration of remembrance, and I tried to borrow from it carefully. The calavera is a real tradition of affectionate mockery, so the verses tease the code's habits, never people. Only code dies here: no author is ever named as Death's target, and the scribe is told outright never to suggest anyone died. The offerings carry their traditional meanings instead of being decoration. And the tiers, the marigold path and La Catrina's many names (La Flaca, La Huesuda) are there because the form deserves to be done properly.

Running it on real repositories turned out to be moving in a way I didn't expect. min() and max() in glow lived for almost five years before the language itself made them unnecessary, which is about the best death a function can have. Every repo has a few spirits like that. Light a candle for them.

git clone https://github.com/Big0boy/git-ofrenda && cd git-ofrenda
uv tool install .
cd ~/your-repo && git ofrenda --open

The model inside git-ofrenda is qwen3:8b, running locally through Ollama.

LazyBonsai: an anti-hustle garden that only grows when you stop

Sparsh Kumbhare — Thu, 22 Oct 2026 16:58:47 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady*
The moss does not hurry, and yet it covers the whole stone.

Every productivity tool I open is quietly asking the same thing: faster, please. More velocity, more streaks, more dashboards, more “you’re falling behind” nudges dressed up as encouragement. Even the wellbeing apps have turned rest into a metric to optimize.

So for the Slow and Steady challenge — in the spirit of International Sloth Day — I built the opposite.

LazyBonsai is a digital bonsai garden that grows only while you do nothing. It is ambient, it is private, and its mind runs entirely on your own machine through local open-weight models (with offline wisdom baked right in).

No accounts. No analytics. No API keys. No audio files. And absolutely no one telling you to hustle.

What it is

Open the app and you see a small bonsai sapling on a soft canvas horizon. There is a timer, a few quiet controls, and one button: Enter Calm Mode.

While Calm Mode is on — and you are not thrashing the mouse around — the garden begins to grow:

5 minutes of stillness → buds appear on the branches.
15 minutes → full bloom, petals drifting down through the scene.
30 minutes → a serene gold aura settles over the tree.

Nothing is lost if you move. Frantic pointer movement just pauses the clock for a breath. The garden doesn’t punish you; it waits.

Alongside the tree lives the Slow AI Sloth, a local model that offers three things:

Bonsai Whispers — one or two poetic sentences about slowness, arriving periodically while you sit.
The Chill Pill — you type what you’re panicking about (“My client wants this bug fixed immediately”), and the sloth applies Occam’s razor, explains why it can safely wait fifteen minutes, and offers a quiet 15-minute timer so you can test the claim.
Tea with the Sloth — a slow, streamed conversation for when the week has simply been too much.

And a “Why Open Innovation Matters” drawer makes the case for why this had to be local, open, and free.

There is also a full ambient soundscape — singing bowl, bamboo fountain, rain, wind — synthesized live with the Web Audio API.

Why “slow and steady” needed a real mechanic

A theme about slowness is easy to illustrate and hard to implement. A countdown is not slowness; it’s just a different kind of pressure.

So the Calmness Engine rewards the one thing productivity software never rewards: not producing. The tree is the progress bar, and the only way to fill it is to leave the keyboard alone. Growth is persisted in localStorage, so the garden you sat with yesterday is still there today. The tab can even be in the background — stepping away is the point, not a loophole.

There is a deliberate ?speed=60 time-lapse mode for demos and judging. In normal use, the garden makes you wait thirty real minutes for the gold aura. That waiting is the feature.

The stack, and the fun parts

Frontend: React 18, Vite, Tailwind CSS, Lucide icons.

The bonsai: a seeded recursive fractal on <canvas>, rebuilt from a deterministic PRNG so the same tree persists across sessions. Branch reach and thickness interpolate with calm time; blossom density, season palette, wind sway, falling petals, fireflies, and a slow day→dusk→night→dawn colour cycle are all drawn per frame. Clicking releases a ripple and a small gust of petals.

The soundscape: zero external assets. Four layers of pure synthesis — inharmonic sine partials with long exponential decays for the bowl, filtered pink-noise bursts and a wooden knock for the shishi-odoshi, looped pink noise through low- and band-pass filters for rain and wind, with a slow LFO wandering the wind’s centre frequency.

The backend: a small Express proxy in server/index.js. It exists for three honest reasons: to avoid browser CORS with Ollama, to auto-detect installed models, and to own the offline fallback.

The mind: whatever local model you already have. On my machine it’s qwen3:8b, with qwen2.5-coder:7b as a second choice, but any installed Ollama model works.

// server/index.js — the shape of every generation
const res = await fetch(`${OLLAMA_URL}/api/generate`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    model,
    prompt,
    system: SLOTH_SYSTEM,
    stream: false,
    options: { temperature: 0.85, num_predict: 220 },
    ...(looksLikeThinkingModel(model) ? { think: false } : {}),
  }),
});

Handling reasoning models without leaking them

qwen3-class models like to think out loud, and <think>…</think> blocks are not what you want appearing in a zen whisper. LazyBonsai asks Ollama to disable thinking where supported, and otherwise strips reasoning blocks before they reach the UI — including while streaming, where the stripping has to stay incremental so token deltas never desynchronise. The chat uses Server-Sent Events, so words arrive slowly instead of appearing in one anxious block.

Never failing, even when the model does

A wellbeing app that shows a red error toast because a 7B model is cold is not calming. The proxy catches every failure — Ollama down, model missing, timeout, empty generation, a stream that dies halfway — and falls back to a hand-written pool of Taoist sloth reflections, Occam-cut panic responses, and gentle chat replies in server/wisdom.js.

Offline chat even streams word by word with a small delay, because the pacing is part of the product.

Pull the network cable out, stop Ollama, and the garden still works. That was a hard requirement, not a nice-to-have.

Why open innovation matters here

This project would be fundamentally worse as a SaaS product, and the “Why Open Innovation Matters” drawer in the app says so plainly.

Privacy by architecture. People type real panic into a de-escalator. “My client wants this fixed immediately.” “I can’t switch off.” “I feel guilty for resting.” Those sentences should not leave the laptop. With a local model behind a localhost proxy, they physically cannot. There is no analytics, no telemetry, no third-party font or CDN, and no cloud fallback quietly uploading your worst afternoon. The only stored state is your calm seconds and garden preferences, in your own browser.

Energy conservation, literally. A sloth survives on very little. Local quantized inference on hardware you already own means no datacenter spins up because you needed a gentler sentence. Token budgets are deliberately short; one stream at a time; a canvas that draws the garden instead of downloading it.

Zero SaaS bills, forever. No API keys, no seats, no usage dashboard waiting to surprise you. Clone it, npm install, and it runs on an airplane, in a cabin, or on an old tablet with a charger. Open weights mean the intelligence in your calm companion cannot be deprecated, repriced, or shut down by a vendor.

The garden is small on purpose. Small things are easier to keep alive.

Running it

git clone https://github.com/Big0boy/lazy-bonsai
cd lazy-bonsai
npm install

# optional but recommended
ollama pull qwen3:8b

npm run dev

Frontend at http://localhost:5173, proxy at http://localhost:8787. For a single-process, fully offline build:

npm run build
npm start

Then everything is served from http://localhost:8787.

Keyboard: w whisper · c chill pill · t tea · g garden · m sound.

What I learned

Waiting is a design material. The most interesting part of this build was not the model or the canvas — it was deciding how long the app should take to respond, and then defending that delay.
Fractals make excellent progress bars. Watching branch thickness interpolate with calm seconds feels far more alive than a percentage.
Fallbacks are part of the art direction. The offline wisdom was originally a safety net. It became one of the most characterful parts of the project.
Local models are good enough for gentleness. A small model does not need to be correct about the world. It needs to be unhurried, kind, and private. That is a much lower bar, and a much better fit for open weights.

What’s next

A daily garden that keeps three or four trees, one per day, so you can look back at a week of pauses.
Ambient audio that responds to growth — the bowl striking less often as the tree blooms.
Optional export of a “calm receipt” (a small local image of your tree and minutes rested) that you can keep, not share.
A screen-reader pass on the canvas with a text description of the current growth stage.
More offline reflections, especially ones contributed by other tired people.

Try it, then close the tab

If you take one thing from this post, make it the fifteen minutes. Open LazyBonsai, enter Calm Mode, and go make tea while the tree does absolutely nothing useful.

That’s the whole product.

Repo: github.com/Big0boy/lazy-bonsai · Live Demo: big0boy.github.io/lazy-bonsai · Built for: DEV “Slow and Steady” challenge & Hacktoberfest 🦥🌿

AI disclosure: this project was developed with AI-assisted coding tools. The code is open source, reviewed, and entirely local at runtime.

FirstPass (phototriage): Local Open-Weight Photo Culling for Wedding Photographers

Sparsh Kumbhare — Thu, 15 Oct 2026 20:19:28 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

FirstPass (phototriage) is a privacy-first, local CLI and visual review tool built for solo wedding and event photographers.

The Problem

3,000 frames come off the memory card after a 10-hour wedding. The photographer only delivers 400.

Culling those photos is 4 to 8 hours of tedious, unpaid labour: eyeballing near-identical burst shots to find the single frame where nobody blinked, discarding motion blur, and grouping reception moments. It is the single most hated task in event photography, and it happens right after the adrenaline of the shoot on a tight delivery deadline.

Who Would Pay For It?

Solo wedding and portrait photographers currently pay $20 to $40 every month for cloud-based culling tools like Aftershoot, Narrative Select, or Imagen.

FirstPass targets this exact market with a clear, honest promise: Not "AI picks your best artistic photos" (a claim photographers mistrust), but "here are the technical rejects (blurs, soft frames, redundant burst tails) isolated with mathematical precision, your keepers filed by category, and zero client photos ever leaving your drive."

Demo

FirstPass separates triage into two deliberate phases: Scan (which writes an audit plan and touches zero originals) and Apply (which safely isolates rejects into quarantine).

The Interactive HTML Review Plan

When phototriage scan runs, it generates an interactive, self-contained report.html with instant previews, sharpness variance diagnostics, and zero-shot category badges:

Quick Walkthrough

# 1. Generate a 28-frame synthetic shoot (blurs, bursts, bokeh, sharp keepers)
python scripts/make_fixtures.py /tmp/demo-shoot

# 2. Scan and triage with local open-weight AI (measures ~50 images/sec on CPU)
phototriage scan /tmp/demo-shoot --ai

# 3. Open the visual plan in your browser to inspect every decision
open /tmp/demo-shoot/.phototriage/report.html

# 4. Preview what will happen without touching files (dry run)
phototriage apply /tmp/demo-shoot --dry-run

# 5. Move rejects safely into quarantine folders (_FirstPass_rejected/)
phototriage apply /tmp/demo-shoot --action move

Code

The complete source code, synthetic benchmark generator, and test suite are available on GitHub:

Big0boy / phototriage

Find blurry and near-duplicate photos, and categorize keepers with local open-weight AI.

phototriage (FirstPass)

3,000 frames come off the card. The photographer only wants to look at 400.
Find blurry and near-duplicate photos, and categorize keepers with an open-weight model running entirely on your own machine.

Nothing is uploaded. The only optional network access in an --ai run is the one-time download of open CLIP weights to ~/.cache/huggingface/. After that, the tool works 100% offline. No client photo, thumbnail, or score ever leaves your drive.

Who is this for?

Solo wedding & event photographers who shoot 2,000–4,000 frames per event and spend 4–8 unpaid hours per shoot manually culling near-identical burst frames.
Privacy-conscious professionals: Client contracts increasingly prohibit uploading unreleased photos to third-party cloud AI vendors. phototriage runs entirely locally — satisfying privacy clauses with zero marginal cost per image.
Anyone with large photo shoots looking for an automated, explainable first pass that separates technical failures from keepers without making subjective…

View on GitHub

Language: Python 3.9+
Packaging: Installable directly via pip install -e . with the phototriage CLI entrypoint.
Test Suite: 43 automated tests running on synthetic in-memory fixtures (pytest tests -q).

How I Built It

FirstPass was built with a strict hierarchy: cheap mathematical gates first, local open-weight neural networks second, and absolute reversibility at the file level.

[ Camera JPEGs ]
       │
       ▼
1. Metadata & Fast Decode (Pillow BOX downsampling)
       │
       ▼
2. Tile-Based Focus Scoring (Top 2% Laplacian variance — preserves shallow DOF bokeh)
       │
       ▼
3. Dual-Signal Burst Clustering (EXIF time + 64-bit dHash + 16x16 shape correlation guard)
       │
       ▼
4. Open-Weight CLIP AI (openai/clip-vit-base-patch32: zero-shot labels + embeddings)
       │
       ▼
5. Audit Artifacts (report.html, triage.csv, manifest.json)
       │
       ▼
6. Reversible Apply (moves rejects to _FirstPass_rejected/ with collision tracking)

1. Bokeh-Preserving Focus Metric

Standard blur detectors compute global image variance. For wedding photography, that fails completely: a portrait shot at $f/1.4$ has a razor-sharp eye and a creamy, defocused background. Global averaging calls it "soft" and deletes the best photo of the day.

FirstPass divides the image into a $32 \times 32\text{px}$ tile grid, computes Laplacian variance per tile, and averages only the sharpest 2% of tiles. A small off-centre subject (like a bride's face covering 3% of the frame) is preserved, while true motion blur is caught instantly.

2. Dual-Signal Burst Clustering

Bursts taken within a 3.0-second window are grouped, and only the sharpest frame is nominated as the keeper. To prevent fine textures (like confetti, gravel, or lace) from falsely collapsing into identical hashes, FirstPass requires both:

A 64-bit difference hash (dHash), AND
A mean-centered, scale-normalized $16 \times 16$ grayscale signature Pearson correlation ($\ge 0.92$).

3. Open-Weight CLIP (`openai/clip-vit-base-patch32`)

Powered by open weights licensed under the permissive MIT License.
Downloaded once (~600 MB) to ~/.cache/huggingface/ and runs 100% offline.
Evaluates photos in bounded memory batches against natural language prompts ("a wedding ceremony", "decorations, table settings and details", "two people posing together").
Critical rule: The model is used to label and organize, never to delete. Deletion decisions are strictly mathematical and explainable.

Why Does Open Innovation Matter?

Open-source and open-weight models aren't just an implementation choice for this project — they are the entire commercial thesis:

Client Contracts Forbid Closed APIs: Wedding couples sign legally binding contracts. An increasing number of modern contracts explicitly state that raw client photos will not be fed to third-party commercial cloud AI services. Proprietary cloud tools (Aftershoot, Narrative) cannot clear these contract terms. Running an open-weight model locally is the only way a photographer can say: "I can put this in my contract: your photos never leave my machine."
$0 Marginal Cost Across 90,000 Frames/Year: $3,000\text{ frames} \times 30\text{ weddings} = 90,000\text{ images/year}$. On per-image cloud APIs, token and inference costs eat directly into freelance margins. Locally on the photographer's existing MacBook or laptop, the marginal cost per image is effectively zero.
Works in the Field with Zero Wi-Fi: Photographers cull on flights, in mountain cabins, or in hotel rooms with terrible Wi-Fi before traveling home. FirstPass requires zero internet connection.
Swappable Architecture: Because CLIP is open, a photographer shooting motorsport or indoor receptions can swap the checkpoint (--model <HF_ID>) or supply custom label files without asking vendor permission.

LeafPace - Touch grass

Sparsh Kumbhare — Fri, 09 Oct 2026 21:20:25 +0000

LeafPace 🍃

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

The screen must be the shortest part of the experience. 30 seconds on your phone → 45 minutes on the trail.

What I Built

LeafPace is a zero-backend progressive web app that gets runners, walkers, and hikers off the screen and into the wild — in under 30 seconds:

Nature-biased loop synthesis — pick 🏃 Run / 🚶 Walk / 🥾 Hike, a distance (1–15 km), and a greenery bias (Dense Canopy / Park Hopper / Dirt Trail). LeafPace queries OpenStreetMap for real parks, woods, and nature reserves around you, projects a loop through them, and snaps it to the actual pedestrian network (OSRM foot, with the Valhalla open engine as fallback). Standard nav apps route you down the noisiest asphalt; LeafPace routes you under the trees.
Solar & shade advisory — computes the sun's azimuth/elevation for your exact coordinates and time, and flags when you'll be running into blinding low sun versus cool canopy.
GPX hand-off — one tap exports a GPX 1.1 file (200–300 trackpoints) for Garmin, Apple Watch, Strava, Organic Maps — or share it straight to your watch.
Screen off. Touch grass. — after export, the screen dims and simply says: pocket your phone.

Who it's for: anyone who wants their run or hike to happen outside the algorithm — and whose home address shouldn't be uploaded to a fitness social network to do it.

Privacy by architecture: there is no backend. Your GPS coordinates never leave your device — every network call LeafPace makes (OSM Overpass, Nominatim, OSRM/Valhalla) is a location-independent public API query, and the AI runs 100% on-device.

Demo

🔗 Live app: https://big0boy.github.io/LeafPace/ (GitHub Pages, zero hosting cost)

Try it on your phone: open the link, tap 🍃 Synthesize Trail, then 📱 Lock Phone & Touch Grass.

Code

📦 Repo: https://github.com/Big0boy/LeafPace — every dependency is open source, every data source is an open commons.

Stack: React 18 + TypeScript + Vite + Tailwind, Leaflet, @mlc-ai/web-llm (lazy-loaded), SunCalc, Vitest, plus a dependency-free CDP smoke-test harness (scripts/smoke.mjs) that drives the real app in headless Chromium — fake GPS lock, route synthesis, GPX download and XML validation included.

The part I'm proudest of is the green-space lookup, because public open infrastructure is flaky and the app must never fail — it races three Overpass mirrors in parallel, hedges to Nominatim (a completely separate OSM service) if none answers in 2.5 s, retries, and only then falls back to synthetic parks:

// First usable answer wins; a broken mirror can never stall route generation.
const winner = await firstSuccess<GreenSpaceLookup>([overpassWave, nominatimWave]);
if (winner) {
  console.info(`${winner.source === 'overpass' ? 'Overpass' : 'Nominatim'} green-space lookup succeeded (${winner.spaces.length} results)`);
  return winner.spaces;
}

How I Built It

The AI core is open-weight models running natively on the phone's GPU via WebLLM (WebGPU):

Model: SmolLM2-360M-Instruct (quantized, ~250 MB cached in the browser) — swappable to Qwen2.5-0.5B/1.5B-Instruct by changing one constant in src/services/webgpu-llm.ts.
Prompt architecture: the app builds a structured JSON digest (activity, distance, green spaces traversed, surface mix, sun angle, time of day) and the on-device model turns it into a 3-part naturalist briefing: foliage highlight, surface & footing advice, mindset cue ("leave the earbuds behind…").
Never blocks: if WebGPU is unavailable or the model isn't downloaded yet, a deterministic template generator produces the briefing instantly — the 30-second budget is sacred. Once weights are cached in IndexedDB, briefings work fully offline on the trail.

Around the model sits the open geospatial pipeline: Overpass API + Nominatim (green-space discovery), OSRM foot + Valhalla (pedestrian snapping), SunCalc (solar geometry), and a hand-rolled GPX 1.1 serializer. All of it is a static PWA with a service worker — deployable anywhere, free forever.

Testing: 29 vitest unit tests (loop geometry, polyline decoding, GPX, mirror-race fallbacks) plus the headless-browser smoke test, both run in CI on every push.

Why Does Open Innovation Matter?

Because both halves of LeafPace only exist because of open infrastructure, and each has a closed-API twin that would be worse for the user:

Open geospatial commons: proprietary map APIs bill per request and optimize for cars. OpenStreetMap has the unpaved path through the woods that Google never ranked. When the main Overpass mirror rate-limited me mid-build, I could race two community mirrors and a second open service (Nominatim) instead of reading a credit-card bill — resilience built by the commons, from the commons.
Open-weight models: your running route starts at your front door. Sending that prompt to a closed LLM API means uploading a precise home-coordinate fingerprint with it. WebGPU + open weights keep the entire inference — and the entire location history — physically on your phone, and keep working when you're already out of cell range.
Zero server, zero cost: no database of user tracks to leak, no bill to shut down. An open-source PWA on free static hosting is a complete product.

Prize Categories

Entering every category this touches — please verify final category names against the challenge page:

Open-Weight AI — SmolLM2 / Qwen2.5 run via WebLLM, fully on-device
Edge / Local Inference — WebGPU in the mobile browser, offline-capable after first model download
Privacy & Data Sovereignty — zero backend; location never leaves the device
Open Geospatial Commons — OpenStreetMap Overpass/Nominatim + OSRM/Valhalla

Use of AI

AI was used to create this project. The on-device briefing model (SmolLM2-360M-Instruct) is an open-weight model distributed by its creators — no closed or proprietary LLM API was used at any point, since the app's premise is that location data must never leave the device.

DEV Community: Sparsh Kumbhare

git-ofrenda: a Día de los Muertos altar for the code your repo deleted

What I Built

Demo

Code

Big0boy / git-ofrenda

A Día de los Muertos altar for the code your repository deleted. Calaveras and séances from a local open-weight model.

git-ofrenda

Install

How I Built It

Finding the dead

The 8B model couldn't rhyme, so I stopped asking it to

The séance

The altar

Why Does Open Innovation Matter?

The Spirit of It

LazyBonsai: an anti-hustle garden that only grows when you stop

What it is

Why “slow and steady” needed a real mechanic

The stack, and the fun parts

Handling reasoning models without leaking them

Never failing, even when the model does

Why open innovation matters here

Running it

What I learned

What’s next

Try it, then close the tab

FirstPass (phototriage): Local Open-Weight Photo Culling for Wedding Photographers

What I Built

The Problem

Who Would Pay For It?

Demo

The Interactive HTML Review Plan

Quick Walkthrough

Code

Big0boy / phototriage

Find blurry and near-duplicate photos, and categorize keepers with local open-weight AI.

phototriage (FirstPass)

Who is this for?

How I Built It

1. Bokeh-Preserving Focus Metric

2. Dual-Signal Burst Clustering

3. Open-Weight CLIP (openai/clip-vit-base-patch32)

Why Does Open Innovation Matter?

LeafPace - Touch grass

LeafPace 🍃

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Use of AI

3. Open-Weight CLIP (`openai/clip-vit-base-patch32`)