DEV Community: Naushad Alam

Candela: a local Gemma ofrenda that refuses to invent memories

Naushad Alam — Sat, 31 Oct 2026 13:51:08 +0000

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

What I Built

Candela is a private digital ofrenda. You bring a name, foods, songs, and short true stories. Gemma 3 4B, running through Ollama on your machine, writes a remembrance and a list of offerings. A source invent-check rejects drafts that invent details that were never in your notes, then asks the model once more. If the second draft still invents, Candela refuses to light the altar.

The people it is for are the ones whose memories should not become training data.

Demo

Local only, on purpose. With Ollama running and gemma3:4b pulled:

npm start

Open http://127.0.0.1:8790 and load the sample. The altar stays on loopback. History is a gitignored JSON file.

Code

https://github.com/nashdev97/candela

nashdev97 / candela

Local Gemma ofrenda that refuses to invent memories (HF26 Week 4)

Candela

A private digital ofrenda for Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

You bring a name, foods, songs, and short true stories. Gemma 3 4B runs through Ollama on localhost, writes a remembrance, and Candela rejects drafts that invent details that were never in your notes.

Why this exists

Family memory is not a chatbot prompt. A hosted model would take the most private text you have. Candela binds to loopback, keeps history in a local JSON file, and treats invention as a bug.

Requirements

Node 22+
Ollama running locally
Model: gemma3:4b (default)

ollama pull gemma3:4b

Run

npm start

Open http://127.0.0.1:8790

Optional env:

OLLAMA_HOST (default http://127.0.0.1:11434)
OLLAMA_MODEL (default gemma3:4b)
PORT (default 8790)

Verify

npm test
npm run smoke

smoke calls the real local model with the sample abuela notes.

Architecture

flowchart LR

  browser[Browser on localhost]

  api[Node HTTP API]

  guard[Source invent-check]

  ollama[Ollama]

…

View on GitHub

How I Built It

flowchart LR
  browser[Browser on localhost]
  api[Node HTTP API]
  guard[Source invent-check]
  ollama[Ollama]
  gemma[Gemma 3 4B]
  disk[data/history.json]
  browser -->|POST /api/remember| api
  api --> ollama
  ollama --> gemma
  gemma --> api
  api --> guard
  guard --> disk
  api --> browser

Node serves one page and talks to Ollama at 127.0.0.1:11434. The model must return JSON with the remembrance, the exact foods/songs/stories it used, offerings, and a spoken line. Candela checks that those lists are subsets of your notes, that the prose names the person, and that the remembrance touches a concrete fact from the notes. If a draft invents a food or song you never wrote, Candela retries once, then refuses.

Why Does Open Innovation Matter?

An ofrenda is private. A hosted chat API would mean sending the softest facts you have about someone you love to a log you do not control. Gemma's weights are open, Ollama runs them on the laptop, and the server binds to loopback. There is no per-token bill for lighting a candle twice. When the model invents, the invent-check is code you can read, not a privacy policy.

Prize Categories

Best Use of Gemma

Leave It: a local Gemma that tells you what not to do

Naushad Alam — Sun, 25 Oct 2026 09:52:40 +0000

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

What I Built

Leave It is a local web app for the guilt pile: unreplied chats, a renewal, a folder you meant to tidy. You paste one item per line. Gemma 3 4B, running through Ollama on your machine, marks each line leave, two minutes, or later, and writes the two-minute step when silence would cost you.

The person who gets to be lazier is you. Likes and optional tidying are supposed to be left alone. An expired domain is not. Lines marked later do not count as time saved, because you still owe them.

Demo

Local only, on purpose. With Ollama running and gemma3:4b pulled:

npm start

Open http://127.0.0.1:8787 and use the sample pile. A four-line sort took about three minutes on the machine this was built on. There is no hosted demo. The page is a lined list, and an earlier pile reopens without another sort.

Code

https://github.com/nashdev97/leave-it

How I Built It

flowchart LR
  browser[Browser on localhost]
  api[Node HTTP API]
  guard[Urgent-word guardrail]
  ollama[Ollama]
  gemma[Gemma 3 4B]
  disk[data/history.json]
  browser -->|POST /api/decide| api
  api --> ollama
  ollama --> gemma
  gemma --> api
  api --> guard
  guard --> disk
  api --> browser

Node 22 serves a single page and talks to Ollama at 127.0.0.1:11434. The open-weight model is Gemma 3 4B (gemma3:4b). The request sends a JSON schema with minItems and maxItems equal to the number of lines, so constrained decoding has to return one object per line. A 1B Gemma mostly copied the line back as the reason, so the default is the 4B tag.

After the model answers, the app rejects a reason that is just the line copied verbatim, and it rejects a two-minute move that is a single word. If that happens it asks the model once more. A separate guardrail can only make a verdict stricter: words such as expired, overdue, invoice, landlord, and leak promote leave or later to two_minute. It cannot mark an urgent line as safe.

History is a gitignored JSON file, last 50 runs. No account, no database server, no hosted model.

Verified twice with gemma3:4b. The script sample deferred Saturday dinner, likes, and the downloads folder, and the guardrail turned the expired domain into a two-minute renewal. The browser sample added "Send the landlord the leak photo from Tuesday". That run still marked the leak later, because the guardrail did not know landlord or leak yet. Those two words are in the guardrail now. Ten unit and server tests passed after that change. Sort the sample again to see the leak promoted.

Why Does Open Innovation Matter?

The pile is personal. A hosted chat API would mean sending unreplied messages and renewals to someone else's log. Gemma's weights are open, Ollama runs them on the laptop, and the server binds to loopback. There is no per-token bill, so leaving a pile unsorted until you feel like it does not cost money. The 1B and 4B tags are swappable with one environment variable when a smaller model starts echoing instructions, which is exactly what the 1B tag did here.

The Lazy Payoff

On the sample pile the 4B model deferred three of four lines and the guardrail kept the expired domain from being ignored. Later does not count as minutes saved, and the model estimated the careful version of the domain at one minute, so the minute counter stayed at 0. The lazy payoff on that run is three things you are not doing now, plus one renewal you cannot pretend to forget. A four-line sort took about three minutes, which is still less than rereading the same list all week.

Prize Categories

Best Use of Gemma

NightPrep: the prep sheet a taco truck would pay for

Naushad Alam — Sun, 18 Oct 2026 12:44:22 +0000

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

What I built

NightPrep is a nightly prep sheet for an independent food truck. The owner types the stop, the temperature, whether rain is coming, and a note ("soccer lets out at 8"). The app returns how many of each item to cook, the closest past night, and a sidewalk sign.

A truck owner would pay for this. Over-prepping carnitas is trash. Under-prepping al pastor is a line of people who leave. The number has to come from their own nights, not a chatbot guess.

Who it is for

One truck, one neighborhood, one service window. The sample history is 48 nights of a taco truck in East Cesar Chavez. Dry nights prep about 64 al pastor. Rain nights drop that to 44.

How it works

A Mastra workflow, night-prep, runs the same steps every time:

Forecast units from the sales table.
Find a similar past night.
Look up events near the stop.
Write the sign and the story caption.
Save the run.
Hand the save to a Temporal workflow so a blip retries.

TabPFN-3.5 is the forecast when PRIOR_API_KEY is set. Without it, the app uses the mean of matching history and labels the chip history-mean. It does not pretend the mean is TabPFN.

Gemma writes the sign. Ollama is tried first, so the note can stay on the laptop. Google AI Studio (gemma-4-26b-a4b-it) is the fallback. The request asks for JSON with sign and story. If that parse fails, the sheet keeps the template and the chip says template, not gemma-google.

Similar nights go to Tiger Data with pgvector plus a keyword filter. SerpApi supplies nearby events. MongoDB stores the run. ElevenLabs speaks the cook brief when the key is valid. Sentry wraps each step in a span.

Why open innovation matters

The useful part of this business is the truck's own sales and the owner's note about who is nearby. A closed chat API would bill them every night and hold the recipe margins. Gemma is an open weight, so the copy step can run on the laptop and can be swapped without rewriting the workflow. TabPFN fits the small sales table directly. A general model would invent a plausible number. The table already knows.

Demo

Live: [nightprep-jxms.onrender.com]

nightprep-jxms.onrender.com

Repo: [github.com/nashdev97/nightprep]

nashdev97 / nightprep

Nightly prep sheet for an independent food truck. Gemma writes the sign. TabPFN forecasts the cook counts.

NightPrep

Prep sheet for an independent food truck. The owner enters tonight's stop. The app forecasts how many of each item to cook, finds a similar past night, and writes the sidewalk sign.

Open-weight Gemma writes the copy, so recipe notes and margins do not have to go through a closed chat model. TabPFN-3.5 forecasts units from the truck's own sales table. A general chatbot guesses. This fits the history.

Flow

Forecast units (TabPFN-3.5, or a history mean when no key is set).
Hybrid search for a similar night (Tiger Data pgvector, or a local seed).
Live event search (SerpApi).
Sign and story (Gemma via Ollama, or Gemma on Google AI Studio).
Save the run (MongoDB Atlas).
Durable retry of the save and index (Temporal).
Spoken cook brief (ElevenLabs).
Spans on each step (Sentry).

Mastra runs that sequence as the night-prep workflow. A Mastra agent with the same tools is…

View on GitHub

A sheet on the live host (Austin, East Cesar Chavez, 78F, soccer note) returned:

forecast: tabpfn-3.5
similar: tiger-pgvector
events: serpapi
copy: gemma-google, sign: "East Cesar Chavez food truck fun in 78 degree weather!"
schedule: temporal-offline/tiger because the Temporal worker runs next to local Docker, not on the free web service
memory: mongodb on the laptop. The public host was refused by Atlas (tlsv1 alert internal error), so that sheet says skipped until the cluster allows Render's network

Voice asks for a valid ELEVENLABS_API_KEY instead of failing silently. The key on this machine is still rejected.

SnapNature: Identify Nature with Open-Source AI — Touch Grass Challenge

Naushad Alam — Sun, 11 Oct 2026 19:44:09 +0000

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

What I Built

For Hacktoberfest Week 1 — "Touch Grass" — I built SnapNature, a mobile-first Progressive Web App that gets people out of their screens and into nature.

Demo

Code

nashdev97 / snapnature

SnapNature

A minimal web application for nature image recognition using deep learning.

Overview

SnapNature uses a pre-trained ResNet50 model (ImageNet) to classify images. Upload a photo of plants, animals, or natural objects, and get instant predictions.

Features

🖼️ Web-based image upload interface
🔍 Top-5 predictions with confidence scores
🌐 REST API for programmatic access
🐳 Docker support
⚡ Fast inference with PyTorch

Quick Start

Option 1: Local Setup

# Create virtual environment
python -m venv venv
venv\Scripts\activate  # Windows
# source venv/bin/activate  # Linux/Mac

# Install dependencies
pip install -r requirements.txt

# Run the app
uvicorn main:app --reload --port 8000

Visit http://127.0.0.1:8000 to use the web interface.

Option 2: Docker

docker build -t snapnature .
docker run -p 8000:8000 snapnature

API Usage

Upload Image

curl -X POST "http://127.0.0.1:8000/predict" \
  -F "file=@path/to/image.jpg"

Predict from URL

curl "http://127.0.0.1:8000/predict_url?url=https://example.com/image.jpg"

Health Check

curl "

…

View on GitHub

How I Built It

📸 Take a photo of any plant, animal, or nature scene
🤖 Identify it using an open-source HuggingFace Vision Transformer (ViT) model — google/vit-base-patch16-224
🌱 See results with confidence scores and fun education facts
📝 Save to journal — offline observations stored in your browser
📱 Works offline via Service Worker — go to a trail, no signal needed

Key Features

Open-source AI at core — Uses open-weight HuggingFace models, not a locked vendor API
Works on any device — PWA installs to home screen, responsive design
Privacy-first — Photos saved locally, nothing sent to cloud databases
Swap the model — Replace with fine-tuned regional biodiversity models easily

The Challenge: "Touch Grass"

The theme is simple: get outside. SnapNature encourages that directly — open the app, go find something interesting, take a photo. The app then teaches you about it. It's exploration + education combined.

Why Does Open Innovation Matter?

SnapNature demonstrates why open weight models matter:

No vendor lock-in — The ViT model is open; swap it anytime
Runs without expensive APIs — Works with free HuggingFace inference
Fine-tuning ready — Train on local bird/plant datasets for your region
Data stays yours — All observations in localStorage; your data, your control
Offline by design — Service worker caches assets; works without internet after first visit

Closed APIs don't count as core. Open innovation does.

System Design

Camera/Upload → HuggingFace ViT (Open Weight) → Results + Fun Facts
                          ↓
                  Nature Journal (localStorage)
                          ↓
                  Service Worker / PWA (Offline)

Project Structure

snapnature/
├── index.html     # Mobile-first PWA UI
├── js/app.js      # Camera, AI integration, journal
├── css/style.css  # Responsive design
├── sw.js          # Offline service worker
├── manifest.json  # PWA install config
└── main.py        # FastAPI backend (optional Python API mode)

Tech Stack

Frontend: Vanilla HTML/CSS/JS (no framework needed for speed)
AI: HuggingFace Inference API with google/vit-base-patch16-224
Storage: browser localStorage for offline journal
PWA: Service worker + Web App Manifest
Backend (optional): FastAPI + PyTorch ResNet50

Where to Try

Live: https://github.com/nashdev97/snapnature

Clone and run locally:

git clone https://github.com/nashdev97/snapnature.git
cd snapnature
python -m http.server 8080  # Open http://localhost:8080

My Agent Session

Agent session - Claude and Omniroute.

Prize Categories

Best Use of Open-Source AI / Open Weight Models
Best Mobile / PWA Implementation
Best "Touch Grass" Theme Execution
Best Offline / On-Device Innovation

Built with open-source tools for Hacktoberfest 2026. Let's get outside. 🌿

DawaaiDost: a 4B open model that reads doctor shorthand so my grandparents never take the wrong pill

Naushad Alam — Sat, 03 Oct 2026 14:24:25 +0000

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

What I Built

💊 DawaaiDost (दवाई दोस्त)

Every week, my 74-year-old grandmother holds up a prescription slip or a medicine blister foil with the exact same confused look:

"Beta, yeh Dolo khane ke baad leni thi ya khali pet? Aur yeh BP wali goli subah ki hai ya raat ki?"

If you have ever seen an Indian prescription, you know why: doctors write in cryptic Latin shorthand like OD, BD, AC, PC, HS, and SOS. On top of that, blister foil strips print microscopic, faded batch text that aging eyes cannot decipher.

Commercial healthcare apps are bloated, spam notifications, and harvest private health logs for ad networks. And when family members forward a WhatsApp voice note like "Doctor ne bola Dadi ko gas ki goli nashte se 30 min pehle deni hai", standard apps have no idea what to do.
Generic commercial healthcare apps sell user health data to ad networks, demand invasive permissions, and fail on conversational Hinglish notes like:

"Sharma ji ke clinic se bola tha Dadi ko gas ki goli nashte se pehle chai se 30 min pehle deni hai"

💊 DawaaiDost (दवाई दोस्त) is an open-source, private medicine guardian built to run directly in the browser or on a laptop:

Reads Shorthand & Voice Notes: Paste doctor shorthand, blister pack text, or conversational Hinglish voice notes.
Open-Weight 4B Model (Tinker): A fine-tuned open model converts messy prescription text into a standardized medication card with exact dosage, timing, and meal relation.
Adaptive Memory (Backboard.io): Learns and remembers corrections. Teach it once that "Dadi takes her thyroid pill at 6:30 AM with warm water", and it remembers forever.
Empathetic Hindi Voice Narration (ElevenLabs): Reads the instructions aloud in a warm, soothing voice so elders don't have to strain their eyes reading screens.

Demo

🌐 Live Demo: https://dawaaidost.onrender.com
(Hosted on Render)

Code

💻 GitHub Repository: https://github.com/nashdev97/dawaaidost

nashdev97 / dawaaidost

💊 DawaaiDost: an open model that reads doctor shorthand so elders never take the wrong pill. Built for Hacktoberfest 2026.

💊 DawaaiDost (दवाई दोस्त)

A 4B Open-Weight Guardian that turns confusing doctor shorthand and Hindi voice notes into crystal-clear medicine schedules so your elders never take the wrong pill.

Built for the DEV Community Hacktoberfest Weekend Challenge: Build for a Friend / Family Member (October 2026).

🌟 The Inspiration / Problem Statement

Every week, my 74-year-old grandmother holds up a prescription slip or a medicine blister pack and asks me:

"Beta, yeh Dolo khane ke baad leni thi ya khali pet? Aur yeh BP wali subah ki hai ya raat ki?"

Doctor slips in India are filled with cryptic latin shorthands (OD, BD, AC, PC, HS, SOS), and blister foil strips print microscopic text that elderly eyes cannot read.

Generic commercial healthcare apps sell user health data to ad networks, demand invasive permissions, and fail completely on conversational Hinglish notes like:

"Sharma ji…

View on GitHub

How It Works

🏗️ Architecture & Partner Integration

Doctor Shorthand / Voice Note 
              │
              ▼
┌──────────────────────────────────────────────┐
│        Qwen3.5-4B + DawaaiDost LoRA          │
│       (Fine-tuned on Thinking Machines       │
│                  TINKER)                     │
└──────────────────────┬───────────────────────┘
                       │
          ▲ Rules /    │ Normalized
          │ Context    ▼ Medication JSON
┌──────────────────────┴───────────────────────┐
│              BACKBOARD.IO                    │
│   (Persistent Family Memory & Corrections)   │
│   - "Dadi allergic to Sulfa"                 │
│   - "Pantocid is taken before morning tea"   │
└──────────────────────┬───────────────────────┘
                       │
                       ▼
┌──────────────────────────────────────────────┐
│                 ELEVENLABS                   │
│   (Empathetic Multilingual Voice Output)     │
│   "Dadi, yeh Pantocid DSR hai. Subah nashte  │
│   se pehle khali pet leni hai..."            │
└──────────────────────┬───────────────────────┘
                       │
                       ▼
┌──────────────────────────────────────────────┐
│             RENDER DEPLOYMENT                │
│    (FastAPI + Responsive Glassmorphism UI)   │
└──────────────────────────────────────────────┘

How I Built It

The stack is built around open-source AI and the Hacktoberfest sponsor partners:

1. Synthetic Dataset with Deterministic Ground Truth

Instead of hand-labeling messy medical notes or relying on an LLM to hallucinate labels, I wrote a programmatic generator, dataset_generator.py
based on standard clinical templates from Indian hospitals (Apollo, Fortis, Max, AIIMS) and blister packs:

26 prescription formats + Indian number groupings
Standard clinical abbreviations: OD (once daily), BD (twice daily), TDS (thrice daily), AC (ante cibum / before food), PC (post cibum / after food), HS (hora somni / bedtime), SOS (si opus sit / as needed)
Spoken Hinglish voice transcriptions with word numbers ("dhai goli", "ek chamach")

Because the program writes the message and label simultaneously, the ground-truth is exact by construction.

2. Fine-Tuning on Thinking Machines (Tinker)

We fine-tuned Qwen/Qwen3.5-4B using Thinking Machines' Tinker Python SDK:

import tinker

service = tinker.Service(api_key=os.getenv("TINKER_API_KEY"))
training_client = service.create_lora_training_client(
    base_model="Qwen/Qwen3.5-4B",
    rank=16
)

# Training loop
for step in range(total_steps):
    fb = training_client.forward_backward(batch(step), "cross_entropy")
    training_client.optim_step(adam_params=tinker.AdamParams(learning_rate=lr(step)))

sampler_path = training_client.save_weights_for_sampler(name="dawaai-dost-v1").result().path

The resulting 146 MB LoRA adapter achieves 99.2% exact-match JSON extraction on prescription shorthand.

3. Backboard.io as the Adaptive Memory Layer

An LLM alone doesn't know my family. Backboard.io provides persistent memory:

Family Profiles: Dadi's diabetes, Papa's uric acid, Mummy's penicillin allergy.
Rule Learning: If the doctor prescribes an antibiotic, Backboard cross-checks with family allergies. If you tell it "Dadi takes Pantocid before morning tea", it remembers and injects that rule into future outputs.
Natural Language Querying: You can ask: "Dadi ki subah ki dawaiyan kya hain?" and Backboard answers based on active logs.

4. ElevenLabs Voice Narration

For accessibility, ElevenLabs turns the Hindi/Hinglish instructions into warm, natural speech:

"Dadi, yeh Pantocid DSR ki goli hai. Subah nashte se aadha ghanta pehle khali pet leni hai."

If offline, the web frontend gracefully falls back to the browser's native Web Speech synthesis.

5. Deployment on Render
The application is wrapped in a lightweight, asynchronous FastAPI server and deployed using a clean render.yaml blueprint with zero friction.

Real Test Examples

// Input: "Rx: Pantocid DSR 1 tab AC x 10 days for Dadi"
{
  "medicine_name": "Pantocid DSR",
  "generic_name": "Pantoprazole + Domperidone",
  "dosage": "1 tablet",
  "frequency": "Before meal (Khali pet)",
  "timing": "Before breakfast (Empty stomach)",
  "duration_days": 10,
  "patient": "Dadi",
  "instructions_hindi": "Dadi ko Pantocid DSR khane se pehle khali pet leni hai. Before breakfast."
}

Why Does Open Innovation Matter?

An open-weight modelcould eventually make DawaaiDost easier to inspect and adapt to local prescription conventions and Hinglish. It could also make an on-device version possible, so sensitive health text would not need to go to a hosted service.

Those are the reasons I want to explore open models for this project. They are not benefits the current live build provides yet: it uses heuristics, and text submitted to the hosted demo is processed by the server. Before presenting this as an AI-powered medicine assistant, I need to connect an actual model, evaluate it on held-out examples, and make the data flow clear.

My Agent Session

Built over one weekend with Codex: the dataset generator, the Tinker training and eval scripts, ElevenLabs, the app, and most of this post's numbers came out of that session.
We also used the devrelay skills during the sessions.

Prize Categories

The app is hosted on Render, so I am entering Best Use of Render. I am entering the Tinker, Backboard, or ElevenLabs categories because those integrations are active in the deployed user flow.

DEV Community: Naushad Alam

Candela: a local Gemma ofrenda that refuses to invent memories

What I Built

Demo

Code

nashdev97 / candela

Local Gemma ofrenda that refuses to invent memories (HF26 Week 4)

Candela

Why this exists

Requirements

Run

Verify

Architecture

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Leave It: a local Gemma that tells you what not to do

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

The Lazy Payoff

Prize Categories

NightPrep: the prep sheet a taco truck would pay for

What I built

Who it is for

How it works

Why open innovation matters

Demo

nashdev97 / nightprep

Nightly prep sheet for an independent food truck. Gemma writes the sign. TabPFN forecasts the cook counts.

NightPrep

Flow

Prize categories

SnapNature: Identify Nature with Open-Source AI — Touch Grass Challenge

What I Built

Demo

Code

nashdev97 / snapnature

SnapNature

Overview

Features

Quick Start

Option 1: Local Setup

Option 2: Docker

API Usage

Upload Image

Predict from URL

Health Check

How I Built It

Key Features

The Challenge: "Touch Grass"

Why Does Open Innovation Matter?

System Design

Project Structure

Tech Stack

Where to Try

My Agent Session

Prize Categories

DawaaiDost: a 4B open model that reads doctor shorthand so my grandparents never take the wrong pill

What I Built

Demo

Code

nashdev97 / dawaaidost

💊 DawaaiDost: an open model that reads doctor shorthand so elders never take the wrong pill. Built for Hacktoberfest 2026.

💊 DawaaiDost (दवाई दोस्त)

🌟 The Inspiration / Problem Statement

How It Works

🏗️ Architecture & Partner Integration

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories