Draku: Exorcising the Ghosts in Your Camera Roll with Offline Open-Weight AI 🦇

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

You are standing at the pharmacy counter. The pharmacist asks for your prescription. You know it is on your phone—somewhere between 4,000 WhatsApp forwards, food photos, and old boarding passes. You scroll past IMG-20261011-WA0004.jpg, Screenshot_2026-09-14.png, and scan_final_v2.pdf.

Screenshots are the most-used notebook on earth that nobody calls a notebook. The problem is that a screenshot stores pixels, not meaning. And inside those pixels live four kinds of digital ghosts haunting every laptop and phone:

Meet Draku—a fluffy black cat with crimson bat wings and eyes full of black flames. He sees everything on your device, and he tells no one.

Draku is a 100% offline, open-source desktop application (built with Tauri) that reads every screenshot, photo, and PDF in a folder once using local PaddleOCR and Google's open-weight EmbeddingGemma, turning that single reading into four concrete outcomes:

IMG-20261011-WA0004.jpg into 2026-10-11 Dr Patel blood test prescription.jpg and embeds the semantic context so you can type "blood test" or "router password" in plain English and find it instantly. Zero bytes uploaded. Zero accounts. Zero settings screens.

Every capture below is recorded directly from the real desktop application on Windows with Wi-Fi off and Airplane Mode visibly enabled—no cloud calls, no mockups, no staged telemetry. The full airplane-mode walkthrough script lives in the repo as DEMO.md.

Local PaddleOCR extracts the text, a structured rule-reader extracts human naming cues, and Google's EmbeddingGemma-300M embeds the reading into a 768-dimensional local vector. Type "internet password" and the router login surface appears immediately—pure meaning match with zero keyword overlap.

Dates are extracted alongside their surrounding contextual words, allowing Draku to recognize that "Warranty ends in 6 days" or "Refill by 10 Nov" is an actionable deadline rather than an old receipt date. One click generates an RFC-compliant .ics calendar file accepted by your system calendar—no cloud sync intermediary.

PaddleOCR returns exact pixel bounding boxes for sensitive ID numbers, card digits, and credentials. Clicking "Make a safe copy" burns irreversible pixelation blur directly into new pixel buffers and strips hidden EXIF location metadata. The original document remains untouched.

Before and after, side by side — the sensitive ID number and GPS coordinates visible in the first frame are permanently eradicated in the safe copy:

Expired boarding passes, old OTP screenshots, and blurry duplicates earn transparent, inspectable "dead file" scores with human-readable explanations. Clicking "Set aside" lays them to rest in .draku/rest/—never deleted, completely reversible with one-tap Undo.

Your files, finally understood.

Draku is a free, open-source, on-device AI file manager for Windows. It reads every screenshot, photo and PDF on your machine — it finds what you need warns you before a date passes, hides what should stay private, and lets go of what is dead. Nothing leaves your machine.

Built for Hacktoberfest 2026 · Week 4 — Ghost in the Machine.

draku/
├── CONTEXT.md     ← project context: plan, stack, tokens, status (read first)
├── site/          ← the landing page (static HTML/CSS/JS + WebGL embers)
├── app/           ← the product: Tauri 2 desktop app (Rust + React/TypeScript)
│   ├── src/           One Screen UI, mascot design tokens (tokens.css)
│   ├── scripts/       bundle prep + one-time model fetch for source builds
│   └── src-tauri/     scanner · reader · OCR · embeddings · actions
└── site/About.md

… To build and run Draku from source (fetches the local models once, then runs completely offline forever):

git clone https://github.com/0dvsh0/draku && cd draku/app
npm install && node scripts/fetch-model.mjs
npm run tauri dev
draku/
├── site/               ← Interactive web sandbox & landing page (vanilla HTML/CSS/JS, WebGL embers)
└── app/
    ├── src/            ← The One Screen UI (React 19 + TypeScript, mascot design tokens)
    ├── scripts/        ← Model fetchers, NSIS installer packager, automated CI smoke test
    └── src-tauri/      ← Native Rust core touching every byte
        ├── scan.rs     ← Folder walker + dHash perceptual duplicate detection
        ├── extract/    ← The READER: PaddleOCR, PDF text parser, kamadak-exif, rule reader
        ├── embed.rs    ← Bundled EmbeddingGemma-300M  + local cosine similarity search
        ├── score.rs    ← Transparent "Let Go" arithmetic engine — weights you can read
        ├── store.rs    ← SQLite (WAL mode) — single local embedded DB, zero daemons
        └── actions.rs  ← Safe copies, .ics generation, set-aside / restore (the ONLY disk mutations)

EmbeddingGemma's 4-bit quantized weights ship inside the installer as model_q4.onnx alongside an external initializer file. Draku's native Rust core loads both in memory directly into ONNX Runtime with DirectML hardware acceleration—without requiring CUDA or external services:

// app/src-tauri/src/embed.rs — the offline path is the only shipped path
let mut bundled = UserDefinedEmbeddingModel::new(read("model_q4.onnx")?, TokenizerFiles {
    tokenizer_file:          read("tokenizer.json")?,
    config_file:             read("config.json")?,
    special_tokens_map_file: read("special_tokens_map.json")?,
    tokenizer_config_file:   read("tokenizer_config.json")?,
})
.with_pooling(Pooling::Mean)
.with_quantization(QuantizationMode::None)
.with_external_initializer("model_q4.onnx_data".into(), read("model_q4.onnx_data")?);

TextEmbedding::try_new_from_user_defined(bundled, InitOptionsUserDefined::new())

When you search "internet password", your query is converted to a 768-dimensional vector, and cosine similarity matches against local readings in SQLite. There is no HTTP client anywhere in the crate.

Rather than relying on an unexplainable black-box classifier, score.rs exposes a plain struct of inspectable signals. Every weight is an auditable constant with a clear rationale:

// app/src-tauri/src/score.rs
pub fn judge(s: &Signals) -> Verdict {
    let mut score = 0.10;
    score += (s.age_days / 180.0).min(0.30);
    if s.is_otp      { score += 0.44; }   // one-time codes only live once
    if s.date_passed { score += 0.50; }   // the deadline is gone; the file overstayed
    if s.is_dup      { score += 0.50; }   // a near-identical file exists
    // …the result clamps to [0, 1]; above 0.60 a file earns the Let-go card
    Verdict { dead: score.clamp(0.0, 1.0), reason: choose_reason(&s) }
}

--no-default-features) for machines that cannot run PaddleOCR. scripts/smoke-test-installer.mjs, wired into GitHub Actions, silent-installs the NSIS package on a clean Windows runner and verifies every bundled binary: draku.exe, DirectML.dll, all 4 OCR models, and all 6 embedding files. SHA256: 19473E9A5AEC88BDE82DF50CD697E7A9450A0B0EA88B49E65B57F89843E52791 Most AI tools bolt four separate pipelines onto four separate problems: one tool for semantic search, another for reminders, another for PII redaction, and a fourth for storage cleanup. That wastes compute and clutters the UI.

Draku is built around a single architectural rule: One reading. Four outcomes.

[ Screenshot / Photo / PDF ]
             │
             ▼
   ┌───────────────────┐
   │  Local PaddleOCR  │ ──► Extracts text + exact pixel bounding boxes + EXIF
   └─────────┬─────────┘
             │
             ▼
   ┌───────────────────┐
   │ Structured Reader │ ──► Parses dates, PII patterns, category & dead-score
   └─────────┬─────────┘
             │
             ▼
   ┌───────────────────┐
   │  EmbeddingGemma   │ ──► Generates local semantic vector embeddings
   └─────────┬─────────┘
             │
             ▼
      [ reading.json ]
             │
   ┌─────────┴──────────┬────────────────────┬───────────────────┐
   ▼                    ▼                    ▼                   ▼
[ FIND ]           [ REMEMBER ]         [ PROTECT ]         [ LET GO ]
Semantic search    Contextual .ics      Pixel-burned PII    Transparent
& smart rename     deadline alerts      & EXIF stripping    rest scoring

When Draku scans a file like IMG-20261011-WA0004.jpg, it produces a single structured internal artifact ( reading.json):

{
  "name":     "2026-10-11 Dr Patel blood test prescription",
  "category": "medical / prescription",
  "dates":    [{ "refill_by": "2026-11-10" }],
  "private":  ["patient_id", "gps"],
  "dead":     0.04,
  "network":  null
}

"pharmacy receipt" or "cholesterol check", EmbeddingGemma matches the meaning even if those exact words aren't in the filename.OTP, ticket, receipt), whether the extracted date has passed, perceptual duplicate distance, blurriness, and byte size. You can read the exact reason Draku suggests letting a file rest.network is always null. Windows is the primary platform where DirectML and WebView2 ensure a guaranteed, zero-friction experience out of the box. For hardware without OCR capabilities, Draku provides a lightweight build (--no-default-features): semantic search, dates, duplicate detection, and rest actions function without OCR, while Protect reports what can be discerned from names and metadata.

If a tool asks to read your entire camera roll and Downloads folder, it is asking to read your life: your prescriptions, tax returns, national ID cards, bank statements, and private family photos.

You cannot build a trustworthy version of Draku on a closed, cloud-hosted API. Here is why open-weight models and open-source code are the only way this product can exist:

fetch-model.mjs), your personal file guardian will work identically ten years from now on an air-gapped laptop. When I saw the Ghost in the Machine theme coinciding with Halloween and Día de los Muertos, I didn't want to build another spooky terminal chatbot pretending to be a poltergeist. I started thinking about the real ghosts that live inside our machines every single day.

Our devices are full of unfinished business: the prescription we forgot to refill, the warranty we missed by three days, the old ticket stub from a trip we took a year ago, and the dead OTP screenshots cluttering the drawer. In the spirit of Día de los Muertos, some things in our digital lives deserve to be remembered and honoured on time, our private secrets deserve to be protected, and the things whose time has passed deserve to be laid peacefully to rest.

That is why Draku is a tiny guardian familiar—eyes of black flame to read the dark pixels, bat wings to shield your secrets, and a quiet nudge to help you let go of what is dead.

ci.yml): linting and type-checking (React 19 + TypeScript + Vitest), dual cargo test suites (light and full OCR) with model caching, and a Windows runner job that builds the NSIS installer, Built with 🦇 for Hacktoberfest 2026 — Draku on GitHub · Landing page · Download the installer