I fired myself as my own librarian: LazyScholar, an unattended knowledge butler powered by a local Gemma

season — Sat, 24 Oct 2026 11:11:59 +0000

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

What I Built

Every productivity tool I tried asked me to be more disciplined. So I built one that asks me for nothing.

LazyScholar is a local knowledge butler for Windows — a Grammarly-style floating sidebar, a comfortable paper reader, and a local Gemma 3 4B (GGUF) running in llama.cpp. No cloud model API, no Ollama, Obsidian optional. It ships as one packaged LazyScholar.exe you can just double-click (you only need the Edge WebView2 Runtime; a model is only needed when you want notes generated, not for reading).

Download v1.0.0:
https://github.com/lood31/lazyscholar/releases/tag/v1.0.0

The queue: three ways in, reading first

From the panel's queue tab you can add:

an arXiv link or ID,
a local PDF whose filename contains its arXiv ID, or
a saved static webpage — .html/.htm or .mhtml/.mht — no arXiv ID required. Import reads only local/embedded resources: it keeps safe images, SVGs and native MathML, never executes the page's scripts, and never goes online to fetch missing pieces.

Processing can run immediately or at a scheduled time, with the model started and stopped automatically. But reading no longer waits for any of that:

Read now. Click it on a queue item and you are reading — no model started, no note required. Reading and generation are decoupled; a missing note is shown as missing, it does not block the article, the PDF, or your annotations. Imported local PDFs read fully offline.

The note: the whole text, with receipts

This is the part that changed most since my earlier drafts, so let me be precise. The desktop queue does not summarize the abstract:

It reads the actual source text — arXiv HTML (or the complete PDF text layer when HTML is unavailable), the imported local PDF, or the imported webpage text. It never silently falls back to an abstract.
All extractable text is processed in chunks. For each chunk the model selects source-passage IDs; the application then retrieves the corresponding extracted text itself, so quotations come from the source, not from the model's memory.
Those evidenced passages are merged hierarchically into the final study note, and every final section must cite valid source IDs such as [C0001]. The fingerprints and evidence are saved alongside the note, and the note discloses its actual source and limits.

Failure is explicit, by design: a source over the chunk limit or an invalid model result fails loudly — no dropped tail, no half-written note, and never overwriting an existing good note. A scanned PDF with no text layer cannot produce a text note, but its pages remain readable.

One more small, deliberate detail: generated content follows the interface language saved when the task starts (Chinese or English) — chunk analysis, intermediate merges and the final guide. Switching the UI language later does not translate or rewrite existing notes, and a running task keeps its starting language.

Honesty boundary, stated in the release notes too: this is processing of extracted text, not an understanding of every figure, formula or page layout, and a valid source ID proves where evidence came from — not that the model's interpretation is correct. Check the key claims against the original. (The old command-line inbox path is retained as a separate entry point and still produces abstract-based notes; it is not the desktop queue described above.)

The reader: the original, comfortably

In-app arXiv HTML reader: the paper's original HTML is fetched and cached automatically, formulas render locally as MathML exactly as published — the model never gets to rewrite an equation. Font size is adjustable, wide formulas scroll horizontally, and figures and formulas open enlarged on click.
Highlighting with a partial eraser: select text to highlight it, persistently. The eraser removes only the segment you select — erase the middle of a highlight and both ends stay. If two reader windows edit annotations at once, saves are revision-checked: on conflict the app re-reads and reapplies your change instead of overwriting the newer one, and a persistent conflict surfaces as an explicit retry error.
Comfortable PDF reading: the original PDF opens at 150% by default, with zoom, fit-width and horizontal scrolling; pages are rendered on demand (higher-resolution on high-DPI displays), and a Larger window button opens a separate, resizable reader window that shares the same annotations.

Deleting things, safely

Delete works from the Notes or Queue toolbar for one paper at a time, behind a compact in-app confirmation. The note, its confirmed app-owned caches, annotations and evidence go to the Windows Recycle Bin — never a permanent-delete fallback. External original files are untouched, one paper may produce several Recycle Bin entries, and partial success is reported as partial, with a metadata receipt (paper_deletions.json, receipts only — no paper-content copies) so you can retry. Restore the items in Windows and the app verifies paths and fingerprints before restoring queue metadata. Stale requests from before a delete/restore/re-import are isolated by a reader lifecycle epoch, so a delayed write from an old window cannot mutate the restored state.

The shell around it all

A small floating ball docks at the right edge of the screen — a frosted pill shape with the app icon, sliding only up and down along that edge — and opens the floating panel: model controls (start/stop/test inside the app), the queue, the reader and notes, and settings (theme, font, schedule, Chinese/English UI). The app lives in the system tray and is single-instance.

Demo

Download v1.0.0 (EXE + SHA-256, manually verified build):
https://github.com/lood31/lazyscholar/releases/tag/v1.0.0

Code

https://github.com/lood31/lazyscholar

How I Built It

Python for the app and pipeline, llama.cpp serving Gemma 3 4B QAT GGUF locally (llama serve, context 16384 by default), notes stored as plain Markdown files in a vault folder you choose.
The desktop shell taught me the most. My first floating-ball attempt used a webview transparency flag that, I later found in the official docs, is simply not supported on Windows — it rendered as a white square. The fix was to leave the webview for the ball: a native Win32 layered window with a Pillow-rendered ball image (per-pixel alpha, shadow baked in), pystray for tray residency, a named mutex for single-instance, and DWM attributes for the panel's rounded corners and shadow.
Because I cannot watch my own laptop screen while an AI agent codes on it, the repository has a GitHub Actions workflow: every push builds the .exe on a Windows runner, launches it, runs smoke and backend regression checks, and publishes QA screenshots to a ci-qa branch. The agent reviews the screenshots itself — that loop is how the ball and panel were verified without me taking a single screenshot. (Known wart, visible in those very screenshots: raw.githubusercontent serves the ci-qa images with stale CDN caching, so I learned to check file hashes and the screenshot clock before trusting what I was looking at.)
The process was deliberately engineering-first after an early version failed visual acceptance: research real implementations, write a spec (a single DESIGN.md as the source of truth), get it approved, then implement in increments, then verify against screenshots.
The reader follows the same honesty rule as the note pipeline: fetch and cache the publisher's HTML, render MathML as-is, keep highlights as plain persisted data, and make the model cite passage IDs the application can check — no model in a position where it could silently corrupt the source.
Deletion was built to the same standard: native Windows recycling via pywin32, receipts instead of copies, conflict-checked annotation saves, and explicit errors instead of fallbacks wherever "just delete it" would have been easier.

Why Does Open Innovation Matter?

Everything here runs on open weights and open tools, and that is not decoration:

Privacy: my reading notes and chat logs never leave my machine — there is no API to send them to.
Offline: reading works with the network cable pulled, and the whole generation pipeline is local too (arXiv fetching aside).
Zero marginal cost: no per-token bill, so the butler can keep filing notes forever on a student budget.
Hackability: the note template is just a prompt in my own code; I changed it twice in one evening.

My Agent Session

This project was pair-built with AI agents, honestly and sometimes painfully. An agent ran my laptop remotely over SSH while I was at swimming practice, set up the vault and model, and got the core pipeline working a day early. It also shipped a UI I rejected on sight (white-square ball, wall-sized panel, no tray icon) — which is what forced the research → spec → approval workflow above, and the CI screenshot loop.

Development did not stop there. A second agent (running on the laptop) kept building on that foundation — the in-app reader and highlighting first, then the full-text pipeline with evidence checking, saved-webpage import, the comfortable PDF reader, Read-now, and the Recycle-Bin deletion lifecycle — while I reviewed deliveries against what was promised, and cut planned features rather than pretend they shipped. I then shipped v1.0.0 myself: the Release's LazyScholar.exe is the manually verified build I accepted, published as-is with its SHA-256 — not a CI rebuild swapped in afterwards. What is in this post is what is in that release, nothing more.

The Lazy Payoff

Before: finishing a paper meant ~15 minutes of manual note-taking I never actually kept up, then hunting through three apps to re-read the original — and any summary I did have was only ever about the abstract.
After: I add a paper (or a saved webpage) to the queue and read it immediately, formulas intact, ready to highlight. When I want the guide, the local model reads the whole extractable text — chunk by chunk, with source references I can check — and files it for me. And when I clean up, deletion goes through the Windows Recycle Bin with a receipt, not into the void.

Prize Categories

Overall
Best Use of Gemma

DEV Community: season