DEV Community: Prateek singh

Walkthrough sorts a listing shoot into a house tour, and no photo ever leaves the laptop

Prateek singh — Sat, 17 Oct 2026 18:28:27 +0000

What I Built

Walkthrough is a small tool for real estate photographers. It does the dull job that comes after every shoot.

A photographer leaves a property with 30 to 60 photos, named IMG_4012.jpg to IMG_4071.jpg. Before the agent can use them, someone has to:

Put them in tour order. The front of the house goes first, because the first photo is the cover on most listing sites. Then the living spaces, kitchen, bedrooms, bathrooms, and the backyard.
Take out the bad frames: underexposed shots, a soft frame from a bumped tripod, and three almost identical angles of the same bathroom.
Rename everything so the agent and the listing site keep the order.

Walkthrough does all three in one pass. You drop the shoot onto the page. An open-weight vision model, running in the browser tab, decides which room each photo shows. The app puts the photos in order, sets aside the dark, soft and repeated ones, and gives you a zip:

12-oak-street-01-front-exterior.jpg
12-oak-street-02-front-exterior-2.jpg
12-oak-street-03-living-room.jpg
...
shot-list.csv

The original files go into the zip unchanged, with no re-compression. You can still change a room, drag a photo to a new place, pick a different cover, or put a set-aside photo back. The model makes the first draft, and the photographer has the final say.

Who would pay for it:

Solo real estate photographers. This is the main customer. They shoot several homes a day, and every shoot ends with the same sorting job.
Small agencies and the assistants who upload listings for them.
Agents who shoot their own listings on a phone. They do not know the "front exterior first" rule until a listing goes live with a toilet as the cover photo.

How it would make money: a flat $9 a month for unlimited listings. Because the model runs on the customer's own computer, each extra listing costs me nothing. A flat price works, and I never need to count photos.

Demo

Try it: https://prateekiiitg56.github.io/walkthrough/

No photos to hand? Click Try it with 14 sample photos. The sample set is a real house front and a real apartment (CC BY-SA, from Wikimedia Commons). I added one blurred copy and one darkened copy so you can see the app set them aside.

The first run downloads the model one time: 176 MB on a computer with WebGPU, or 89 MB without. After that, the app works with no connection.

Code

Prateekiiitg56 / walkthrough

Sorts a real estate photo shoot into listing order in your browser. Open-weight CLIP, no uploads.

Walkthrough

Walkthrough sorts a real estate photo shoot into listing order, in your browser.

Drop in the photos from a property shoot. Walkthrough:

puts them in tour order: front of the house, living spaces, kitchen, bedrooms, bathrooms, then outside;
sets aside photos that are too dark, out of focus, or almost the same as a better shot;
renames the original files in order (12-oak-street-01-front-exterior.jpg) and downloads them as a zip with a shot-list.csv.

You can change any room, drag photos into a new order, pick a different cover, or put a set-aside photo back.

Live: https://prateekiiitg56.github.io/walkthrough/

Photos are never uploaded. The model runs in the browser tab.

How it works

Model: CLIP ViT-B/32, open weights, ONNX.
Runtime: Transformers.js 3.7.6
- With WebGPU and 16-bit float support, the fp16 vision model runs on the graphics card. That is about 80 ms per photo and a 176 MB one-time…

View on GitHub

How I Built It

Model: CLIP ViT-B/32, open weights, ONNX export.
Runtime: Transformers.js in the browser.
- With WebGPU, the fp16 vision model runs on the graphics card. On my laptop, that is about 80 ms per photo.
- Without WebGPU, the 8-bit model runs on WebAssembly. That is about 0.8 s per photo: slower, but it works everywhere.
App: plain HTML, CSS and JavaScript modules. No framework, no build step and no backend. JSZip makes the download, and GitHub Pages hosts the files.

Rooms are just text. CLIP puts images and text into the same vector space. Each room type is one to three short prompts, such as "a real estate photo of a kitchen with an oven and a sink". A photo goes to the room whose prompts are closest to it. To add a room type, you add a line of text. There is no training.

Only half the model goes to the browser. The room prompts never change while the app runs, so I embed them once with a small Node script and ship the 14 vectors as a 60 KB JSON file. The browser downloads only CLIP's vision encoder. That cut the download and removed a whole model from the page.

One embedding does three jobs. Each photo goes through the model once:

Room: cosine similarity against the 14 room vectors, then a softmax. If the top room is below 50%, the card says "Check room".
Order: rooms in listing order. Inside a room, the photo the model is surest about goes first.
Duplicates: two photos of the same room with a cosine similarity of 0.95 or more are the same shot, so the weaker one is set aside.

Dark and soft come from the pixels, not the model. In my first test, the blurred kitchen photo came back as "hall and stairs". A blurry photo loses the details that tell rooms apart. So the app checks focus and brightness separately, on a 256 px grayscale copy of the photo:

Soft focus: the variance of the Laplacian (how strong the edges are). The blurred copy scores about 2. The sharp photos score from 11 to 240. Plain white bathrooms are the lowest, because tiles have few edges. I set the cut-off at 5 so a clean bathroom is never mistaken for a blurry one.
Too dark: mean brightness below 0.30.

A bug I only found by measuring. My first duplicate threshold was 0.93, tuned on the 8-bit model in Node. When I switched the browser to the fp16 model on WebGPU, two different angles of the same house front were set aside as "the same shot". Similarity scores move a little between quantizations. I measured the pairs on both versions of the model:

Pair	8-bit (CPU)	fp16 (GPU)
Two near-identical bathroom shots	0.966	0.977
Two angles of the house front	0.889	0.913
Two angles of the living room	0.913	0.888

Real duplicates sit above 0.96 and different angles stay below 0.92 on both. I moved the threshold to 0.95, and now both engines give the same result on the sample set.

Why Does Open Innovation Matter?

The photos are the inside of someone's home. Before a listing goes live, these photos show who lives where, what is inside, and where the cameras are not. An agent should not need to upload them to a third-party server to get them sorted. With open weights, the model comes to the photos instead. Walkthrough has no server at all, so there is nothing to leak.
The business only works if each photo costs nothing. A busy photographer sorts thousands of photos a month. A cloud vision API charges for every image, and every re-sort costs again. That pushes you toward per-listing pricing and makes you watch usage. With an open model on the customer's own machine, my cost per photo is zero. Hosting is a free static site, so a flat monthly price is safe.
It works on site. Photographers often sort in the car between shoots, sometimes with a weak signal. After the first download, Walkthrough works offline.
I control the rooms. Australian listings say "lounge", American ones say "family room", and a lake house needs "boat dock". With CLIP, that is a prompt change and one script run, not a feature request to a vendor. I can also swap in a stronger open model, such as SigLIP, by changing one constant, and nobody can change the price or retire the model under me.

Touch Grass Bingo - offline nature bingo checked by an AI that lives on your phone

Prateek singh — Fri, 09 Oct 2026 15:48:53 +0000

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

What I Built

Touch Grass Bingo is a nature bingo card that you play outside. You open it, get a seasonal card (a red leaf, an acorn, moss, a feather, a mushroom…), and put your phone away. When you find something, you take one photo. An open-weight vision model running on your phone checks it and marks the square.

The center square is never free. It is "Touch grass": a photo of your hand on real grass.

Who it is for:

Families who want a reason to make a walk last longer.
Run clubs and hiking groups. Everyone types the same card code (like FERN-42) and gets the same card. First to bingo wins. There are no accounts and no server.
Anyone doomscrolling who needs a nudge. If you photograph your monitor, the model detects a screen and tells you that you cannot touch grass through a monitor.

The screen is the shortest part of the game: one glance at the card, then the phone goes in the pocket until you find something.

Demo

Play it: https://prateekiiitg56.github.io/touch-grass-bingo/

Open it on your phone. Tap Download photo checker once on Wi-Fi (about 150 MB). After that, it works in airplane mode.

Play the same card as a friend: https://prateekiiitg56.github.io/touch-grass-bingo/?code=FERN-42

Code

Prateekiiitg56 / touch-grass-bingo

Offline nature bingo. Snap what you find outside; open-weight CLIP checks it on your phone. No signal, no uploads.

Touch Grass Bingo

Offline nature bingo for walks, hikes and run clubs. The app deals you a seasonal bingo card (a red leaf, an acorn, moss, a feather…). You go outside and take a photo only when you find a square. An open-weight AI model running on your phone checks the photo. No signal is needed and no photo leaves the device.

Open-weight model: CLIP ViT-B/32 (ONNX, 8-bit quantized)
Open-source runtime: Transformers.js 3.7.6 on ONNX Runtime Web (WASM)
No backend: static files only. Host on GitHub Pages, Netlify or any static host.

How it works

Field kit. On Wi-Fi, tap Download field kit. The model (about 150 MB) goes into the browser cache. A service worker caches the app shell and runtime. From then on the app works in airplane mode.
Deal a card. A card code (for example FERN-42) seeds a deterministic shuffle of the season's item…

View on GitHub

How I Built It

Model: CLIP ViT-B/32, open weights, ONNX export, 8-bit quantized (about 150 MB).
Runtime: Transformers.js on ONNX Runtime Web (WASM). Inference runs in the browser tab.
App: plain HTML, CSS and JavaScript modules. No framework, no build step, no backend. Hosted free on GitHub Pages.
Design: styled like a topographic map. Grid references (A1, B2…) run along the edge of the card, so a group can shout "got B2". A finished line is drawn as an orange trail-blaze route.
Offline: a service worker caches the app shell and runtime. Transformers.js caches the model weights in the browser. After a one-time download on Wi-Fi, the app works in airplane mode.

The core trick is zero-shot classification. Each bingo square is only a text prompt, for example "a photo of an acorn". When you take a photo, CLIP scores it against every item in the season's pool plus a set of distractors (a screen, an indoor room, a selfie, a document, a city street). On a laptop, one photo takes about 100 ms:

If the square you tapped wins, you found it.
If a different unfound square on your card wins clearly, the app marks that one as a bonus ("Not running water, but it is a mushroom").
If a seasonal item that is not on your card wins, you get "Good find, but it is not on this card."
If a distractor wins, the find does not count, and you get a hint.

My first version scored photos only against the squares on the card. In testing, a red maple leaf was marked as the "yellow leaf" square with 95% confidence, because it was the closest option. Scoring against the full season pool fixed this: the same photo now comes back as "red leaf, not on this card."

Group play uses a seeded shuffle: the card code, season and size feed a hash, which seeds a small PRNG that shuffles the season's item pool. Every phone with the same code deals the same card, with no network.

Why Does Open Innovation Matter?

It works where the grass is. Trails, parks and forests often have no signal. A closed vision API needs a network round trip for every photo. Open weights let the model live on the phone, so the game works in airplane mode.
Photos stay private. Families take photos of kids' hands, backyards and favorite spots. With an on-device model, no photo is uploaded to a server that the player does not control.
It costs nothing to run. No API key, no per-image bill, no rate limit. I can host it on GitHub Pages for free, and a whole run club can play without anyone paying.
It is easy to change. Because CLIP is zero-shot and open, a new square is one line of text. A teacher can make a "schoolyard" card, a birding club can make a "local birds" card, and anyone can swap in a different open model (for example SigLIP) by changing one constant.

Prize Categories

Best Use of Gemma
Using Gemma, Google's open-weight model, in building my project