DEV Community: NIRAJ THAPA

# Marigold: A Quiet Ofrenda for the Ghost in the Machine

NIRAJ THAPA — Sun, 01 Nov 2026 13:10:41 +0000

What I Built

Marigold is a private, local-first digital ofrenda: a small place to collect the details, stories, and qualities that help keep someone close.

The “ghost” here is not an AI pretending to speak for someone who has died. It is the way memory lingers in ordinary details. Marigold lets you write those details yourself, or—if you choose—ask a local model for help getting past a blank page.

You can save, edit, and delete remembrances in your browser, and export or import a JSON backup. When you press Help me find the words, Marigold sends the fields you entered to an Ollama model running on your own computer. The result is a short, editable suggestion. The app reminds you to check it, because a local model can still invent details.

Demo

There is no hosted demo yet; Marigold runs locally. Install Ollama, download the default model, start Ollama, and run:

python3 server.py

Then open http://127.0.0.1:8000. The full setup is in the repository README.

Code

Nirajkam / lastweek_octuber

Marigold

A private, local-first digital ofrenda for gathering memories and shaping them into an editable remembrance. Marigold uses a locally running Ollama model for drafting; it does not send stories to a hosted AI service.

What it does

Keeps saved remembrances in this browser's local storage.
Uses an open-weight model through Ollama on your computer to help write a first draft.
Lets you edit, delete, export, and import your memories.
Makes no analytics or third-party network requests.

The local model only receives the fields you enter when you choose Help me find the words. The app does not contact the model until you press that button.

Run it

Install Ollama and download a model once:
```
ollama pull qwen2.5:3b
```
Start Ollama if it is not already running.
From this folder, start the app:
```
python3 server.py
```
Open http://127.0.0.1:8000.

The first model download needs internet. After it is downloaded, the app…

View on GitHub

The project is released under the MIT License.

How I Built It

The interface is plain HTML, CSS, and JavaScript. A small Python standard-library server serves the app and provides two local endpoints: one to discover installed Ollama models and one to request a draft. Remembrances stay in browser localStorage; the model is contacted only after the person asks for a draft.

The README uses qwen2.5:3b as the suggested Ollama model. Marigold prefers it when installed and otherwise lets you select another installed model. No hosted AI API or analytics service is part of the app.

Why Does Open Innovation Matter?

Open-weight models and a local runtime make privacy a practical choice, not just a promise from a hosted service. There is no API key or remote inference provider between a person and their remembrance. Once the model is downloaded, the app can be used offline.

The small codebase is also inspectable and adaptable: people can see what text is sent to the model, change the prompt, or choose another model that works with Ollama.

The Spirit of It

I wanted the AI to have a deliberately modest role. It can help someone find a first sentence, but it should not impersonate a loved one, claim to know them, or turn missing details into plausible-sounding facts. The person remembers; the model offers a draft; the person decides what is true enough to keep.

# SlothSort: a local-first file organizer for people who would rather not sort files

NIRAJ THAPA — Sun, 25 Oct 2026 10:16:28 +0000

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

What I Built

My Downloads folder tends to collect files faster than I feel like organizing them. SlothSort is a small Python command-line tool that sorts files into folders such as Documents, Images, Videos, Audio, Code, and Archives.

Point it at a folder to preview a cleanup or organize the files in one pass. It can also watch a folder and sort new files after they finish downloading. It skips hidden and temporary files, avoids overwriting duplicate names, and never opens file contents.

Demo

SlothSort is a local command-line app, not a hosted web page. Try it from a terminal:

python main.py ~/Downloads --dry-run
python main.py ~/Downloads --once
python main.py ~/Downloads --watch

The first command previews proposed moves without changing files. The second organizes the folder once; the third watches for new files. Ollama is optional: when it is unavailable, SlothSort falls back to filename and extension rules.

Code

View the SlothSort source on GitHub

How I Built It

SlothSort is written in Python. It sends a filename (not file contents) to a local Ollama server for classification, using gemma3:4b by default. If Ollama is unavailable or does not return a recognized category, filename and extension rules provide a fallback.

Folder watcher or one-time scan
             |
             v
 Filename-only classification
       /             \
 local Ollama     filename rules
       \             /
             v
   preview or move file

The local model call is made to http://localhost:11434; there is no hosted AI API in the app. The dry-run option makes it possible to inspect planned destinations before moving anything.

To set up the project, install the Python dependencies with pip install -r requirements.txt. For local model classification, install Ollama and run ollama pull gemma3:4b; otherwise the built-in rules still work.

Why Does Open Innovation Matter?

Open-weight models and local inference make this kind of utility practical without sending filenames to a hosted AI service. I can run the organizer on my own machine, inspect how it classifies files, and keep the fallback behavior useful even when the model is not running.

My Agent Session

I do not have a shareable agent-session link to include.

The Lazy Payoff

Instead of manually making folders and dragging each file into place, I can preview or run one command. I have not measured a time-saved figure yet, so I will not claim a number.

Pocket Ledger: Turn a Shoebox of Receipts into a Tax-Ready CSV, Offline with Ollama

NIRAJ THAPA — Sun, 18 Oct 2026 02:15:44 +0000

What I Built

Pocket Ledger is an offline-first receipt and invoice sorter built for freelancers, contractors, and small teams who want a faster way to organize financial paperwork without sacrificing privacy.

The app lets users upload PDFs or images of receipts, extracts key details like vendor, date, amount, currency, and category using an AI model, and then automatically copies the files into organized folders. It also generates an editable CSV for bookkeeping and tax prep.

This solves a real pain point: manually sorting receipts is tedious, error-prone, and time-consuming. Pocket Ledger turns that workflow into a simple “upload → review → export” process while keeping the experience local-first and flexible.

I built the app locally and ran it in development with Streamlit:

Local demo: https://youtube.com/shorts/TDSnhUZL1Lk
Repo: https://github.com/Nirajkam/Week2challageof_hackoctoberfest2026

A quick walkthrough:

Upload PDF or image receipts
Choose a local Ollama model or a cloud provider
Let the app extract structured fields
Review the generated entries
Export organized files and CSV data

Code

GitHub: https://github.com/Nirajkam/Week2challageof_hackoctoberfest2026

How I Built It

I built Pocket Ledger with Python and Streamlit, using an open-source-first AI workflow.

The app supports multiple LLM providers:

Ollama (local/offline)
OpenAI
Google Gemini
Anthropic Claude
Groq

For local use, the project works with Ollama models such as gemma3:4b, llava, and moondream, so sensitive documents can stay on the user’s machine. For cloud use, users can plug in a provider and API key.

The backend does a few things:

Reads image/PDF input
Extracts text from PDFs using PyMuPDF when needed
Sends the document to the chosen model with a strict JSON schema prompt
Validates the returned data
Organizes files into category/year folders without overwriting duplicates
Writes a CSV for review and export

This keeps the system modular and model-agnostic, which makes it easy to swap providers without changing the app workflow.

Why Does Open Innovation Matter?

Open innovation matters here because financial documents are sensitive, and not everyone wants to send personal or business data to a third-party service.

Using open-source models through Ollama and flexible provider support makes the app:

private by default
local-first when needed
accessible to people without a fixed vendor lock-in
easier to adapt for different budgets and use cases

A closed API-only approach would have forced users to trust a single provider and often required uploading receipts to the cloud. Open-source models and local inference make it possible to build something more privacy-conscious and more accessible to everyday freelancers and small businesses.

My Agent Session

I’m documenting the build process and session history while refining the project, and I plan to save the final agent session alongside the project notes for transparency and reproducibility.

Prize Categories

Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle

This project fits the “side hustle” spirit by turning a practical daily pain point into a useful, open-source AI workflow that can be extended by others.

Outside: a private streak app that listens to your walk with open-source AI

NIRAJ THAPA — Thu, 08 Oct 2026 11:36:35 +0000

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

What I Built

Outside is a small, private Android app that gets me off the screen and into the world. I tap "I'm outside", put the phone in my pocket, and walk. While I'm out, the app listens to the sounds around me and writes them into a journal, so a walk becomes "Birds, water, wind" instead of just "20 minutes."

Streak with rest days: an animated flame counts consecutive days outside. You earn one rest day for every 7 days outside, so one missed day doesn't wipe out your streak.
Automatic sound journal: it labels sounds in 5-second windows (birds, wind and leaves, water, traffic, voices, animals, bells, footsteps) and saves only the labels.
Approximate step count from the phone's motion sensor.
Time-of-day sky: the header changes from dawn to night with the clock.
Journal as text: any walk can be exported as plain text that I own.

It is for anyone who wants a gentle reason to go outside. It is deliberately not social: no account, no feed, no photo posting, no server. The screen is only used for a few seconds at the start and end of a walk.

Demo

Code

https://github.com/Nirajkam/outsideapp_week1challage_hacktoberfest

How I Built It

Open-weight model: YAMNet by Google (Apache 2.0), which recognizes 521 sound classes. It runs fully on the phone through TensorFlow.js, with the model files bundled inside the app.
App: plain HTML, CSS, and JavaScript, wrapped as an Android app with Capacitor. Everything is stored in local storage on the device.
Turning raw classes into a journal: I grouped the 521 classes into 8 friendly categories. Steady sounds (water, wind, traffic) are scored by their average over a window, and short sounds like birdsong by their peak.
Listening loop: it starts when a walk starts and stops when it ends. It keeps the screen awake so the microphone keeps working, and classifies 5-second windows in memory.
Debug view: the app shows the model's top 3 raw guesses on screen, which made tuning much easier.

What I Learned From Testing

I tested by playing sounds near the microphone. Speech was picked up and labeled as "Voices". My first waterfall test was not detected at all. The model's raw classes for running water were missing from my "water" group, and my detection threshold was too high for a steady sound. I added more water-related classes (rain on surface, waves, gush, spray), lowered the water threshold, and switched steady sounds to window averages.

Limits I want to be upfront about:

It labels sound types, not species. It says "Birds", not "robin".
It only listens while the app is open and the screen is on, which costs battery.
Steps are an estimate from the accelerometer, not a real pedometer.
Android only for now.

Why Does Open Innovation Matter?

Privacy: microphone audio never leaves the phone. It's classified in memory for a few seconds and then discarded, and only the labels are saved. With a closed cloud audio API, recordings of my walks would go to someone else's server.
It works with no signal: the model ships inside the app, so it can work on a trail with no coverage, which is where an outdoor app is most useful.
Free to run: no API keys, no per-request cost, no subscription.
I could change it: the model is a plain TensorFlow.js file and the category mapping is a JSON file. When water detection failed, I fixed it by editing the mapping and thresholds, which I couldn't have done with a closed black-box API.

Prize Categories

This project uses YAMNet, not Gemma, so I'm not entering Best Use of Gemma. I'm entering the overall prize.