DEV Community: Academic

I Stopped Deciding Dinner — a Sloth Does It Now (आज क्या बनाऊँ?)

Academic — Wed, 21 Oct 2026 16:19:17 +0000

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

What I Built

The question that ruins 6 PM every day is not "can I cook?" â€” it is "à¤†à¤œ à¤•à¥à¤¯à¤¾ à¤¬à¤¨à¤¾à¤Šà¤?" (what should I cook today?). Standing in front of an open fridge, recalculating the same inventory for the thousandth time, while hungry. That is decision fatigue, and it costs more energy than the cooking.

à¤†à¤œ à¤•à¥à¤¯à¤¾ à¤¬à¤¨à¤¾à¤Šà¤? (Aaj Kya Banau?) ends the ritual:

Tick your kitchen once. 52 common Indian-kitchen ingredients as checkboxes in four groups â€” atta, chawal, dals, sabzis, dahi, masale. The browser remembers it (Gradio BrowserState) â€” no account, no server-side storage, nothing leaves your device.
Say how lazy you feel â€” à¤•à¤® à¤®à¥‡à¤¹à¤¨à¤¤ caps suggestions at effort 2 out of 5.
Press one button. The first card is tonight's dinner. A deterministic matcher picks the top 3 from a 40-recipe open database, ranked by fewest missing items, then least effort, then least time.
"à¤à¤• à¤šà¥€à¤œà¤¼ à¤²à¥‡ à¤†à¤“" (bring just one thing) â€” nothing perfect in the kitchen? Instead of pretending, it shows what is one ingredient away: à¤¬à¤¸ à¤Ÿà¤®à¤¾à¤Ÿà¤° à¤²à¥‡ à¤†à¤“, à¤”à¤° à¤¸à¥ˆà¤‚à¤¡à¤µà¤¿à¤š à¤¬à¤¨ à¤œà¤¾à¤à¤—à¤¾.
Gemma only writes the mood. A short Hinglish verdict, a one-line pitch and chef tip per dish, and it parses your genuinely messy free text ("thoda basi chawal hai, aadha gobhi bhi") onto the ingredient vocabulary. It never chooses recipes and never invents ingredients â€” every id in its JSON output is clamped to the database shipped in the repo.
Model down does not mean dinner down. No API key, no network, rate-limited? The matcher still decides; pitches and tips fall back to the recipe database itself. The app works fully offline in mock mode.

Demo

Live app: https://aaj-kya-banau-rcaf.onrender.com/ (free tier â€” first load may take a minute to wake)

A real session from testing: with chawal, dahi, aloo, pyaz, tamatar and basics ticked, plus "thoda basi chawal hai, aadha gobhi bhi" typed in the free-text box, the app picked à¤¦à¤¹à¥€-à¤šà¤¾à¤µà¤² (5 minutes, zero shopping) as tonight's dinner, put à¤®à¤¸à¤¾à¤²à¤¾ à¤®à¥ˆà¤—à¥€ second â€” and, because "basi chawal" was parsed onto the vocabulary, à¤¬à¤¾à¤¸à¥€ à¤šà¤¾à¤µà¤² à¤à¥à¤¨à¤¾ (fried rice from yesterday's rice) appeared as card 3. The whole round trip, including Gemma's verdict and pitches, took 88 seconds on the free tier.

Code

Everything is on GitHub (MIT, recipes included): https://github.com/Yuser00123/aaj-kya-banau

File	Role
`kitchen.py`	52-ingredient vocabulary + the matcher (all decisions happen here)
`recipes.py`	the 40-recipe open database â€” plain, editable Python
`prompts.py`	Gemma's narrow job: the prompt, the clamp, the offline fallback
`llm.py`	provider adapter (any OpenAI-compatible endpoint, Ollama, or mock)
`app.py`	Gradio 6 UI, BrowserState persistence, `/health`, PWA

Adding your family's recipe is deliberately boring â€” no JSON, no schema, eight-ish lines of Python:

R("gobhi_paratha", "à¤—à¥‹à¤à¥€ à¤ªà¤°à¤¾à¤ à¤¾", "ðŸ«“", ["atta", "phool_gobhi"],
  ["pyaz", "adrak", "lasun", "namak", "tel"], 3, 40, True,
  ["Gobhi kaddukas karke namak laga ke 10 minute chhod do.",
   "Atta gundh ke parathe banao, bhigote bhar lo.",
   "Tawe par ghee ke saath sunhare ho tak seko."],
  "Sunday-feeling dinner, aaj hi bana lo.",
  "Kaddukas geela lage to kapde mein kas ke nikaal do â€” paratha phulega.")

verify() runs on import and refuses to start the app with a bad ingredient id â€” a PR that breaks the kitchen breaks the tests. The test suite is 45 offline checks (matcher rules, veg filter, effort caps, free-text parsing, prompt clamping, the /health endpoint) that need no API key and no network.

How I Built It

Before writing code I read the week's entries first â€” when I checked, the field was full of file sorters, inbox tidiers and chat digesters. Recipe deciders existed but generic, so the opening was: an Indian-kitchen ground truth (a fixed, realistic ingredient vocabulary) and an open recipe database anyone can extend. That is what the sloth sits on.

The central design decision: decisions in code, mood in the model.

The matcher is ~40 lines of pure Python: missing <= 0 means perfect, missing == 1 lands the dish in the one-away list, and a sort key of (missing, fits-sloth-level, effort, minutes) ranks everything else. If nothing fits today's laziness cap, it relaxes the bar and says so loudly instead of quietly returning nothing.
Free text gets a deterministic first pass â€” Hindi labels and Roman aliases, longest match first, with matched text consumed so "basi chawal" does not also fire "chawal" â€” and Gemma handles the truly messy rest.
Gemma makes one JSON call (verdict, per-recipe pitch/tip, parsed_extras, shopping_line) through Gemini's OpenAI-compatible endpoint. The response is then clamped: invented recipe ids are dropped, unknown ingredients are dropped, empty fields are filled from the database. The model can flavor the dinner; it cannot change what's for dinner.

An AI coding agent did most of the typing on this one â€” the ingredient vocabulary, the matcher rules, the recipe database format and the clamp logic were designed in conversation and I reviewed and tested everything (including catching that my first draft pointed à¤†à¤²à¥‚-à¤—à¥‹à¤à¥€ at cabbage instead of cauliflower â€” in most Indian kitchens that dish is à¤«à¥‚à¤²à¤—à¥‹à¤à¥€).

Deployment is a Render Blueprint from the repo (render.yaml): free web service, health check on /health, the Gemini key as the only secret.

Why Does Open Innovation Matter?

Because the interesting part of this app is not the model â€” it is the database. Forty everyday recipes in a plain Python file, MIT licensed, eight lines to add your mother's version, with a verifier that keeps contributions honest. A hundred families forking it and adding their own recipes is worth more than any prompt engineering I could do.

And because a small open-weight model, clamped to ids from an open repository, gives AI-flavored writing without AI-authored facts. Swap the endpoint to a local Ollama with one environment variable and the app never talks to a cloud at all â€” the sloth keeps deciding dinner either way.

Prize Categories

Render â€” deployed as a Blueprint (render.yaml), free web service, /health health check, sleeps and wakes like a proper sloth.
Gemma â€” Gemma writes the verdict, pitch and tips and parses messy kitchen notes; JSON mode, single call, output clamped to the open recipe database.

Arzi Likho (अर्ज़ी लिखो) — the ₹30 cyber-café application letter, drafted in formal Hindi by Gemma 4 in three minutes

Academic — Thu, 15 Oct 2026 09:23:51 +0000

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

What I Built

Walk into any cyber café or Jan Seva Kendra in small-town Uttar Pradesh and there is a typing counter, and the counter has a queue. A woman wants to know why her widow pension stopped in April. A student needs a bonafide certificate by Monday. Someone's electricity bill is four times what it was last month. Each of them pays ₹30–100 to have it typed as a formal Hindi application — सेवा में, विषय, महोदय, प्रार्थना, भवदीय — addressed to exactly the right office, because a letter to the wrong office goes nowhere.

The operator types these letters from memory, twenty a day, fifteen to twenty minutes each. The addressee is sometimes wrong (is a ration-card correction the जिला पूर्ति अधिकारी or the पूर्ति निरीक्षक?). The ₹10 RTI fee and the 30-day reply rule get quoted from memory. The customer stands there while Windows updates.

Arzi Likho (अर्ज़ी लिखो — "write the application") turns that into three minutes:

Pick the matter — twelve of them: RTI application and RTI first appeal, ration card, pension, electricity, police complaint, public grievance, certificates, school, bank, document correction, biodata. Pick the district — all 75 UP districts, Raebareli by default.
Fill five to ten plain-Hindi fields. Not "compose a letter" — just: who, where, what happened, what you want.
Out comes the full formal letter, plus a "कहाँ जमा करें" box — the office, the online portal (rtionline, jansunwai, edistrict, sspy…), the helpline (1912, 1076, 112, 1967, 1947), the fee, the time limit and the attachments checklist. Then: print, .docx download (cafés live in Word), an English version for offices that accept one, and a WhatsApp follow-up message with the reference number left blank for later.

Who would pay, and why: the operator — I'd charge about ₹199/month — because it turns a 20-minute error-prone typing job into a 3-minute one at the same ₹30–50 per customer, and the addressee, the act, the fee and the portal are never wrong, because they aren't typed from memory at all. To be honest about the "side hustle" part: I have not signed up a paying café yet. That's the next step, not this week's claim; this week was about proving the drafts are good enough to sell.

Demo

Live: https://arzi-likho.onrender.com/ — free Render instance, so the first load can take 30–60 s while it wakes. Then pick a matter, fill the form, and Gemma 4 writes the letter in 30–90 s (the status line tells the customer so honestly).

The 12 matters	The form	Writing…	The letter

(The "कहाँ जमा करें" box on its own: 5-kahan.png.)

What the letters actually looked like when I ran four real-shaped cases against the live app:

RTI against the electricity department (46 s). My two rough points came back as proper numbered prose: "वांछित सूचनाएं इस प्रकार हैं: 1. पिछले वित्त वर्ष में मेरे खाते में जमा कुल बिल राशि का विवरण। 2. गलत बिल वसूली के संबंध में जारी किए गए आदेश की प्रति।"
Police complaint, woman applicant (83 s): "रात्रि लगभग 8 बजे, जब मैं घर से सब्ज़ी लेने गई थी और वापस लौट रही थी, तब गाँव के पश्चिमी छोर पर खेत के पास दो अज्ञात युवकों ने मेरा रास्ता रोक लिया।" — the feminine गई थी / रही हूँ holds through the whole letter, because gender is a form field, not a guess. The पुलिस अधीक्षक gets a प्रतिलिपि line, as a police complaint should.
Village grievance (30 s): routed to the खंड विकास अधिकारी (city cases go to the नगर पालिका instead). I hadn't typed the block name, so the letter reads "विकास खंड — [खंड का नाम]". That bracket is the feature I'm proudest of: a missing fact stays a visible blank; it is never invented.
Widow pension, stalled installments (41 s), closing line: "अतः प्रार्थना है कि कृपया मेरी पेंशन की रुकी हुई किश्तों की जांच कर उनका भुगतान जल्द से जल्द कराने की कृपा करें।"

The same call returns a formal English version of the letter, and a WhatsApp follow-up the operator can paste when the customer comes back asking what happened.

Code

https://github.com/Yuser00123/arzi-likho — MIT. Python 3.12, Gradio 6 on FastAPI, one render.yaml, ten offline tests (python test_app.py — no key, no network, LLM_PROVIDER=mock). The file that matters most is forms.py: twelve matters × (fields, addressee, act/section, fee, time limit, portals, attachments) × 75 districts, as plain editable Python.

How I Built It

Picking the hustle before building it. Before writing code, I read the week's other 186 submissions. Receipt/invoice sorters: seventeen and counting. Etsy/eBay listing writers: eleven. "Scope-creep shields" for freelancers: a whole genre. Nobody was doing Indian government paperwork, in Hindi, for the counter that actually types it — so that's the lane. A cyber café is the rare customer you can name, walk to, and watch paying ₹30 in cash for the exact artefact the tool produces.

The design decision everything hangs on: templates write the letter, the model writes the sentences.

Part of the letter	Who writes it
Addressee — जिला पूर्ति अधिकारी? अधिशासी अभियंता? थानाध्यक्ष?	`forms.py` template
Act & section (RTI §6(1), §19(1), CrPC §154), fee (₹10), 30-day limit	`forms.py`
Portals and helplines in the कहाँ जमा करें box	`forms.py`
Skeleton — date, सेवा में block, विषय, salutation, प्रार्थना, signature, संलग्नक	`letter.py`
The narrative — what happened, since when, what is wanted	Gemma 4
English version + WhatsApp follow-up	Gemma 4

Gemma never chooses an office, never quotes a fee, never cites a section. Its job is the part that is actually writing: turning "पेंशन अप्रैल से बंद है, बैंक बोला विभाग से पूछो" into two dignified paragraphs of सरकारी हिंदी. The system prompt's hardest rules: use only the facts in the form; a blank becomes a [कोष्ठक] placeholder, never an invention; no legal advice, no threats, no promises; the request line starts with कृपया because the app supplies the "अतः प्रार्थना है कि" itself.

Testing the model like code. I drove the deployed app through its own API (gradio_client) instead of eyeballing screenshots, and asserted on the letters. That's how I caught my favourite bug of the week: every letter's closing line read "अतः प्रार्थना है कि अतः आपसे विनम्र निवेदन है कि…" — my template's prefix and Gemma's own prefix, doubled. Fixed three ways: a prompt rule, a sanitizer that strips leading connectives no matter who added them, and a cleaner subject template for police complaints. The same API pass confirmed the feminine grammar, the village/city addressee routing and the 30–83 s timings.

Keeping the counter alive when the model isn't. The model's JSON is clamped to a schema: a partial response gets its missing parts filled from deterministic templates, and if the API is down entirely, the whole letter still comes out in mock mode — the counter must never stall in front of a paying customer. Ten offline tests exercise all twelve matters this way, including "no [ left when the form is complete" and "every portal lands in the कहाँ जमा करें box."

The UI is one fixed pool. Twelve matters have different fields, but instead of dynamic component creation the app relabels and shows/hides a fixed pool of seventeen inputs — the matter switch is instant, nothing jumps. The letter itself is a plain editable textbox: the operator fixes a name or adds a line before printing (the print stylesheet prints only the letter), and the .docx is regenerated from whatever they edited. Drafts live in gr.BrowserState — in the browser, not on the server: an Aadhaar number in a police complaint should not be in anyone's logs, including mine.

Where I didn't start from zero: llm.py is the engine I built for my Week 1 project, Pakshi Padosi — streaming-safe <thought> stripping for Gemma 4, retries with a time budget, and one wrapper that runs the same model on Google's free tier or on a café's own PC with two environment variables. Reusing it is the open-source way of having a weekend.

Full disclosure, same as last week: an AI coding agent did most of the typing on this project. The template data, the prompt rules, the Hindi register calls — and the mistakes — are mine.

Why Does Open Innovation Matter?

The data on the counter isn't the user's — it's their customers'. Ration-card numbers, pension files, a widow's bank details, a police complaint about a threat. My demo runs on Render with the Gemini API's free tier because that is what I can host for ₹0 — but the same code, pointed at Ollama (LLM_BASE_URL=http://localhost:11434/v1), runs entirely on the café's own PC with no internet and no third party. That's not a checkbox; it's the difference between a tool a café can put on its counter and one it shouldn't.

The maths needs open weights. A ₹30 application cannot carry per-token API costs plus a subscription and still leave the café a margin. Open weights run on hardware that already exists, at ₹0 per page.

The network is worse than you think. Village CSCs run on patchy 4G. The model doesn't need the internet — only the government e-portals do, and the box tells you which ones.

The templates are the product, and they're editable. A Raebareli operator can open forms.py, add their tehsil's office or correct a fee, and the app updates. No vendor ticket, no lock-in — and when a better Hindi model ships next year, it's two environment variables, not a migration.

The register is the moat. Closed general-purpose APIs drift into Hinglish or translate English letter structure literally. Here the सरकारी register is pinned by templates and the open model writes within it — and when an output is wrong I can see exactly which rule to fix: a prompt, a template, a sanitizer. You can't do that with a black box standing between a customer and their ration card.

Prize Categories

Best Use of Gemma — gemma-4-31b-it writes every letter's narrative, request line, English version and WhatsApp follow-up from field-notes-only prompts with [placeholder] discipline; the write-up covers thought-stripping, retry budgets, the schema clamp and the mock fallback that keeps the counter alive when the API is down.
Best Use of Render — deployed from render.yaml on the free plan with a /health check; the fix-test-fix loop during live API testing (two same-day pushes, each live in about two minutes) is exactly what a one-person side hustle needs from a platform.

Built in Raebareli, Uttar Pradesh, 14–15 October 2026, mostly after dark.

Pakshi Padosi — a 60-second Hinglish card of the birds that are actually outside your door this week (GBIF Gemma 4)

Academic — Fri, 09 Oct 2026 12:34:35 +0000

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

What I Built

Pakshi Padosi ("bird neighbour") is a small web app that answers one question in Hinglish: which birds are actually around me this week, and how do I recognise them with my own eyes?

You give it a town (or press GPS) and how many minutes you have. In about a second it shows the data: how many bird records exist within 25â€“50 km of you for this time of year â€” from GBIF, which means eBird and iNaturalist observations logged by real people â€” and which six species you should look for: three padosi that are always here, three mehmaan that are migrating in right now. Then Gemma 4 writes each bird a 60-second Hinglish card: size compared to a sparrow or a myna, the two most diagnostic field marks, where to stand, what it sounds like, and a one-line hook you'll actually remember ("Kaala bird jiski laal pooch thartharati hai" â€” Black Redstart).

Then it tells you to put the phone in your pocket. That is the whole design:

The screen is the shortest part. Read the card once (or print it â€” the print stylesheet strips the UI), then walk. No camera, no mic, no live identification. The app does nothing useful while you are outside, on purpose.
Come back, tick, done. The Bahar tab is a six-box checklist plus one optional line of notes. Gemma turns the ticks into a two-line diary entry, and you can export the diary as Markdown or an eBird-style CSV. The diary lives only in your browser; your location goes to the open APIs that need it and nowhere else.
Grounded, not generated. Gemma never chooses the birds. The species list, the resident/visitor status, the record counts, the hotspots and the sunrise window all come from data; the model only writes the descriptions, and every card shows the numbers behind it ("24 records Â· 8 within 25 km").

Who it's for: people like me in small towns â€” I'm in Raebareli, Uttar Pradesh, a city of about 200,000 with no birding club that I know of and no field guide in the language people actually speak here. Anyone who has heard a bird on the way to work and wondered what it was, and whose comfortable language is Hinglish rather than field-guide English. It works for any place GBIF has data for â€” Delhi, Mumbai, Chennai and Bharatpur all give sensible cards â€” but it was built on Raebareli's data.

Demo

Live: https://pakshi-padosi.onrender.com/ â€” free Render instance, so the first load can take ~30 s while it wakes up. The Raebareli card is instant; type your own town and Gemma writes the card bird by bird, usually inside 90 seconds.

Home	The card	Back from the walk

What the card said for Thursday morning in Raebareli: window 6:10â€“6:50 AM (first hour after sunrise), 60 species recorded within 50 km this season, and "Indira Gandhi Smarak Vanaspati Udyan (3.1 km) sabse paas hai" â€” a park three kilometres from my house that I had never once thought of as a birding place. The app found it by clustering where other people's October records actually came from.

And the walk? I haven't done it. I spent the mornings this week fixing the things below instead of standing next to a pond, and I'm not going to invent a field report in a post whose whole argument is that the app should never pretend. What was tested: the live server, on a phone-sized browser, repeatedly â€” the Raebareli card in about 10 seconds, other towns filling in bird by bird from 35 seconds, and the data side checked against five cities. The app's job ends at the gate. Mine starts there, and that part is still owed.

Code

https://github.com/Yuser00123/pakshi-padosi â€” MIT. Python 3.12, Gradio 6 on FastAPI, one render.yaml. Runs locally with LLM_PROVIDER=mock and no keys at all, or against Ollama with LLM_BASE_URL=http://localhost:11434/v1.

How I Built It

Data first, model second. GBIF's occurrence API is free and needs no key. For a point, I facet bird records by species within 25 km â†’ 50 km â†’ 100 km until there are at least a thousand records for the Â±1-month season window (Raebareli needed 50 km: 1,177 seasonal records, 60 species, almost all from eBird). Four more faceted queries give each species' records per season, and that becomes a status: a resident keeps a fair share of its records in every season; a winter visitor vanishes in the monsoon.

That classifier bit me twice, and fixing it was the most interesting hour of the build. First, a resident White-browed Wagtail came out as a "winter visitor" because it had one monsoon record out of 26 â€” so small samples now need a clean zero in the off-season. Second, when I tried Bharatpur, home of Keoladeo, 25 of 60 species were "winter visitors", including the Painted Stork that breeds there. The data wasn't lying; the birders only go in winter. So every species is now compared against all bird records in the same circle, season by season â€” an effort correction. Bharatpur went from 25 false visitors to 1 (a real one, the Lesser Whitethroat). Raebareli's card ends up with three true winter visitors â€” White Wagtail, Black Redstart, Common Sandpiper â€” and three genuine neighbours.

Hotspots are not a lookup table: the app pulls 300 recent seasonal records with coordinates, buckets them on a 2 km grid and names each bucket by its most common locality string. The window comes from Open-Meteo (sunrise, rain, AQI â†’ "first hour after sunrise; smog â€” short walk"), with plain NOAA sunrise maths as the fallback. Hindi names are the honest weak spot: GBIF has no Hindi vernaculars, and Wikidata's Hindi labels are often English typed in Devanagari ("à¤±à¥‡à¤¦-à¤µà¤¤à¥à¤¤à¥à¤²à¥‡à¤¦ à¤²à¤ªà¥à¤µà¤¿à¤™à¥") or wrong (it calls the Common Sandpiper a kind of lapwing). So a curated list of folk names comes first, Wikidata second, and the card says "Hindi naam pakka nahi" when neither is trustworthy. Lying about a bird's name to look complete is exactly what this app must not do.

Gemma 4 (gemma-4-31b-it, open weights, through the Gemini API's free tier) writes only what needs writing. It gets our six species with their status and record counts as input and returns strict JSON per bird; the card's header lines are templates filled from the data, so there is nothing to hallucinate there. Three things I learned about it:

Through the OpenAI-compatible endpoint it reasons inline inside <thought>â€¦</thought> tags before answering. The client strips them (streaming-safe) and retries when the thinking eats the whole token budget.
My first version asked for the whole card in one call. It worked â€” and took 194 seconds on the live server, and a single 500 lost everything. Now each bird is its own small call, six run in parallel, and the page fills in bird by bird (first one in ~35 s). A bird that still fails after its budget is shown with just its name and status from the data, plus a "press again" note: the finished ones are cached, so the second press only writes the missing ones.
The endpoint throws intermittent 500s in batches. So the descriptions Gemma wrote for Raebareli's six birds during the first live runs ship with the repo as a seed cache â€” the demo town's card is instant and survives a bad API hour. Everything else is generated live, and GET /cache dumps what the instance has written if you want to grow the seed. (One field mark in that seed was corrected by hand after checking a guide; the file says which.)

Render runs it from a Blueprint (render.yaml, free plan, /health check). Free hosts share outbound IPs, and both Open-Meteo and OSM's Nominatim refused that IP within the first hour â€” fine from my laptop, "map par nahi mila" in production. So geocoding falls back to Photon and then to a built-in table of Indian cities, the default town needs no geocoder at all, and the weather falls back to computed sunrise with a visible note ("mausam service abhi busy"). None of that is glamorous; all of it is what makes the card show up on a phone at 6 AM.

Tooling: Gradio 6 with BrowserState for the diary, a print stylesheet, PWA manifest, Playwright for the screenshots, six offline tests with recorded fixtures (LLM_PROVIDER=mock). I paired with an AI coding agent for most of the typing; the design, the data decisions and the Hindi name curation are mine, and so are the mistakes.

Why Does Open Innovation Matter?

Nothing in this app is mine except the glue, and that is the point. The bird list is thousands of people's morning walks, logged into eBird and iNaturalist and published through GBIF under open licences. The map is OpenStreetMap. The weather is Open-Meteo. The Hindi names are Wikidata, with my corrections going back as the next edit. The language model is open weights â€” swap LLM_BASE_URL to Ollama and the same Hinglish bird cards come out of a laptop in Raebareli with no account anywhere, which is where I want this to end up: a district school running it on one old machine.

Open data is also what lets the app be honest. A closed "AI bird guide" says "you may see a Black Redstart"; this one says "9 records in this window, 3 within 25 km, zero in the monsoon" â€” and when the data is thin it says that too, in the same font size. When the classifier mislabelled a wagtail I could see exactly which 26 records did it and fix the rule in ten lines; when Wikidata's Hindi was wrong I could see it was a bot transliteration and route around it. You cannot debug a black box with a field guide in your other hand.

And open models change who gets to be for whom. Field guides for India are written in English for people who already own binoculars. A 31-billion-parameter model that anyone can run, fed a species list from a public API, will patiently write "Maina se thoda chhota, cheeks par red patch" for a town of 200,000 that no publisher will ever target. That is not a smaller version of the English product. It is a different product, and only open pieces make it buildable in three evenings by one person.

My Agent Session (optional)

(skipped)

Prize Categories

Best Use of Gemma â€” gemma-4-31b-it writes every bird description and diary entry from a data-grounded prompt; the write-up documents thought-stripping, per-bird parallel calls, the retry budget and the seed cache that made a slow free-tier endpoint usable on a phone.
Best Use of Render â€” deployed from render.yaml on the free plan with a health check, plus the production lessons about shared-IP refusals and the fallbacks that fixed them.

Built in Raebareli, Uttar Pradesh, 6â€“8 October 2026, mostly after dark.

Samjhao — I built my friend a Hinglish study buddy on open-weight Gemma

Academic — Sat, 03 Oct 2026 09:46:47 +0000

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

What I Built

Around midnight, my phone buzzes. It's Suyash â€” a screenshot of a textbook page and three words: "yeh kya bol raha hai?" ("what is this even saying?").

Suyash is my closest friend, and he's preparing for JEE here in Prayagraj. Everything he studies from â€” NCERT, coaching modules, previous-year solutions â€” is in English. He thinks in Hindi. The problem isn't vocabulary; he can read every word. The problem is register: a textbook explains like a textbook, and Suyash understands when a friend explains. For months, that friend has been me, at midnight, re-typing paragraphs in Hinglish with a chai analogy thrown in.

So I built Samjhao (à¤¸à¤®à¤à¤¾à¤“ â€” "explain it to me"): a small web app that does what I do at midnight, without me.

Paste a paragraph, a PDF page, or just a topic name â€” "Le Chatelier's principle" is enough.
Pick a depth â€” Bilkul basic, Exam ke liye, or Deep dive â€” and a language â€” Hinglish, Hindi, or English.
It explains the way Suyash actually talks, pulls out the key terms (English â†’ Hindi), gives three memory hooks, and ends with one realistic exam question with a model answer. Formulas render properly, because JEE Physics without Â½mvÂ² is just vibes.
Quiz banao turns the same material into five MCQs and scores them, with a why under each â€” because JEE is MCQs, and the wrong answer you don't understand is the one you'll repeat.
Everything goes into a Doubt Diary. Wrong answers become weak points; one tap builds a revision test that targets exactly those.

I showed it to Suyash as soon as it ran, with his name in the title bar â€” Suyash ka padhai saathi. He was shocked. Not polite-shocked; actually shocked that the paragraphs he'd been sending me had turned into a real app built around how he learns.

Demo

ðŸ”— Live app: https://samjhao.onrender.com â€” a free Render instance, so give it ~40 seconds to wake up. Paste any paragraph from NCERT and press Samjhao ðŸ™. Gemma 4 thinks before it answers, so the first explanation takes 30â€“60 seconds; the app shows a "ðŸ¤” Gemma soch raha haiâ€¦ 23s" timer while you wait.

Here's the work-energy theorem, pasted straight from a Physics textbook, explained Exam ke liye in Hinglish â€” definition, exam-ready points, key terms, a UPI-transaction memory hook, and one exam question:

One tap on Quiz banao turns that same paragraph into five MCQs. I deliberately got two wrong â€” every answer gets a âœ…/âŒ and a one-line why:

And the Doubt Diary remembers it: the two wrong answers are now weak points, one button builds a revision test from them, and the whole thing downloads as Markdown or JSON (nothing is stored on a server):

Code

Yuser00123 / samjhao

Samjhao (समझाओ) — a Hinglish study buddy built for my friend Suyash's JEE prep, powered by open-weight Gemma. Paste a paragraph → friend-style explanation, quiz, Doubt Diary. Hacktoberfest 2026 Weekend Challenge: Build for a Friend.

📚 Samjhao (समझाओ) — a Hinglish study buddy, built for one friend

Paste a paragraph from the textbook (or a PDF page, or just a topic name) → get it explained the way a smart friend would, in Hinglish, with key terms, memory hooks and an exam question → take a 5-question quiz → everything you struggled with lands in a Doubt Diary that turns into a weekly revision test.

Built for Hacktoberfest 2026 · DEV Weekend Challenge: Build for a Friend, with an open-weight model (Gemma) at its core.

Why open-weight matters here

Need of a student in a UP hostel	What open weights make possible
No money	Gemma 4 is free on Google AI Studio (no card). Zero running cost.
Hostel wifi dies	Same app, `LLM_BASE_URL=http://localhost:11434/v1` → Gemma 3 4B via Ollama, fully offline on a CPU laptop.
Their notes are theirs	Nothing is stored server-side.

…

View on GitHub

MIT licensed. The repo was created and finished inside the challenge window. The README has a five-command quickstart, the three screenshots above, and an offline mode.

How I Built It

The open-source AI at the core is Gemma 4 (gemma-4-31b-it), Google's Apache-2.0 open-weight model, served through Google AI Studio's free tier. It does everything: the explanation, the quiz (as strict JSON), and the revision test. There is no closed model anywhere in the code â€” not even as a fallback.

Around it: Python, Gradio 6 mounted on FastAPI (UI plus a /health endpoint that Render pings; it ships as a PWA so it installs on a phone), the openai SDK pointed at an OpenAI-compatible endpoint, pypdf, and Render's free tier (Singapore region) for hosting.

The piece I'm proudest of is llm.py â€” a few hundred lines that know nothing about Google. It talks to any OpenAI-compatible endpoint, so the same Gemma family runs three ways with two environment variables:

# Google AI Studio â€” free, cloud
LLM_BASE_URL=https://generativelanguage.googleapis.com/v1beta/openai/
LLM_MODEL=gemma-4-31b-it

# Ollama â€” same app, no internet, CPU laptop
LLM_BASE_URL=http://localhost:11434/v1
LLM_MODEL=gemma3:4b

It also absorbs the real-world mess: if a provider rejects the system role, the prompt is folded into the first user turn and retried; if it lacks response_format, a lenient JSON parser takes over; a 429 gets a polite retry and a Hinglish "Gemma thoda busy hai" instead of a stack trace.

The bug that taught me the most: Gemma 4 thinks out loud. The first time the deployed app answered, the explanation began with <thought>Ohm's Law. Suyash wantsâ€¦</thought>. Gemma 4 is a reasoning model, and Google's OpenAI-compatible endpoint streams its chain of thought inline, as ordinary text. So llm.py grew a streaming-safe filter that removes <thought>â€¦</thought> blocks even when a tag is split across two chunks, and the UI shows the soch raha hai timer until the first visible line arrives. The same afternoon the endpoint threw a few 500 Internal errors, and once the model spent its entire token budget thinking and returned nothing â€” both now retry automatically, and if all three attempts fail Suyash gets a Hinglish sentence, not a traceback. None of this is Gemma's fault; it's the price of using a reasoning model through a compatibility layer, and the fix is about eighty lines anyone can lift.

The persona is a prompt, not a fine-tune. Forty lines in prompts.py encode how Suyash likes things explained: Roman-script Hinglish "the way two friends chat on WhatsApp", technical terms kept in English with the Hindi meaning in brackets the first time, analogies from chai/cricket/trains/UPI only when they genuinely help, exam-precise definitions â€” and "if the material is garbled or isn't study material, say so; don't invent." The three depth levels change the word budget and structure, never the voice. (The UPI analogy in the screenshot? Gemma's own idea. The prompt just allowed it.)

The quiz is structured output. Gemma returns {"topic", "questions": [{"q", "options"[4], "answer_index", "why"}]}; the app validates every question (exactly four options, one valid index) and drops anything malformed rather than show a broken quiz. Wrong answers are stored as weak points, and the revision prompt is told to rephrase them, not repeat them.

The Doubt Diary is deliberately boring: a list in the browser session with JSON export/import. No accounts, no database, nothing stored on a server. For a tool used by one person, that's a feature.

Why Does Open Innovation Matter?

I could have built this on a closed API in the same weekend. Here's what would have been worse, concretely:

It would cost money, and a JEE aspirant has none to spare. Gemma 4 on AI Studio's free tier needs no card. Suyash can run this every night until the exam for â‚¹0. The moment a study tool has a monthly bill, it stops being used.
Internet is not a given at midnight. Data packs run out; wifi drops. Because the weights are open, the same code can point at Ollama with gemma3:4b on a laptop â€” no internet, no account, no key. It's the same OpenAI-compatible protocol, so it's two environment variables, documented in the README. A closed API cannot do this, by definition.
Suyash's doubts are his business. The only thing that leaves the device is the pasted text, and it goes to a provider we choose â€” including our own machine. No vendor is building a profile of what a JEE aspirant struggles with the night before a test.
The model can't be taken away. Closed models get deprecated, re-priced, or geo-restricted. Apache-2.0 weights don't. If the free tier changes tomorrow, I change one URL. If Suyash ever wants Samjhao to know his exact syllabus, the weights can be fine-tuned â€” that path exists because the model is open.
Hinglish is a first-class citizen. I was genuinely surprised how well Gemma handles Roman-script Hindi + English code-switching with precise technical terms â€” look at "gatij urja" next to kinetic energy in the screenshot. With open weights, that's an advantage I get to keep.

The honest counterpoint: free-tier rate limits are real (~15 requests a minute), and a 31B reasoning model served remotely takes 30â€“60 seconds per explanation. For one student at midnight, neither matters â€” and when it does, the open weights mean the fix is a smaller Gemma on his own laptop, not a bigger bill.

Prize Categories

Best Use of Gemma â€” Gemma 4 (gemma-4-31b-it) is the only model in the project: explanation, quiz JSON, and revision test; swappable to Gemma 3 via Ollama for offline use.
Best Use of Render â€” deployed as a free Render web service from render.yaml (Blueprint), Singapore region, with /health as the health-check path; the app reads PORT and ships as a PWA.

Built solo.

"The Internet Didn’t Need This… So I Built It Anyway"

Academic — Thu, 09 Apr 2026 06:53:33 +0000

This is a submission for the DEV April Fools Challenge

What I Built

I built the Useless Button Generator — a chaotic website where every click creates more buttons, plays a click sound, and roasts you for your terrible decisions.

It tracks how many times users keep clicking (despite knowing it’s useless) and occasionally throws in random chaos like fake rewards or wiping the screen.

It solves nothing.
It wastes time.
And you will click again 😈

Demo

Click here if you’re ready to make bad decisions

Code

Curious how this terrible idea works?
Go ahead, make another bad decision:
Click here to see the code

How I Built It

I built this masterpiece of bad decisions using HTML, CSS, JavaScript, and PHP.

HTML for the structure (aka where poor choices begin).
CSS to make everything look slightly chaotic and suspicious.
JavaScript to generate infinite buttons, play sounds, and roast users in real-time.
PHP to track and store the total number of bad decisions (clicks) globally.

The frontend handles the chaos, while the backend quietly judges everyone.

Prize Category

I am submitting it for winning a surprise teapot or coffee maker with appropriate fixings.