DEV Community: Smaranika

Dear Tomorrow: a local Gemma app that writes the note you'll need in the morning

Smaranika — Sun, 25 Oct 2026 16:21:04 +0000

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

The most expensive part of starting work is often remembering where you stopped. Which branch? Which test was failing? What did you promise to send? Rebuilding that context at 9 am is slow, dull work, and you only have to do it because nobody wrote it down while it was fresh.

So I built Dear Tomorrow. At the end of the day, you dump everything into one box, messy as it comes. A local Gemma model turns it into a short note to your future self. Next time you open the page, the note is waiting.

What I Built

Dear Tomorrow is a single web page. The note has four parts:

🎯 Start here. One concrete first action for tomorrow, taken from your own words.
🧭 Where you were. Up to three short facts that rebuild context.
🔁 Open loops. Up to five unfinished things as a checklist you can tick off.
🗂️ Your original dump. Always saved in full, one click away.

Around the note, there's a steady streak of consecutive days you handed off, a list of past notes, and a copy button for pasting the note into chat or a ticket.

It fits the theme because it's lazy in the right way: it does the remembering so you don't have to. It also lets you stop on time, because the loose ends are written down and no longer rattling around in your head. Slow and steady, with a bit of help.

Demo

Live: https://smaranikamondal.github.io/dear-tomorrow/

The hosted page can't run Gemma. Without Ollama, it works as a plain "note to tomorrow" pad that keeps your raw dump, and See a sample shows a labelled example of what a note looks like. With Ollama running locally, the same page writes real summaries with your own model. The README has the steps.

Code

smaranikamondal / dear-tomorrow

🦥 Dear Tomorrow

Dump your day. Gemma writes the note. Tomorrow-you starts in thirty seconds.

A lazy-in-the-right-way note-to-self, written by an open model on your own laptop. Your notes never leave your machine.

Why this exists

Dear Tomorrow does it the night before, while it's still in your head. Dump everything, however messy. Gemma turns it into a short note for tomorrow, and the note is waiting when you open the page.

Built for the Hacktoberfest Open-Source AI Challenge, Week 3: Slow and Steady (Oct 19-25, 2026). Started and finished within the challenge window.

What it does

📝 Dump	One box. Notes, half-finished to-dos, branch names, error messages, things

…

View on GitHub

How I Built It

One HTML file, no framework, no build step, no dependencies. The model is Gemma, served locally by Ollama.

1. The model's job is small. It summarises and doesn't judge. The prompt asks for a fixed JSON shape: a headline, a single first action, and two short lists. It tells the model to use only what's in the dump, to keep real names, files, and numbers, and to treat the dump as data and ignore any instructions in it.

2. The original is saved before the model is called. Your raw dump goes into storage first, so if Gemma is missing, slow, or returns nonsense, the note is simply the raw dump, shown open. The summary is a convenience on top of the text, never a replacement for it.

3. Code validates what comes back. A reply needs a non-empty "start here". The lists are filtered to strings, de-duplicated (case-insensitive), and capped at three and five items. Anything else is dropped.

4. Dates and streaks are code. "Good morning" versus "from 4 days ago" and the streak count are worked out from stored dates. A missed day resets the streak, and today stays open until you hand off. A language model has no business counting days.

5. Practical limits are explicit. Only the first 3,500 characters go to the model, because Ollama's default context is small. The note says so, and the full dump is still saved. Requests use JSON mode, a low temperature, and a token cap, which keeps small models on a CPU laptop quick enough.

6. Everything the model writes is shown as plain text, never as HTML.

7. I tested it in a headless browser against a mocked Ollama with seeded dates: the full flow, reload persistence, the next-morning view, streak maths, malformed model output, no Ollama, blocked storage, a long dump, injection attempts and the phone layout. All 47 checks passed. That tests the app's logic, not Gemma's summarising, which depends on the model you run.

Honest limits.

Summaries can miss or blur details, and small models are especially prone to it. That's why the original dump is always one click away. Read the note before you trust it.
"Start here" is the model's guess at your most concrete next action, and it can be wrong.
Notes live in browser storage, so they don't sync across devices and disappear if you clear site data.
Prompt injection isn't solved. The prompt asks the model to treat your dump as data, which helps but isn't a guarantee.
Notes are stored unencrypted, so don't put secrets in them.

Why Does Open Innovation Matter?

A day's brain dump is the most private text most people write: client names, half-formed ideas, and things they shouldn't have typed. Open models fit that job for practical reasons:

Nothing leaves the laptop. There's no server in the loop, so an NDA'd project or a rough idea stays put.
It's free every night. A tool you use daily shouldn't meter every note.
It works offline, on the train home or on a plane, and the model can't change behaviour overnight.
Swapping models is one dropdown. The list comes from whatever Ollama has installed, so you can trade speed for quality without touching the code.

Prize Categories

Best Use of Gemma. Gemma writes every summary locally through Ollama. The app detects and selects it automatically, keeps its job small, and validates everything it returns.

Built with AI coding assistance. Gemma is provided under and subject to the Gemma Terms of Use found at ai.google.dev/gemma/terms.

Scopewise: a local Gemma app that turns "could you also…?" into a quote

Smaranika — Sun, 18 Oct 2026 15:59:42 +0000

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

Freelance projects rarely go wrong in one big moment. They go wrong in small ones. A client sends "could you also add…?", and saying yes quietly is easier than the awkward money conversation. A few of those, and a fixed-price project has stopped being worth doing.

So I built Scopewise: paste what you agreed and the client's new message, and a local Gemma model tells you whether the request is inside the scope, extra work, or too vague to say. If it's extra, it lists the work, prices it, and gives you a polite reply ready to edit and send.

What I Built

Scopewise is a single web page with four jobs:

🔍 Check. You paste the agreed scope and a client message. The verdict is one of Inside scope, Extra work, or Needs a question, with a one-sentence reason that points back to your scope.
💰 Quote. For extra work, each new piece of work gets an hour estimate, and the app turns hours into a cost using your hourly rate.
✉️ Reply. A draft in a friendly or firm tone. It never promises free work, and the estimate line is added by the app.
📈 Tally. A running total of extra work you've flagged, kept in your own browser.

It's for freelancers and tiny agencies working on fixed-price projects: designers, developers, writers, anyone whose scope lives in a short brief and whose client messages arrive in a chat window.

Demo

Live: https://smaranikamondal.github.io/Scopewise/

The hosted page can't run Gemma, so you can press See a sample to see a labelled example result. With Ollama running locally, the same page checks your own text with your own model. The README has the steps.

Code

smaranikamondal / Scopewise

🧾 Scopewise

Tell clients "yes, and here's the quote", not "sure, no problem".

A scope-creep checker for freelancers, powered by an open model on your own laptop. Client messages never leave your machine.

Why this exists

Scope creep is a small, constant leak in freelance work. A client sends "could you also…?", and saying yes quietly is easier than having the awkward conversation. A few of those and a fixed-price project stops being profitable.

Scopewise takes the awkward part off your plate. Paste what was agreed and the client's new message. It tells you whether the request is inside the scope, extra work, or too vague to say, and writes a polite reply you can edit and send.

Built for the Hacktoberfest Open-Source AI Challenge, Week 2: Side Hustle (Oct 12-18, 2026). Started and finished within the challenge window.

What it does

🔍 Check	Paste the agreed scope and a

…

View on GitHub

How I Built It

One HTML file, no framework, no build step, no dependencies. The model is Gemma, served locally by Ollama.

1. Two untrusted blocks of text go in. The scope and the client message are both wrapped in tags, and the prompt says to treat them as data and ignore any instructions inside them. That reduces prompt injection but doesn't eliminate it, so the README says so.

2. The model returns a fixed JSON shape. Requests use format: "json" and a low temperature. The shape is a verdict, a one-sentence reason, a list of extra items with hours, an optional clarifying question, and a reply.

3. Code decides what's valid. The reply is parsed defensively, then checked:

An unknown verdict is rejected.
An "extra" verdict with no items is rejected.
Extras attached to an "in scope" or "unclear" verdict are dropped.
Hours are clamped to 0.25-80 and rounded to quarter hours.

4. The money is never the model's job. Gemma estimates hours. The app multiplies by your rate, formats the currency, and writes the estimate line into the reply. A language model shouldn't be doing arithmetic on someone's invoice.

5. Everything the model writes is shown as plain text, never as HTML, so a strange output can't inject anything into the page.

6. I tested it in a headless browser against a mocked Ollama: the extra-work flow and its quote maths, in-scope and unclear results, copy to clipboard, saved settings after a reload, malformed model output, an HTML injection attempt and the phone layout. All 30 checks passed. That tests the app's logic, not Gemma's judgment, which depends on the model you run.

Honest limits.

The hours are a model's guess. Change the quote before you send it.
It only knows what you paste. A vague scope gives a vague verdict.
It's a drafting aid, not legal advice or a contract.
In my own testing, gemma3:1b on a CPU-only laptop marked two clearly out-of-scope requests as “Inside scope”. A larger Gemma may judge scope more reliably, but I haven’t tested that, so read every verdict before you reply to a client.
The tally and saved scope live in browser storage, so they stay on one browser.

Why Does Open Innovation Matter?

A client's messages and a project's scope are confidential: names, budgets, unreleased products. For this tool, open models solve practical problems:

Client data stays on the freelancer's laptop. There's no third-party server in the loop, which matters when a client's brief is under NDA.
It costs nothing per check. A freelancer might run it on every message. With a hosted API, that's a meter running on every client email.
It works offline, and the model can't change behaviour underneath you.
Swapping models is trivial. The dropdown is filled from whatever Ollama has installed, so you can trade speed for judgment with one click.

Would Someone Pay for This?

The theme asks for something people would pay for, so here's the honest version. The value isn't the reply text. It's catching the request. One caught request of a few hours is worth more than any plausible price for the tool, and the awkward-conversation cost is removed. What's missing for a paid product is the part I deliberately kept out: a saved library of past projects and scopes, and a way to turn a quote into a proper change order. This is a working prototype of the core loop, not a finished product.

Prize Categories

Best Use of Gemma. Gemma judges every request, estimates the hours, and drafts the reply locally through Ollama. The app detects and selects it automatically, and the code validates everything it returns.

Built with AI coding assistance. Gemma is provided under and subject to the Gemma Terms of Use found at ai.google.dev/gemma/terms.

Mosey: a local Gemma app that deals you a walk, then makes you put the phone away

Smaranika — Sun, 11 Oct 2026 18:47:25 +0000

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

"Go for a walk" is good advice that is hard to follow. The walk itself is easy. What's hard is knowing what to do with it, and the phone is right there making it easy to skip.

So I built Mosey: an app that deals you a walk. You tell it how long you have and how you feel, a local Gemma model writes you a pocket card of small, odd things to notice, and then the app does its best to disappear.

What I Built

Mosey is a single web page with four parts:

🃏 Deal. Pick 15, 30 or 60 minutes, a mood (calm, curious, energetic, fried from screens), and optionally where you are. Gemma writes a card with a playful title, one task per sense, a phone rule for the walk and a question to carry home.
📵 Phone-away mode. One button turns the screen black with a countdown. The card can also be printed or saved as a PDF, so you can walk out with paper and leave the phone behind.
📓 Field note. Back home, jot a few rough words. Gemma turns them into a short journal entry using only what you wrote.
🧰 Built-in deck. If no local model is found, Mosey deals from a hand-written deck, so it always works.

The goal was to make the screen the shortest part of the experience. The whole interaction is about thirty seconds on the page, then the walk, then a minute afterwards.

The tasks are meant to be specific and a little strange. "Find three different shades of green and decide which one is the winner" gives you something to do. "Enjoy nature" doesn't.

Demo

Live: https://smaranikamondal.github.io/Mosey/

The hosted copy deals from the built-in deck, because a static site can't run Gemma. If you have Ollama installed and running with OLLAMA_ORIGINS set, the page finds your local Gemma and writes the cards itself. The README has the steps.

Code

smaranikamondal / Mosey

🌿 Mosey

Deal yourself a walk. Then put the phone away.

A pocket walk card written by an open model on your own laptop. No account, no cloud, no per-request cost.

Why this exists

Most people know they should go outside more. The hard part is knowing what to do once you're out there, and the phone is right there making that easy to skip. Mosey gives you a small, specific reason to look around, then gets out of the way.

Built for the Hacktoberfest Open-Source AI Challenge, Week 1: Touch Grass (Oct 5-11, 2026).

What it does

🃏 Deal	Pick how long you have (15, 30 or 60 minutes), your mood, and optionally where you are. Gemma writes a card with a playful title, one odd noticing task per sense, a phone rule and a question to carry home.
📵 Phone-away mode	A black countdown screen so the app

…

View on GitHub

How I Built It

The app is one HTML file with no framework, no build step, and no dependencies. The model is Gemma, served locally by Ollama.

1. The page finds the model for you. On load, it calls Ollama's /api/tags, lists the installed models, and picks a Gemma one. If Ollama isn't running, the status line says so, and the built-in deck takes over.

2. The prompt asks for a fixed shape. The request includes the day, the time of day, the minutes available, the mood, and the place. Gemma has to reply with JSON in this form:

{
  "title": "3-5 word playful title",
  "intro": "one short sentence setting the scene",
  "stops": [{ "sense": "look|listen|touch|smell|do|wonder", "text": "one concrete task" }],
  "rule": "one short phone rule for this walk",
  "closer": "one reflective question"
}

The card gets 4, 5, or 6 stops depending on whether you chose 15, 30, or 60 minutes, and each stop must use a different sense. The prompt also tells the model to avoid anything that needs equipment, money, or a screen, anything unsafe and anything involving trespassing, and to fit the season, time of day and place.

3. Ollama's JSON mode, then validation. Requests use format: "json". The reply is then parsed defensively: the code pulls out the first {...} block, checks that there's a title and at least three stops, and drops stops with no text.

4. A fallback instead of an error. If the reply is broken, or Ollama isn't there, Mosey deals from a hand-written deck of tasks for each of the six senses, with titles and phone rules to match the mood. A broken model response never shows up as an error screen.

5. The field note is deliberately small. The prompt asks for three or four sentences and tells the model to use only the details in your notes and not to invent events.

Honest limits.

Nothing in the code checks the model's tasks for safety. The prompt asks for safe ones, but a small model can still suggest something silly. Use your own judgment about where you walk.
Cards depend on the model. A small Gemma can be generic or repeat itself, and the first card can be slow while the model loads.
The field note can embellish even when told not to. Read it before you keep it.
Mosey can't tell whether you actually went outside.
Safari blocks https pages from calling http://localhost, so the Gemma path on the hosted site needs Chrome, Edge or Firefox.

Why Does Open Innovation Matter?

A walk card is a few sentences of text. It shouldn't need an account, an API key, a subscription, or a connection. Open models make that true:

It works anywhere. Once the model is on the laptop, it runs with no signal at all, which is where a walk often starts.
It's private. Where you walk and how you feel never leave your machine. There is no server of mine in the loop, and no analytics.
Every card is free. You can deal ten walks and keep the best one without thinking about cost.
Swapping models is trivial. The model dropdown is filled from whatever Ollama has installed, and changing how the cards behave is a prompt edit.

Prize Categories

Best Use of Gemma. Gemma writes every card and field note locally through Ollama, and the app detects and selects it automatically.

Built with AI coding assistance. I directed it, reviewed the code, and ran it myself. Gemma is provided under and subject to the Gemma Terms of Use found at ai.google.dev/gemma/terms.

I built my cousin a gym planner that can't sneak an allergy past him

Smaranika — Sun, 04 Oct 2026 20:16:11 +0000

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

My cousin just started going to the gym. He also has a severe nut allergy and a shellfish allergy, which makes "just follow a meal plan from the internet" a bad idea. Most meal-plan apps don't know what he can't eat.

So I built him PlateAndPlate: a gym meal and workout planner that runs on his own laptop, and checks every plan for his allergens before he ever sees it.

What I Built

PlateAndPlate has three tabs:

🏋️ Train. A weekly split based on how many days he trains (4 days gives Upper, Lower, Upper, Lower). He taps a day and the model writes that session: warm-up, exercises, sets, reps and rest.
🥗 Eat. He types what he wants ("3 high-protein dinners") and gets meals with approximate calories and protein.
📊 Log. A daily calorie counter. A ring at the top fills as he logs food, and turns red if he goes over.

The one rule behind all of it: the AI suggests, and plain code decides.

Demo

Watch PlateAndPlate in action: one gym planner, zero nuts

PlateAndPlate is built to run locally on his laptop, so there is no hosted version. The screenshots and the code show how it works.

Code

smaranikamondal / PlateAndPlate

🏋️ PlateAndPlate

A gym meal and workout planner that can't sneak an allergen past you.

Runs on your own laptop with an open model. No account, no cloud, no per-request cost.

Why this exists

I built PlateAndPlate for my cousin, who is starting a gym routine and has severe nut and shellfish allergies. Most meal and fitness apps suggest almond-crusted everything and don't know what he can't eat. PlateAndPlate plans his meals and workouts, counts his calories, and checks every plan for his allergens before he sees it.

What it does

🏋️ Train	A weekly split (set by gym days per week). Tap a day and Gemma writes that session: warm-up, exercises, sets, reps, rest.
🥗 Eat	Ask for meals in plain language, such as "3 high-protein dinners". Plans include approximate calories and protein.
📊 Log	A daily calorie counter with a ring that fills as you log food.

…

View on GitHub

How I Built It

The whole thing is one Python file with no dependencies, a single HTML page, and a JSON profile. The model is Gemma 3 1B, served locally by Ollama.

1. The guardrail is code, not a prompt. Asking a model nicely to avoid nuts isn't a safety system. So every response goes through a plain-code check against his avoid list before it reaches the screen. The text is normalised first (Unicode NFKC, zero-width characters stripped), so peanut with a hidden character and the full-width ｐｅａｎｕｔ still count as "peanut". If anything on the list appears, the draft is thrown away and regenerated, up to three times, then refused. Workouts get the same treatment for exercises he should skip.

2. The numbers come from formulas, not the model. A 1B model can't look up real food data, so his daily calorie and protein targets are calculated in code with the Mifflin-St Jeor equation from his age, weight, height, activity and goal. Gemma only writes the meals and exercises.

3. The weekly split is fixed in code. Gemma writes one session at a time instead of a whole week, which keeps requests short and the structure reliable. Sessions are checked against a whitelist, and the server only answers requests addressed to localhost.

4. Tests. They cover bypass attempts (hidden and full-width characters), the second allergen, the retry logic, the workout whitelist and the calorie formula.

What I learned along the way:

My first prompt called the model a "friendly meal planner", and it started calling my cousin "darling" in the middle of dinner plans. Small models over-act a persona. Changing "friendly" to "practical" and telling it to start directly with the first meal fixed it.
I didn't trust a small model to follow "no nuts" on its own, so I wrote tests that try to sneak a peanut past the check using a hidden zero-width character and full-width letters, and a draft containing a banned word is thrown away and regenerated. I haven't yet seen a long run of real-world use with it, so treat the guard as a safety net, not a guarantee.
The test I cared about most: I asked the Eat tab for "something with almond", on purpose, with almonds on my cousin's avoid list. The app showed a red "Blocked by the safety check" banner instead of a recipe. That banner only appears when all three attempts contained a banned ingredient, so the check threw every draft away and nothing unsafe reached the screen. It's what I built the guardrail for, because asking a model nicely to avoid nuts isn't enough. A small model tends to repeat the words it's given, and here the almonds were in my own request.

Honest limits. The calorie targets are estimates and the model's per-meal numbers are rough guesses, so this isn't medical advice. The guard checks words, not ideas: if an ingredient or synonym isn't on his list, it won't be caught. The README says so too.

Why Does Open Innovation Matter?

For this project, open models weren't a principle. They solved four practical problems:

His health data stays on his laptop. Allergies, body weight and eating habits are about the last thing I'd want to send to someone else's server. Here it's one small JSON file.
It's free every day. There is no cost per plan, so he can ask as often as he wants without thinking about it.
It works offline, and the model version is pinned, so it can't change behaviour on him overnight.
I could wrap it tightly. A hard safety check, a calorie formula and a fixed weekly structure around the model are much easier when you control the model and can run it locally.

Handing it over

I haven't handed it over yet. I'm putting it on his laptop this week with his real allergens in the avoid list, and I'll update this post with what he thinks. I suspect he'll ignore the workout tab and go straight to the calorie ring.

Prize Categories

Best Use of Gemma. Gemma 3 1B writes every meal plan and workout locally through Ollama.

Built with AI coding assistance. I directed it, reviewed the code and ran it myself. Gemma is provided under and subject to the Gemma Terms of Use found at ai.google.dev/gemma/terms.