I Built Mimu Because Even Taking Notes Is Too Much Work

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

I have a lot of ideas. Sometimes they're useful. Sometimes they're not. And sometimes I think of something I want to remember while I'm doing something completely unrelated.

The problem is that stopping to organize those thoughts feels like a whole separate task. Give a note a title, decide where it belongs, add tags, maybe set a reminder... suddenly the tiny thought I wanted to save has homework.

So when this week's challenge asked us to build something that rewards laziness, I knew exactly which chore I wanted to avoid.

I built Mimu, a little voice-note companion that lets me say what's on my mind and get on with my day. The note-taking is my part. The note-organizing is Mimu's.

And because I wanted to experiment with open models, the AI runs on devices I control rather than through a paid AI API.

What I Built

Mimu remembers for you.

On my phone, I tap the microphone, ramble for a few seconds, check the transcript, and save it. Whisper transcribes the audio in the browser. Later, a small Gemma model running on my computer turns that raw thought into a note with a useful title, formatted Markdown, a category, and tags.

The original transcript stays intact, so I can always see what I actually said. And if I don't feel like talking, I can type instead.

For example, I might say, "I need to call the dentist Thursday at two." Mimu can save that as an organized note with a due date instead of leaving me to remember which of my 47 scattered notes contains the dentist's appointment.

It also has a few features I added after getting the basic idea working:

• Ask Mimu: Ask questions like "Who do I need to call?" and get an answer based on your saved notes, with links to the notes it used.
• Morning digest and reminders: The desktop model prepares a short summary of what's due today and what I saved yesterday. Due-time reminders can be sent to the phone without needing the desktop to stay on.
• Search and editing: Find notes by words, categories, and tags, or fix anything yourself without having the model overwrite it later.
• Offline capture: Notes wait on the phone if the connection drops and sync when it comes back.
• Markdown export: Save one note as .md or export everything as a ZIP of Markdown files. My notes don't have to live inside Mimu forever.

It's a responsive web app, so I can capture and browse notes on my phone and work through the library on a bigger screen. I gave it a tiny mascot, too, because apparently I cannot build an app without giving it a face.

[Insert mobile screenshots]

Demo

Try Mimu: https://mimu.pinkpixel.dev

I made a hosted demo because I didn't want the first thing a judge had to do to be "create two cloud accounts and configure a database." You can start a demo account or sign in with GitHub and explore sample notes right away.

To watch your own notes get organized by AI, you'll need Ollama on a computer. Mimu's Desktop page gives you a command to install and connect the Node worker, which downloads the Gemma model the first time. You can pair your phone by scanning a QR code. The app works as a note library without that worker, but Gemma-powered organizing, Ask, and digests need it running.

One important privacy detail: in the hosted demo, note text is stored in a separate database for each demo account under my Turso setup. Audio isn't uploaded; it's transcribed on the device and discarded. The language model still runs on the user's own computer. Anyone who prefers their own infrastructure can self-host Mimu instead.

Code

The source is available here:

pinkpixel-dev / mimu

Speak a thought, and a local AI sorts it into searchable Markdown notes.

Mimu

Mimu remembers for you.

Mimu is a voice notes app for people with too many ideas and not enough patience for note-taking. You tap the mic on your phone, say whatever's on your mind, and it's saved. Later, a model running on your own computer turns those rambling transcripts into tidy Markdown notes with a title, a category, and tags. You can search them, edit them, and export the whole library as plain Markdown whenever you want.

The speech recognition runs on your phone, and the organizing runs on your desktop. No paid AI API is involved anywhere.

See it in action

Here's a quick demo video. Click the thumbnail to watch it on YouTube.

Desktop

Mobile

Try it

There's a hosted demo at mimu.pinkpixel.dev, so you don't need a Turso or Cloudflare account to try Mimu.

1. Open the site and tap Start a demo (or Continue with…

View on GitHub

The README includes the setup instructions, architecture, and a quickstart for deploying your own copy.

How I Built It

I started on October 20, which happened to be International Sloth Day. Appropriate timing for an app dedicated to doing less.

My first plan was a phone app and a separate Tauri desktop app. Then I looked at the deadline and remembered that I am, unfortunately, only one person. I went with one React PWA that works on both screens and a headless Node worker on the desktop. It meant I could spend more of the week making the whole experience actually work, rather than maintaining two UIs.

The main pieces are:

• Whisper tiny (English) through Transformers.js for speech-to-text in the browser.
• Gemma 4 gemma4:e4b through Ollama on my computer for organizing notes, interpreting dates, writing digests, and answering questions.
• React + Vite for the PWA, Hono on Cloudflare Workers for the API, and Turso/libSQL for note storage and full-text search.
• A Node worker that picks up pending jobs, talks to Gemma locally, and sends the results back through the API.

The audio is handled on the phone. The saved text travels through the API to the database, and the desktop worker reads that text to process it. So this is local AI inference, not an entirely offline app. I think that distinction matters.

The bigger model wasn't better

Before settling on Gemma, I tested three sizes against ten messy sample notes, using structured JSON output through Ollama.

Gemma model	Valid JSON	Median time per note
gemma4:e2b	10/10	3.2s
gemma4:e4b	10/10	3.4s
gemma4:12b	10/10	13.7s

The funny thing is that all three were worse at organizing categories when I gave them a bad instruction. I told them to reuse existing categories "even loosely," and suddenly a grocery list was a "General Thought" and a failing CI build belonged with software ideas.

A much more specific rule about types of notes fixed the problem. E4B made six sensible categories in that test, without the extra wait from the 12B model. That was a useful reminder that throwing a bigger model at a vague prompt doesn't necessarily fix the prompt.

My phone had other plans

I initially tried Whisper with WebGPU. It looked promising until I tested it on my iPhone: the model download hit 100%, Safari reloaded, and I got to repeat the whole experience. No visible error. Just goodbye.

I added little diagnostic breadcrumbs that survived a reload and tracked the crash to ONNX session setup. The browser could detect a WebGPU adapter, but that didn't mean the model could actually run on it.

Switching to WASM fixed the issue. On the same phone, the model loaded in about 3.3 seconds and transcribed a three-second audio clip in about 1.8 seconds. For a model this small, WASM was also competitive on my desktop, so I made it the default everywhere.

I learned more from testing on a real phone than from a lot of happy-path desktop tests.

The tricky part wasn't formatting. It was not making things up.

At one point, Whisper misheard a phrase and Gemma confidently cleaned it up into something that meant the opposite of what I had said. The resulting note looked wonderfully polished. It was also wrong.

That's a dangerous failure for an app that's supposed to remember things for me.

I experimented with ways to make Gemma flag suspicious transcript fragments instead of quietly repairing them. In a small repeated test with deliberately garbled and clean phrases, asking for uncertainty inside the main organizing call caught only some of the errors. Giving uncertainty detection its own tiny model pass caught all ten garbled examples with no false alarms in that test, at roughly 0.6 seconds more per note.

Mimu now has a little "Mimu wasn't sure about" section, and the app verifies that a flagged phrase really appeared in the transcript. It doesn't eliminate every possible transcription error, but it gives me a chance to fix something ambiguous instead of trusting a very convincing invention.

I kept giving my lazy app more work

Once the capture-and-organize loop worked, I wanted Mimu to do more than make a neat pile of notes.

I added natural-language due dates, so "Thursday at two" can become an actual date and time. In my test of 16 phrases run twice, giving Gemma the capture timestamp and timezone produced 32/32 correct date-and-time results. Adding a calendar cheat sheet actually made it worse. That one surprised me.

Then came Ask Mimu, morning digests, and reminders. Ask uses full-text search first, then has Gemma answer from the retrieved notes, with references checked against the notes it received. If the search finds nothing, it says so instead of improvising.

The final result still has more moving pieces than my original "just let me talk" idea. But they're moving so I don't have to.

Why Does Open Innovation Matter?

Mimu wouldn't be the same project if every voice note had to go through a paid transcription API and every bit of organizing required another hosted model call.

Using open models let me decide where the work happens. Whisper runs right in the browser, so audio doesn't have to leave the phone. Gemma runs on my own computer through Ollama, so I can experiment with prompts, swap model sizes, and keep using the AI features without paying per note or per question.

It also meant I could test the model's actual behavior instead of treating it like a mysterious service. I could compare sizes, measure timings, change how uncertainty was handled, and build simple checks around what the model returned.

There are trade-offs. You need a computer capable of running the model, and some features aren't available until the desktop worker connects. The app also uses cloud storage to sync text between devices, so I'm not claiming the whole system is private-by-default or offline. But the audio stays on the phone, inference happens locally, and you can deploy the app under your own accounts. And your notes can leave as Markdown whenever you want.

That combination of control, portability, and the freedom to tinker is what made this project exciting to me.

The Lazy Payoff

I haven't done a formal time-savings study, so I'm not going to pretend Mimu saves an exact number of minutes every day. The benefit I was going for is smaller and more familiar: removing the little bits of friction that make me not bother writing something down at all.

Instead of stopping to decide on a title, folder, tags, and maybe a reminder, I can just talk. And later, I can search for the thought without remembering how I named it. That's the kind of laziness I can get behind.

I did test the complete flow with a real phone and laptop: start a demo, connect the worker, pair the phone, speak a note, and watch Gemma organize it. I also tested offline capture and resync. Those aren't hypothetical features in a mockup; they worked in my end-to-end tests.

The part I still want to keep testing is how well it handles real, everyday notes over time. A clean demo with a few examples is one thing. A growing pile of random thoughts from my brain is an entirely different workload.

Which, conveniently, I can provide in abundance.

Prize Categories

I'm entering Best Use of Gemma. Gemma 4 is the core of Mimu's note organization, date extraction, question-answering, and digests, running locally through Ollama.

---