DEV Community: noneofurbusiness

SlothSort

noneofurbusiness — Mon, 26 Oct 2026 10:59:29 +0000

🦥 SlothSort: A Lazy Way to Organize Your Downloads with Local AI

My submission for the Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady.

What I Built

My Downloads folder was full of files with names like final_final_v2.zip and IMG_8841.png. I kept postponing the cleanup, so I built SlothSort — a local AI agent that organizes files for me.

It reads supported file contents, suggests meaningful filenames, and moves files into sensible folders. It never deletes files, and every operation is logged so I can undo changes.

Demo

Source code: https://github.com/yaansa/slothsort

How It Works

Scan: Python scans files and extracts text from supported text files and PDFs. Images are currently classified using their filenames and extensions because OCR isn't implemented yet.
Understand: Gemma runs locally through Ollama and returns structured JSON with a category, suggested filename, and explanation.
Plan first: The plan command previews proposed changes without moving anything.
Move and undo: The apply command moves files, while SQLite logs operations so undo can restore their previous locations.

Stack: Python, Gemma via Ollama, SQLite, and an optional PDF reader.

Why Open-Source AI Matters

Downloads folders can contain private documents, resumes, marksheets, and financial records. Uploading them to a cloud AI service just to organize files isn't ideal.

With Gemma running locally through Ollama, SlothSort can process supported content on my own machine. Once the model and dependencies are installed, the workflow can operate offline without requiring a paid AI API for every request.

Open-weight AI also gives me the freedom to experiment with models and customize the workflow while keeping greater control over my data.

Safety First

Dry-run mode previews changes before execution.
Files are moved, never deleted.
Model output is validated, and filenames are sanitized to prevent unsafe paths.
Rule-based fallback handles cases where Ollama is unavailable.
Automated tests cover dry-run, apply/undo, and invalid model output.

What Worked and What Didn't

Worked: [Add your actual test results: files correctly classified out of total files tested.]
Didn't: Without OCR, images are classified using filenames and extensions, so their actual contents aren't understood.
Next: Add OCR and a review step for uncertain classifications.

What I Learned

Building SlothSort showed me that reliable AI automation needs more than a good prompt. Validating model output, previewing changes, and supporting undo are essential for making an agent safer and more useful.

The goal: Spend less time organizing files and more time doing what matters. Let the sloth take care of the boring stuff. 🦥

devchallenges #hf26challenge #Gemma #Ollama

Udhaar Khata: The Notebook Behind the Counter

noneofurbusiness — Sun, 18 Oct 2026 18:16:41 +0000

Udhaar Khata: The Notebook Behind the Counter

What I Built

In almost every kirana store in India, there is a thin notebook next to the cash box. Page after page, it records entries like Ramesh ₹500, Sita ₹300, and Amit ₹1,000 baaki. This is the udhaar khata, the informal credit ledger that small businesses use to track customer debts and repayments.

Tutors maintain similar records for pending fees, while tailors, milkmen, chemists, and neighbourhood shops rely on trust and handwritten notes to manage payments. But notebooks can get lost, amounts can be disputed, and promised payment dates can be forgotten.

Digital alternatives often introduce too much friction through signups, complicated forms, and dropdowns. They may also require customers' financial information to be stored on someone else's server.

I built Udhaar Khata, a privacy-focused digital ledger that lets users record transactions in everyday language instead of filling out forms.

For example, a shopkeeper can type:

"Ramesh ne 500 udhaar liya, 200 kal dega."

The AI interprets the sentence and extracts transaction details, including the customer, amount, transaction type, promised payment, and date. The shopkeeper reviews the proposed entry, corrects it if necessary, and confirms it before saving. Payment reminders can also be opened in WhatsApp with a pre-filled message.

The goal is to preserve the two best things about the traditional notebook—speed and privacy—while making records easier to maintain.

Who would pay for it?

My target users are kirana shop owners, tutors, tailors, milkmen, chemists, and other small businesses that maintain informal credit records. The product could follow a free or low-cost model, with potential premium features such as backups, exports, and advanced summaries. Local AI inference helps keep recurring inference costs low.

Demo

Live application: https://udhaar-khata.onrender.com

Open the application in an up-to-date version of Chrome or Edge on a device that supports WebGPU. The first visit may take longer because the AI model needs to download.

Code

GitHub repository: https://github.com/yaansa/udhaar-khata

The project is built around local AI inference, natural-language transaction parsing, and a simple interface that keeps the user in control of financial records.

How I Built It

Udhaar Khata uses an open-weight language model running directly in the browser through WebLLM and WebGPU. Instead of sending every transaction to a remote AI service, the application processes the user's input locally.

The workflow is straightforward:

The user enters a transaction in everyday Hindi, Hinglish, or English.
The model interprets the sentence and returns structured JSON.
The application validates the output and checks for missing or malformed fields.
The proposed transaction is displayed for review and editing.
The entry is saved only after the user confirms it.
A WhatsApp deep link can open a pre-filled payment reminder.

The application uses browser-side storage for ledger records and is hosted as a static website on Render, with the source code maintained on GitHub.

A key design decision was to avoid silently trusting the model. Financial records require care, so when parsing fails or important details are missing, the application provides an editable fallback instead of guessing.

The main challenges include interpreting colloquial Hinglish, distinguishing money lent from money repaid, understanding partial payments, and handling relative dates such as "kal" and "parso." These are important areas for further testing and improvement.

Why Does Open Innovation Matter?

Open innovation matters because privacy, affordability, flexibility, and adaptability are central to this project.

1. Privacy by design

A ledger contains sensitive information about customers, outstanding balances, and payment habits. Local inference means transaction text does not need to be sent to a third-party AI API. This reduces unnecessary data sharing and gives users greater control over their records.

2. Affordable AI for small businesses

A shopkeeper may record dozens of transactions every day. Per-request API charges could make a free or affordable product difficult to sustain. Running inference on the user's device avoids per-request AI costs, although hosting, device compatibility, and the initial model download remain practical considerations.

3. Flexibility without provider lock-in

Using open-weight models provides the flexibility to evaluate and potentially replace the model as better alternatives become available, without depending entirely on a single hosted AI provider.

4. Opportunities for domain-specific improvements

Everyday expressions such as "baaki hai," "wapas diye," and "parso dega" can be difficult for general-purpose models to interpret consistently. Open weights create opportunities to investigate domain-specific evaluation and fine-tuning using carefully prepared, privacy-conscious examples.

5. AI that supports rather than replaces human judgment

The model proposes a transaction, but the shopkeeper makes the final decision. This human-in-the-loop approach is particularly important when AI is handling financial information.

For me, open innovation is not just about using a model whose weights are available. It is about making useful AI more adaptable, affordable, and accessible to people who may not otherwise benefit from it.

My Agent Session

Udhaar Khata's main contribution is the working application and its browser-based AI workflow. I do not have a DevRelay agent-session link to share in this submission, so I am leaving this optional section out.

Prize Categories

Open-Source AI / Open-Weight Models: Udhaar Khata uses an open-weight language model through browser-based inference with WebLLM and WebGPU.

Side Hustle: The project addresses a practical problem faced by small businesses and explores a free or low-cost product model built around local AI inference.

What's Next?

I would like to improve Udhaar Khata with Hindi voice input, better handling of colloquial Hinglish, domain-specific model evaluation, reliable export and backup, and a summary view showing outstanding balances.

Local-first storage also introduces an important limitation: records may be lost if the device is lost or browser data is cleared. A reliable backup feature will be essential for making the application more practical for everyday use.

The broader idea behind this project is simple: some of the most useful tools are built around habits people already trust. The traditional udhaar notebook works because it is immediate and personal. Digitising it should not require complicated workflows or unnecessary data sharing.

With Udhaar Khata, I wanted to explore how a small open-weight model can make an everyday task easier without taking control away from the person using it.

Built for Hacktoberfest 2026 by Yaansa Brijwasi.

What I Built

Digital alternatives often introduce too much friction through signups, complicated forms, and dropdowns. They may also require customers' financial information to be stored on someone else's server.

I built Udhaar Khata, a privacy-focused digital ledger that lets users record transactions in everyday language instead of filling out forms.

For example, a shopkeeper can type:

"Ramesh ne 500 udhaar liya, 200 kal dega."

The goal is to preserve the two best things about the traditional notebook—speed and privacy—while making records easier to maintain.

Who would pay for it?

Demo

Live application: https://udhaar-khata.onrender.com

Open the application in an up-to-date version of Chrome or Edge on a device that supports WebGPU. The first visit may take longer because the AI model needs to download.

Code

GitHub repository: https://github.com/yaansa/udhaar-khata

The project is built around local AI inference, natural-language transaction parsing, and a simple interface that keeps the user in control of financial records.

How I Built It

The workflow is straightforward:

The user enters a transaction in everyday Hindi, Hinglish, or English.
The model interprets the sentence and returns structured JSON.
The application validates the output and checks for missing or malformed fields.
The proposed transaction is displayed for review and editing.
The entry is saved only after the user confirms it.
A WhatsApp deep link can open a pre-filled payment reminder.

The application uses browser-side storage for ledger records and is hosted as a static website on Render, with the source code maintained on GitHub.

Why Does Open Innovation Matter?

Open innovation matters because privacy, affordability, flexibility, and adaptability are central to this project.

1. Privacy by design

2. Affordable AI for small businesses

3. Flexibility without provider lock-in

Using open-weight models provides the flexibility to evaluate and potentially replace the model as better alternatives become available, without depending entirely on a single hosted AI provider.

4. Opportunities for domain-specific improvements

5. AI that supports rather than replaces human judgment

The model proposes a transaction, but the shopkeeper makes the final decision. This human-in-the-loop approach is particularly important when AI is handling financial information.

My Agent Session

Prize Categories

Open-Source AI / Open-Weight Models: Udhaar Khata uses an open-weight language model through browser-based inference with WebLLM and WebGPU.

Side Hustle: The project addresses a practical problem faced by small businesses and explores a free or low-cost product model built around local AI inference.

What's Next?

With Udhaar Khata, I wanted to explore how a small open-weight model can make an everyday task easier without taking control away from the person using it.

Udhaar Khata: A Ledger That Understands Hinglish and Keeps Your Customers' Debts Private

noneofurbusiness — Sun, 18 Oct 2026 18:15:08 +0000

Udhaar Khata: The Notebook Behind the Counter

What I Built

Digital alternatives often introduce too much friction through signups, complicated forms, and dropdowns. They may also require customers' financial information to be stored on someone else's server.

I built Udhaar Khata, a privacy-focused digital ledger that lets users record transactions in everyday language instead of filling out forms.

For example, a shopkeeper can type:

"Ramesh ne 500 udhaar liya, 200 kal dega."

The goal is to preserve the two best things about the traditional notebook—speed and privacy—while making records easier to maintain.

Who would pay for it?

Demo

Live application: https://udhaar-khata.onrender.com

Open the application in an up-to-date version of Chrome or Edge on a device that supports WebGPU. The first visit may take longer because the AI model needs to download.

Code

GitHub repository: https://github.com/yaansa/udhaar-khata

The project is built around local AI inference, natural-language transaction parsing, and a simple interface that keeps the user in control of financial records.

How I Built It

The workflow is straightforward:

The user enters a transaction in everyday Hindi, Hinglish, or English.
The model interprets the sentence and returns structured JSON.
The application validates the output and checks for missing or malformed fields.
The proposed transaction is displayed for review and editing.
The entry is saved only after the user confirms it.
A WhatsApp deep link can open a pre-filled payment reminder.

The application uses browser-side storage for ledger records and is hosted as a static website on Render, with the source code maintained on GitHub.

Why Does Open Innovation Matter?

Open innovation matters because privacy, affordability, flexibility, and adaptability are central to this project.

1. Privacy by design

2. Affordable AI for small businesses

3. Flexibility without provider lock-in

Using open-weight models provides the flexibility to evaluate and potentially replace the model as better alternatives become available, without depending entirely on a single hosted AI provider.

4. Opportunities for domain-specific improvements

5. AI that supports rather than replaces human judgment

The model proposes a transaction, but the shopkeeper makes the final decision. This human-in-the-loop approach is particularly important when AI is handling financial information.

My Agent Session

Prize Categories

Open-Source AI / Open-Weight Models: Udhaar Khata uses an open-weight language model through browser-based inference with WebLLM and WebGPU.

Side Hustle: The project addresses a practical problem faced by small businesses and explores a free or low-cost product model built around local AI inference.

What's Next?

With Udhaar Khata, I wanted to explore how a small open-weight model can make an everyday task easier without taking control away from the person using it.

Built for Hacktoberfest 2026 by Yaansa Brijwasi.

What I Built

Digital alternatives often introduce too much friction through signups, complicated forms, and dropdowns. They may also require customers' financial information to be stored on someone else's server.

I built Udhaar Khata, a privacy-focused digital ledger that lets users record transactions in everyday language instead of filling out forms.

For example, a shopkeeper can type:

"Ramesh ne 500 udhaar liya, 200 kal dega."

The goal is to preserve the two best things about the traditional notebook—speed and privacy—while making records easier to maintain.

Who would pay for it?

Demo

Live application: https://udhaar-khata.onrender.com

Open the application in an up-to-date version of Chrome or Edge on a device that supports WebGPU. The first visit may take longer because the AI model needs to download.

Code

GitHub repository: https://github.com/yaansa/udhaar-khata

The project is built around local AI inference, natural-language transaction parsing, and a simple interface that keeps the user in control of financial records.

How I Built It

The workflow is straightforward:

The user enters a transaction in everyday Hindi, Hinglish, or English.
The model interprets the sentence and returns structured JSON.
The application validates the output and checks for missing or malformed fields.
The proposed transaction is displayed for review and editing.
The entry is saved only after the user confirms it.
A WhatsApp deep link can open a pre-filled payment reminder.

The application uses browser-side storage for ledger records and is hosted as a static website on Render, with the source code maintained on GitHub.

Why Does Open Innovation Matter?

Open innovation matters because privacy, affordability, flexibility, and adaptability are central to this project.

1. Privacy by design

2. Affordable AI for small businesses

3. Flexibility without provider lock-in

Using open-weight models provides the flexibility to evaluate and potentially replace the model as better alternatives become available, without depending entirely on a single hosted AI provider.

4. Opportunities for domain-specific improvements

5. AI that supports rather than replaces human judgment

The model proposes a transaction, but the shopkeeper makes the final decision. This human-in-the-loop approach is particularly important when AI is handling financial information.

My Agent Session

Prize Categories

Open-Source AI / Open-Weight Models: Udhaar Khata uses an open-weight language model through browser-based inference with WebLLM and WebGPU.

Side Hustle: The project addresses a practical problem faced by small businesses and explores a free or low-cost product model built around local AI inference.

What's Next?

With Udhaar Khata, I wanted to explore how a small open-weight model can make an everyday task easier without taking control away from the person using it.

Udhaar Khata: A Ledger That Understands Hinglish and Keeps Your Customers' Debts Private

noneofurbusiness — Sun, 18 Oct 2026 11:16:52 +0000

Udhaar Khata: The Notebook Behind the Counter

What I Built

Digital alternatives often introduce too much friction through signups, complicated forms, and dropdowns. They may also require customers' financial information to be stored on someone else's server.

I built Udhaar Khata, a privacy-focused digital ledger that lets users record transactions in everyday language instead of filling out forms.

For example, a shopkeeper can type:

"Ramesh ne 500 udhaar liya, 200 kal dega."

The goal is to preserve the two best things about the traditional notebook—speed and privacy—while making records easier to maintain.

Who would pay for it?

Demo

Live application: https://udhaar-khata.onrender.com

Open the application in an up-to-date version of Chrome or Edge on a device that supports WebGPU. The first visit may take longer because the AI model needs to download.

Code

GitHub repository: https://github.com/yaansa/udhaar-khata

The project is built around local AI inference, natural-language transaction parsing, and a simple interface that keeps the user in control of financial records.

How I Built It

The workflow is straightforward:

The user enters a transaction in everyday Hindi, Hinglish, or English.
The model interprets the sentence and returns structured JSON.
The application validates the output and checks for missing or malformed fields.
The proposed transaction is displayed for review and editing.
The entry is saved only after the user confirms it.
A WhatsApp deep link can open a pre-filled payment reminder.

The application uses browser-side storage for ledger records and is hosted as a static website on Render, with the source code maintained on GitHub.

Why Does Open Innovation Matter?

Open innovation matters because privacy, affordability, flexibility, and adaptability are central to this project.

1. Privacy by design

2. Affordable AI for small businesses

3. Flexibility without provider lock-in

Using open-weight models provides the flexibility to evaluate and potentially replace the model as better alternatives become available, without depending entirely on a single hosted AI provider.

4. Opportunities for domain-specific improvements

5. AI that supports rather than replaces human judgment

The model proposes a transaction, but the shopkeeper makes the final decision. This human-in-the-loop approach is particularly important when AI is handling financial information.

My Agent Session

Prize Categories

Open-Source AI / Open-Weight Models: Udhaar Khata uses an open-weight language model through browser-based inference with WebLLM and WebGPU.

Side Hustle: The project addresses a practical problem faced by small businesses and explores a free or low-cost product model built around local AI inference.

What's Next?

With Udhaar Khata, I wanted to explore how a small open-weight model can make an everyday task easier without taking control away from the person using it.

Udhaar Khata: The Notebook Behind the Counter

noneofurbusiness — Sun, 18 Oct 2026 11:14:21 +0000

Udhaar Khata: The Notebook Behind the Counter

What I Built

Digital alternatives often introduce too much friction through signups, complicated forms, and dropdowns. They may also require customers' financial information to be stored on someone else's server.

I built Udhaar Khata, a privacy-focused digital ledger that lets users record transactions in everyday language instead of filling out forms.

For example, a shopkeeper can type:

"Ramesh ne 500 udhaar liya, 200 kal dega."

The goal is to preserve the two best things about the traditional notebook—speed and privacy—while making records easier to maintain.

Who would pay for it?

Demo

Live application: https://udhaar-khata.onrender.com

Open the application in an up-to-date version of Chrome or Edge on a device that supports WebGPU. The first visit may take longer because the AI model needs to download.

Code

GitHub repository: https://github.com/yaansa/udhaar-khata

The project is built around local AI inference, natural-language transaction parsing, and a simple interface that keeps the user in control of financial records.

How I Built It

The workflow is straightforward:

The user enters a transaction in everyday Hindi, Hinglish, or English.
The model interprets the sentence and returns structured JSON.
The application validates the output and checks for missing or malformed fields.
The proposed transaction is displayed for review and editing.
The entry is saved only after the user confirms it.
A WhatsApp deep link can open a pre-filled payment reminder.

The application uses browser-side storage for ledger records and is hosted as a static website on Render, with the source code maintained on GitHub.

Why Does Open Innovation Matter?

Open innovation matters because privacy, affordability, flexibility, and adaptability are central to this project.

1. Privacy by design

2. Affordable AI for small businesses

3. Flexibility without provider lock-in

Using open-weight models provides the flexibility to evaluate and potentially replace the model as better alternatives become available, without depending entirely on a single hosted AI provider.

4. Opportunities for domain-specific improvements

5. AI that supports rather than replaces human judgment

The model proposes a transaction, but the shopkeeper makes the final decision. This human-in-the-loop approach is particularly important when AI is handling financial information.

My Agent Session

Prize Categories

Open-Source AI / Open-Weight Models: Udhaar Khata uses an open-weight language model through browser-based inference with WebLLM and WebGPU.

Side Hustle: The project addresses a practical problem faced by small businesses and explores a free or low-cost product model built around local AI inference.

What's Next?

With Udhaar Khata, I wanted to explore how a small open-weight model can make an everyday task easier without taking control away from the person using it.

RaahSaathi AI: An Offline Companion for Touching Grass

noneofurbusiness — Fri, 09 Oct 2026 06:47:46 +0000

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

What I Built

RaahSaathi AI is a local-first outdoor mission generator. You pick a mode (Walk, Nature or Garden) and a time (5, 10 or 20 minutes), and a small open-weight model running on your own machine gives you three screen-light missions, like "Find something red, then listen for three different sounds." You pick one, put the phone in your pocket, and go outside. When you come back, you type what you noticed and the app turns it into a short personal field note.

The screen is meant to be the shortest part of the experience. The AI is only there to give you a reason to look up. It is for anyone who spends too much of the day on a screen and wants a small, easy nudge to go for a walk, sit in a garden, or notice their own neighbourhood.

Demo

Live demo (Render, fallback mode): https://raahsaathi-1.onrender.com

The hosted version on Render uses predefined missions, because a free server cannot run a language model. The full AI experience runs locally with Ollama.

Code

https://github.com/yaansa/raahsaathi

How I Built It

Model: Gemma (gemma3:1b) served locally through Ollama. It is small enough to run on an ordinary laptop.
Backend: Python and FastAPI with three endpoints: /api/missions, /api/note and /api/history.
Storage: SQLite keeps every session (mission, reflection, field note) on the device.
Frontend: One plain HTML/CSS/JS page: choose a mode and time, tap a mission, write what you noticed.
Fallback: If the model is unavailable or returns bad output, the app picks from predefined missions, so the demo never breaks.
Hosting: The web interface is deployed on Render, running in fallback mode. The AI inference stays local.

The mission prompt gives the model an "outdoor activity designer" role and safety rules: no special equipment, no photographing strangers, no sending the user into roads, private property or unsafe areas, and each activity under 40 words.

What the small model got wrong

It added an intro line. The first card often read "Absolutely! Here are three safe activities...", wasting one of three slots. I added a filter that drops lines ending in a colon or starting with "Absolutely", "Sure" or "Here".
Missions were poetic, not actionable. "Feel the sunshine warm on your skin" is pleasant, but it is not a task. I added a rule that every mission must start with an action verb (Find, Count, Listen, Touch, Spot).
The field note invented a plan. Given "I found a rough leaf near the gate, it felt like sandpaper", the model ended the note with "I'm going to keep looking around for a different one", which I never said. I tightened the prompt to describe only what happened.

What happened when I took it outside

I did a 10-minute Walk Mode test on a nearby street. The mission I got was: "Observe something around you that you usually ignore during your daily routine."

What worked: A simple mission made an ordinary walk feel a little more intentional.
What failed: The mission was too open-ended. I wasn't sure what exactly to observe or do, which is the opposite of what a screen-light app needs. I shouldn't have to keep checking my phone to work out the task.
What I would change:
- Make missions short, specific and action-oriented ("Find three different sounds"), not "observe something".
- Add more creative, location-aware missions.
- Make the app usable without repeatedly checking the phone.

Why Does Open Innovation Matter?

RaahSaathi uses an open-weight model locally instead of a closed cloud API.

Privacy: Reflections and missions stay on the device. Nothing is sent to a remote service.
Offline use: Walks and hikes often have poor connectivity. A local model needs none.
Replaceable model: The model name is one line of config. A developer can swap in a smaller model, a newer Gemma, or one fine-tuned for a particular community.
Inspectable behaviour: The safety rules live in a prompt I can read and change. I did not have to trust a black box to keep users out of unsafe places.

The tradeoff is real: my hosted demo can only show fallback missions, because the intelligence lives on your machine, not on a server.

Prize Categories

Best Use of Gemma: Gemma runs locally and generates both the missions and the field notes.
Best Use of Render: The public web interface is deployed on Render, in fallback mode.

RaahSaathi AI: An Offline Companion for Touching Grass

noneofurbusiness — Fri, 09 Oct 2026 06:29:43 +0000

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

What I Built

Demo

Live demo (Render, fallback mode): https://raahsaathi-1.onrender.com

The hosted version on Render uses predefined missions, because a free server cannot run a language model. The full AI experience runs locally with Ollama.

Code

https://github.com/yaansa/raahsaathi

How I Built It

Model: Gemma (gemma3:1b) served locally through Ollama. It is small enough to run on an ordinary laptop.
Backend: Python and FastAPI with three endpoints: /api/missions, /api/note and /api/history.
Storage: SQLite keeps every session (mission, reflection, field note) on the device.
Frontend: One plain HTML/CSS/JS page: choose a mode and time, tap a mission, write what you noticed.
Fallback: If the model is unavailable or returns bad output, the app picks from predefined missions, so the demo never breaks.
Hosting: The web interface is deployed on Render, running in fallback mode. The AI inference stays local.

What the small model got wrong

It added an intro line. The first card often read "Absolutely! Here are three safe activities...", wasting one of three slots. I added a filter that drops lines ending in a colon or starting with "Absolutely", "Sure" or "Here".
Missions were poetic, not actionable. "Feel the sunshine warm on your skin" is pleasant, but it is not a task. I added a rule that every mission must start with an action verb (Find, Count, Listen, Touch, Spot).
The field note invented a plan. Given "I found a rough leaf near the gate, it felt like sandpaper", the model ended the note with "I'm going to keep looking around for a different one", which I never said. I tightened the prompt to describe only what happened.

What happened when I took it outside

I did a 10-minute Walk Mode test on a nearby street. The mission I got was: "Observe something around you that you usually ignore during your daily routine."

What worked: A simple mission made an ordinary walk feel a little more intentional.
What failed: The mission was too open-ended. I wasn't sure what exactly to observe or do, which is the opposite of what a screen-light app needs. I shouldn't have to keep checking my phone to work out the task.
What I would change:
- Make missions short, specific and action-oriented ("Find three different sounds"), not "observe something".
- Add more creative, location-aware missions.
- Make the app usable without repeatedly checking the phone.

Why Does Open Innovation Matter?

RaahSaathi uses an open-weight model locally instead of a closed cloud API.

Privacy: Reflections and missions stay on the device. Nothing is sent to a remote service.
Offline use: Walks and hikes often have poor connectivity. A local model needs none.
Replaceable model: The model name is one line of config. A developer can swap in a smaller model, a newer Gemma, or one fine-tuned for a particular community.
Inspectable behaviour: The safety rules live in a prompt I can read and change. I did not have to trust a black box to keep users out of unsafe places.

The tradeoff is real: my hosted demo can only show fallback missions, because the intelligence lives on your machine, not on a server.

Prize Categories

Best Use of Gemma: Gemma runs locally and generates both the missions and the field notes.
Best Use of Render: The public web interface is deployed on Render, in fallback mode.

Plan My Day — Private Offline AI Timetable Planner

noneofurbusiness — Sun, 04 Oct 2026 14:29:38 +0000

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

Plan My Day — A Private Offline AI Timetable Planner

What I Built

Plan My Day is a private, offline timetable planner that I built for a friend who has to fit a long to-do list around a fixed daily routine.

The user enters fixed commitments such as classes, meals and gym sessions, along with the tasks they need to complete. A locally hosted language model turns this information into a structured, time-blocked schedule.

The planner tries to respect fixed commitments and place demanding tasks within the user's preferred focus period whenever possible.

When plans change, the user can describe the change in plain language, such as "move gym to the evening," and the timetable is regenerated.

The main idea was to build something genuinely useful for a real person while keeping their daily routine private.

Nothing leaves the device. The schedule and personal routine are processed locally using Gemma through Ollama.

Demo

I tested Plan My Day with my friend using their real schedule, including their fixed commitments, actual tasks and preferred focus period.

I first generated a timetable from their inputs and then tested the natural-language editing feature by asking the planner to modify the schedule.

The screenshot below shows the Plan My Day interface and the generated timetable.

Plan My Day — generating a personalized timetable using a locally running Gemma model.

Code

The complete source code is available on GitHub:

https://github.com/yaansa/planmyday

The repository contains the HTML interface, timetable generation logic, Ollama integration and instructions for running the project locally.

How I Built It

Tech Stack

Model: Gemma 3, 4B parameters
Local model runtime: Ollama
Frontend: HTML, CSS and JavaScript
Architecture: Single HTML file with no framework and no backend
Hardware: Intel i5, 16 GB RAM and NVIDIA RTX 2050 with 4 GB VRAM

How It Works

The page collects the user's wake and sleep times, preferred focus period, fixed commitments and tasks.
These inputs are sent to the locally running Ollama endpoint.
Gemma is instructed to return the timetable in a strict JSON format containing start, end, title and type.
The application validates the model response before displaying it.
Valid timetable blocks are sorted chronologically and rendered as a visual schedule.
When the user wants to change the plan, the current timetable and the natural-language change request are sent back to the local model.
Gemma generates an updated schedule, which is validated and rendered again.

Challenges and Lessons Learned

Browser security: Opening the HTML file directly from disk caused the browser to block requests to Ollama. Serving the file through a local web server bound to 127.0.0.1 fixed the issue while keeping the application accessible only from my own machine.

Initial model setup: The first run requires a one-time download of the Gemma model, which is around 3.3 GB. After the model is installed, the application can run without an internet connection.

Structured output from a small model: A 4B model cannot always be expected to return perfectly structured data. I therefore instructed Gemma to return strict JSON and added validation on the client side. If the response is malformed, the application shows an error instead of rendering a broken timetable.

Why Does Open Innovation Matter?

A daily schedule can contain personal information such as class timings, work routines, exercise schedules and other parts of someone's daily life.

Because Plan My Day uses an open-weight model that runs locally, my friend's routine does not need to be sent to a third-party AI service.

The application does not require an account, API key or paid subscription.

Open models also provide flexibility. Users can select from models available through Ollama and choose a smaller model if they have limited hardware, without changing the core idea of the application.

This makes the project practical for students and other users who may not have access to paid AI APIs. Once the model is downloaded, the planner can work offline without per-request API costs.

For me, open innovation is valuable because it makes AI experimentation more accessible, private and adaptable. Instead of building around one hosted API, the application can work with locally available models and hardware.

What I Learned

Building Plan My Day taught me that using a local AI model is not only about connecting an application to an LLM.

I had to think about browser security, local networking, structured model outputs, validation and how to make AI-generated results reliable enough for an actual user.

The project also showed me how useful small local models can be when privacy and simplicity matter more than having access to a large cloud-based model.

Prize Category

Best Use of Gemma

Plan My Day uses Gemma 3 locally through Ollama to transform a user's routine and task list into a structured timetable and to revise that timetable based on natural-language change requests.

Links

GitHub: https://github.com/yaansa/planmyday

Built for: A real friend and their daily routine

Model: Gemma 3 (4B) running locally through Ollama

I Built an Offline AI Timetable Planner for a Friend Using Gemma

noneofurbusiness — Sun, 04 Oct 2026 13:55:02 +0000

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

What I Built

Plan My Day is a private, offline timetable planner that I built for a friend who has to fit a long to-do list around a fixed daily routine.

You enter your fixed commitments such as classes, meals and gym sessions, along with the tasks you need to finish. A locally hosted language model turns this information into a structured, time-blocked schedule.

It respects fixed commitments and places demanding work in the user's peak focus window whenever possible.

When plans change, you can describe the change in plain language, such as "move gym to the evening," and the timetable is revised.

Nothing leaves the device. The schedule and personal routine are processed locally using Gemma through Ollama.

Demo

I tested the tool with my friend using their real schedule: their fixed times, actual tasks and preferred focus time.

I generated a timetable using their inputs and then tested the natural-language editing feature by asking the planner to modify the schedule.

The screenshot below shows the Plan My Day interface and generated timetable.

Plan My Day — generating a personalized timetable using a locally running Gemma model.

Code

The complete source code is available on GitHub:

https://github.com/yaansa/planmyday

The repository contains the HTML interface, timetable generation logic, Ollama integration and instructions for running the project locally.

How I Built It

Stack

Model: Gemma 3, 4B parameters, served locally through Ollama
Interface: A single HTML file with no framework and no backend
Language: HTML, CSS and JavaScript
Hardware: Intel i5, 16 GB RAM and NVIDIA RTX 2050 with 4 GB VRAM

How it works

The page collects wake and sleep times, the peak focus period, fixed commitments and tasks.
These inputs are sent to the locally running Ollama endpoint.
Gemma is instructed to return the timetable in a strict JSON format containing start, end, title and type.
The page validates the model response before displaying it.
Valid timetable blocks are sorted chronologically and rendered as a visual schedule.
When the user wants to change the plan, the current timetable and the natural-language change request are sent back to the local model.
Gemma returns an updated schedule, which is validated and rendered again.

Lessons from the build

Setup cost: The first run requires a one-time download of the Gemma model, which is around 3.3 GB. It took about an hour on a slow connection, but after installation the application can run without an internet connection.

Small-model output: A 4B model cannot always be assumed to return perfectly structured data. I therefore instructed the model to return strict JSON and added validation on the client side. If the response is malformed, the application shows an error instead of rendering a broken timetable.

Why Does Open Innovation Matter?

A daily schedule can contain personal information such as class timings, work routines, exercise schedules and other parts of someone's daily life.

Because Plan My Day uses an open-weight model that runs locally, my friend's routine does not need to be sent to a third-party AI service. The application does not require an account, API key or paid subscription.

Open models also provide flexibility. The model can be selected from the models installed in Ollama, so users can choose a smaller model if they have weaker hardware without changing the application's core logic.

This makes the project practical for students and other users who may not have access to paid AI APIs. Once the model is downloaded, the planner can work offline and does not incur per-request API costs.

Prize Categories

Best Use of Gemma

Plan My Day uses Gemma 3 locally through Ollama to transform a user's routine and task list into a structured timetable and to revise that timetable based on natural-language change requests.