DEV Community: Malay-dev

My Browser History Wrote Its Own Horror Story. I Just Watched.

Malay-dev — Sat, 31 Oct 2026 16:20:01 +0000

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

What I Built

It's 2am. You're on Stack Overflow. Again. For the seventh time this week. You know how to reverse a string. You've known for years. You just need to hear it from a stranger who asked in 2009.

Nobody sees your browser history. But what if something did — and narrated it back to you like a Victorian ghost story?

Browser History Horror reads your Chrome history, detects your most unhinged browsing sessions using anomaly detection, and feeds them to Gemma running locally. Gemma writes it back as gothic horror. ElevenLabs reads it aloud in a creepy voice. You sit there and take it.

Your history never leaves your machine. The AI that judges you lives on your laptop.

The Archivist Speaks

This is real output from my actual browsing history. I wish I was making this up.

It began on Monday at 23:47. A single search — innocent enough on its face.
The developer already possessed this knowledge. They had possessed it for
years. Yet here they were, returning to the eternal repository of unanswered
questions, seeking the validation of strangers who had asked the same thing
in 2009.

They left. They returned. They left again. Eight times between 23:47 and
00:31, the same domain welcomed them back with the patience of a very old
spider.

The orange forum came next — a brief interlude, a glance at the horrors
others had inflicted upon their codebases. Reassuring in its way. At least
they were not that.

At 01:15, something shifted. The work-adjacent sites fell away. What replaced
them was a video labyrinth, vast and illuminated, designed by engineers who
understood that the human soul has no natural stopping point.

The last entry: 01:44. A search that shall remain unrecorded. The browser
was closed, and the darkness of the room was left to do what darkness does.

Tomorrow was Tuesday. It had already begun.

Stack Overflow is "the eternal repository of unanswered questions." Reddit is "the orange forum." YouTube is "the video labyrinth." LinkedIn is "the professional purgatory."

Gemma never uses real URLs. It gives every site a gothic alias and writes about your habits like a disappointed Victorian ghost.

How It Works

Browser SQLite ──► History Reader ──► Anomaly Detector ──► Gemma Narrator ──► Gothic UI
     (local)         (pandas)        (TabPFN/heuristic)    (Ollama local)    (FastAPI + SSE)

Step 1: Summon Your History

Chrome stores everything in a SQLite file. The tool copies it to temp (bypasses the browser lock), extracts the last 7 days, and engineers features — hour of visit, domain frequency, session gaps, rapid revisits.

  📖 History found: ~/Library/Application Support/Google/Chrome/Default/History
  1,395 rows extracted in 0.1s
  1,215 marked as heuristically haunted

87% of my browsing is "heuristically haunted." I don't want to talk about it.

Step 2: Detect the Hauntings

The heuristic rules catch the obvious sins:

Visits between midnight and 4am
5+ visits to the same domain within 30 minutes
Rapid-fire revisits (< 30 seconds apart)
Unknown domains after 10pm

TabPFN (tabular foundation model from Prior Labs) refines this — it picks up subtler patterns like a slow drift from work tools → entertainment → doom-scrolling that only looks haunted in context. If TabPFN isn't available, heuristic scoring works fine on its own.

3 chapters extracted:
  Saturday, Oct 24  | 16:09 | MALEVOLENT (1.00) | claude.ai
  Sunday, Oct 25    | 07:09–17:37 | MALEVOLENT (1.00) | gitlab, google
  Monday, Oct 26    | 04:16–15:12 | MALEVOLENT (1.00) | jira, google, docs

Every single session: MALEVOLENT. The algorithm is not wrong.

Step 3: The Archivist Writes

Gemma 3 4B runs locally via Ollama. Each chapter gets a system prompt that enforces the gothic voice:

Second person ("the developer", "they") — never breaks character
Sites become gothic aliases — never raw URLs
One darkly comic observation per chapter
One ominous closing line

The prompt also includes visit patterns, timestamps, and intensity scores so Gemma can reference your actual behavior without ever seeing the raw data.

Step 4: The Séance

A gothic web UI streams everything in real time:

Flickering candle SVGs in the header
Chapters stream in with a typewriter effect as Gemma generates them
Each chapter shows a Haunting Intensity bar powered by the anomaly score
ElevenLabs reads each chapter aloud in a measured, deliberate voice
A fog layer drifts at the bottom of the page because atmosphere matters
When it's over, download your Grimoire — a self-contained HTML file of your sins

No React. No build step. One HTML file with vanilla JS. The séance needs no bundler.

The Privacy Argument

This is the slide I'd put in a conference talk if I gave conference talks:

Data	Where it goes
Browser history	Copied to temp, queried, deleted. Never leaves your machine.
Feature vectors	Processed locally by TabPFN. Never sent anywhere.
Narration prompts	Sent to local Ollama. Never touches a cloud API.
Generated prose	Sent to ElevenLabs for TTS — only the gothic text, not your history.
Sentry traces	Latency numbers and model names only. No content.

Your browser history is a confessional. The only AI that should read it is one that lives on your hardware and can't phone home. Gemma running locally via Ollama is the only appropriate choice here. A cloud API would mean shipping your 2am Stack Overflow spiral to someone else's server. No.

Run It Yourself

# Prerequisites: Python 3.11+, Ollama running
ollama pull gemma3:4b

git clone https://github.com/Malay-dev/browser-history-horror.git
cd browser-history-horror
pip install -r requirements.txt
python seance.py

Browser opens. Click the button. Face your sins. Three commands.

ElevenLabs is optional — without an API key, the browser's built-in speech synthesis does the reading (less creepy, still functional). Sentry tracing is optional too. The core experience is Gemma + your history + guilt.

Code

Malay-dev / browser-history-horror

🕯️ Browser History Horror

"On Tuesday at 2am, the developer returned to Stack Overflow for the seventh time They searched for 'how to center a div.' They knew the answer. They just needed to hear it again."

A fully local, privacy-first tool that reads your browser history, detects anomalous browsing patterns, and narrates your week as a gothic horror story — complete with creepy voice narration and a downloadable "grimoire" of your sins.

Your browsing history never leaves your machine during analysis. The only data that touches an external service is the generated narration text sent to ElevenLabs for text-to-speech (and that's optional).

Built for the Hacktoberfest 2026 Ghost in the Machine challenge.

How It Works

Browser SQLite ──► History Reader ──► Anomaly Detector ──► Gemma Narrator ──► Gothic UI
     (local)         (pandas)          (TabPFN/heuristic)    (Ollama local)    (FastAPI + SSE)

Extract — Copies your Chrome/Chromium/Brave/Edge history from SQLite (bypasses the browser lock)
…

View on GitHub

browser-history-horror/
├── seance.py              # Entry point — checks Ollama, finds history, starts server
├── src/
│   ├── history.py         # SQLite reader + feature engineering (8 features)
│   ├── detector.py        # TabPFN scoring + session grouping
│   ├── narrator.py        # Gothic prompt design + Ollama streaming
│   ├── tts.py             # ElevenLabs with speechSynthesis fallback
│   ├── api.py             # FastAPI + SSE streaming + grimoire generation
│   └── tracer.py          # Sentry span instrumentation
├── frontend/
│   └── index.html         # Self-contained gothic UI (19KB, zero deps)
└── requirements.txt

How I Built It

Gemma 3 4B via Ollama — local inference, streaming. The system prompt is doing the heavy lifting — it enforces the gothic voice, prevents URL leakage, and structures each chapter with a comic beat and an ominous closer. Domain aliasing happens post-generation as a safety net: even if Gemma slips, sanitize_narration() catches raw domains and replaces them.

TabPFN — in-context tabular classification. No train/test split needed. The heuristic seed labels ("obviously haunted" by simple rules) become training signal, and TabPFN picks up cross-feature interactions. The fallback to heuristic-only scoring means the tool works even without the gated model weights.

FastAPI + SSE — the narrator streams chunks as Gemma generates them. The browser consumes Server-Sent Events and renders text character by character. No WebSocket complexity, no polling. TTS audio is generated async and served via a separate endpoint when ready.

ElevenLabs — eleven_turbo_v2_5 for low latency. The free tier gives 10,000 characters/month — enough for one full séance (~7,500 chars across 5 chapters). Falls back to the Web Speech API with pitch dropped to 0.75 for a budget-gothic effect.

Sentry — every pipeline stage is a span: history extraction, feature engineering, TabPFN scoring, each Gemma chapter, each ElevenLabs call. The trace waterfall shows exactly where the time goes (spoiler: it's Gemma, always Gemma).

Frontend — one HTML file. CSS custom properties for the color palette. SVG candles with randomized flicker animations. Typewriter effect via JS chunked rendering. The haunting intensity bar is a CSS gradient driven by the anomaly score. The grimoire download generates a self-contained HTML file server-side.

Why Does Open Innovation Matter?

Browser history is the most personal dataset on your computer. Every anxious 2am search, every rabbit hole, every time you Googled something you already knew — it's all there in plain SQLite.

The only way to build something like this responsibly is with open-weight models running locally. Gemma on Ollama means the model that reads your history lives on your hardware. No API keys for the scary part. No telemetry. No "we improved our model using your data."

Open-source also means you can read exactly what data goes where. The privacy model isn't a policy document — it's six Python files you can audit in 10 minutes.

I built a tool that reads your most private data and turns it into entertainment. If that doesn't make the case for local AI, I don't know what does.

The Gothic Payoff

Before: Browser history is a log file you never look at.

After: Browser history is a horror story you can't stop reading.

I ran this on my own history and learned that I visited claude.ai 9 times in one sitting on a Saturday afternoon. The Archivist called it "a peculiar fixation" and "a futile endeavour mirroring the human condition itself."

It's not wrong. Ship it. Face your sins.

Prize Categories

Gemma — Core narrative engine. Local inference via Ollama, streaming generation, gothic system prompt with domain aliasing and output sanitization. Every word of the horror story is Gemma. #Gemma

TabPFN — Anomaly detection on browsing session features. In-context classification on 8 engineered features with heuristic seed labels. Surfaces the sessions that become chapters. #TabPFN

ElevenLabs — Chapter narration voiced in-browser. Turbo v2.5 for low latency, with Web Speech API fallback. Only receives generated prose, never raw history. #ElevenLabs

Sentry — Full pipeline traced with spans. History extraction → feature engineering → TabPFN scoring → per-chapter Gemma generation → per-chapter TTS. Latency, token counts, audio sizes — all in one trace waterfall. #Sentry

Render — Gothic web UI deployed as a static site for the public demo. Anonymized fixture data so visitors can experience the séance without exposing their own history. #Render

The Ticket Sold Out While I Was Lazyinhh... So I Built Clutch.

Malay-dev — Sun, 25 Oct 2026 16:38:24 +0000

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

What I Built

I missed GDG DevFest Bengaluru by one day. The announcement sat unread in my Discord (cause too much clutter and procrastination on reading all those) while the last ticket sold.

I don't need more notifications. I need something that knows what I can't afford to miss.

Clutch watches your communities — Discord, Luma, KonfHub, Hacktoberfest, RSS - scores every event against your interests using Gemma 3 locally, and puts only what matters on your Google Calendar with colors that escalate as deadlines approach.

330+ events. 5 sources. One calendar || feed || any form factor.

Gemma knows the difference

Profile: AI/ML, open source, hackathons, robotics, Bengaluru

[HIGH    ] 0.79  Build Agents with Omega (Bengaluru)
[HIGH    ] 0.77  Physical AI Demo Night (Bengaluru)
[HIGH    ] 0.76  Hacktober Hack (Bengaluru)
[INFO    ] 0.19  10 Tips for CSS Grid Layouts
[INFO    ] 0.05  Flower Bouquet Out Of Pipecleaners
[INFO    ] 0.05  Social dynamics of toxic metal in medieval Europe

A flower bouquet workshop never even reaches the model. Pre-filter catches it.

Calendar does the nagging

Google Calendar's native colors. No emojis. Time drives the escalation.

Time left	Color	Suffix
>7 days	Blue	—
3-7 days	Orange	[5d left]
<3 days	Red	[TOMORROW]
Past	gone	auto-deleted

The pipeline

Connectors

Source	Events	Auth
Luma	90	None
KonfHub	128	None
Hacktoberfest	80	None
RSS	32	None
Discord	varies	Bot token

Every connector is a standalone pip package. pip install and Clutch discovers it. We want the community to add Telegram, Slack, GitHub, Meetup — any source where opportunities hide in noise.

Escalation in action

The radar

Temporal workflow

Code

Malay-dev / clutch

Clutch

The AI that won't let you miss what matters.

Clutch is a local-first AI agent that monitors your communities — Discord, Luma, KonfHub, Hacktoberfest, RSS — scores every event against your interest profile using Gemma 3, and puts what matters on your Google Calendar with escalating color-coded reminders.

How It Works

5 Connectors (330+ events)
  -> Pre-filter (keyword match, drops obvious noise)
  -> Gemma 3 scoring (interest, urgency, scarcity, impact)
  -> Google Calendar (time-based color escalation)
  -> Temporal (durable 4h cycle, survives restarts)

Events start blue on your calendar. As deadlines approach, they turn orange, then red. Past events are auto-deleted. You never configure this — time does it.

Quick Start

# Prerequisites: Python 3.12+, Ollama with gemma3:4b, Podman (optional)
ollama pull gemma3:4b
# Clone and install
git clone https://github.com/Malay-dev/clutch.git
cd clutch
uv venv && source .venv/bin/activate
uv pip install -e ".[dev]"
uv pip install -e connectors/rss

…

View on GitHub

How I Built It

Gemma 3 4B via Ollama — local inference, no cloud. Four-dimension scoring (interest, urgency, scarcity, impact) as structured JSON. Batch mode, 5 events per LLM call. Pre-filter drops noise before the model sees anything.

The prompt does the heavy lifting — it checks attending eligibility (same city? online? worth traveling?), penalizes expired events, and scores conservatively. Most things are noise. Only what you can realistically act on gets through.

Scoring guide baked into the prompt:
- Generic blog post: 0.1-0.2
- Hackathon in your city matching interests: 0.8+
- Great topic but wrong city: 0.2-0.4 (unless online)
- Online workshop matching interests: 0.6-0.8
- Expired event: urgency 0.0 regardless of topic

Temporal — 6-activity durable workflow. Connectors fetch in parallel. If one fails, the rest proceed. 4-hour durable timer survives restarts. Every activity visible in the Temporal UI. - Durable code, best observability, native OSS

Google Calendar API — native color IDs, time-based escalation, triple dedup (in-memory + SQLite + Calendar-side), capped at 10 active events. (Google here, but any calendar app with API support could be used)

pgvector (Tiger Data) — Temporal persistence backend + future interest graph. - all in one

Podman — full stack in containers. Ollama native on host for GPU.

Your interest profile is a YAML file. Your data stays on your machine. The model runs on your hardware. That's the whole point.

Why Does Open Innovation Matter?

Clutch monitors your Discord messages, your event feeds, your community channels. That is attention data. With Gemma running locally, none of it leaves your machine.

A closed API would mean every community message gets shipped somewhere you don't control. Open weight means offline, on a plane, behind a firewall. Swap the model whenever — Gemma today, Llama tomorrow.

The Lazy Payoff

Before: 6 Discord servers, 3 Telegram groups, Luma, KonfHub, RSS. Checked manually. Usually too late.

After: I check my calendar.

I used Clutch this week to track this hackathon's own deadline. It worked.

Ship your own

Here's the thing — don't run this on your MacBook while you work. Deploy it on a Raspberry Pi, an old laptop, any machine gathering dust. Let it run 24/7 as your personal attention server. Gemma runs slow on a Pi — ~30s per event instead of 4. But for a 4-hour cycle, that's fine. Slow and steady is literally the point.

We move fast. The tech world moves faster. Conferences sell out. CFPs close quietly. Hackathon deadlines pass while you're "going to get to it."

Don't just read about it. Deploy it. Level up.

Set it up once. Forget about it. Your calendar fills itself with what matters. Opportunities stop slipping through the cracks while you're busy shipping code or, you know, lazying.

Prize Categories

Gemma — Core scoring engine. Local inference, batch mode, structured output. 100+ events per cycle on consumer hardware. #Gemma

Temporal — 6-activity workflow. Parallel fetches, retries, durable timers, full UI observability. #Temporal

Tiger Data — pgvector as Temporal backend and interest graph store. #Tiger