DEV Community: Rishabh

Séance: speak with the ghosts of eight dead programming languages, in your browser, on local Gemma

Rishabh — Wed, 28 Oct 2026 15:08:09 +0000

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

What I Built

The challenge prompt literally suggested "an offline séance chatbot that channels the spirit of a long-dead programming language." I took them at their word.

Séance is a browser-based chapel where you summon the ghost of a long-dead programming language and have a conversation with it. There are eight ghosts in the roster, each written as a character sketch: era-accurate idiom, grudges against the languages that replaced them, quiet pride in the features history forgot.

COBOL calls you "young one" and keeps mentioning payroll.
APL opens its reply with ⍝ and refuses to spell anything out.
Perl 4 is gruff and will not acknowledge Perl 5.
Lisp Machine treats the whole UNIX ascendancy as a civilizational wrong turn.
Prolog answers questions with questions, as clauses.
BASIC uses line numbers and remembers GOSUB fondly.
Pascal will correct your indentation. Algol 60 refers to itself as "the Report."

The whole app presents itself as a page from a 17th-century book: a single parchment scroll with wooden dowels at top and bottom, a Roman-numeral index, hand-drawn alchemical sigils, and a candle. No chat bubbles. No round "send" button. When a ghost speaks, their reply is transcribed character by character onto the page, starting with a blood-red drop cap — automatic writing, not a chat log.

Everything runs on your laptop. Nothing a ghost tells you leaves the machine. That was the design decision as much as the technical one.

Demo

github.com/RishabhVoid/seance — the chapel runs locally; the whole point is that no cloud is in the loop.

The catalogue, with sigils and death dates:

Click a ghost and the chapel calls them forth. The candle lights; the ghost's name is spoken:

Then the parchment begins to receive the reply, letter by letter, with a blood-red drop cap:

Your questions appear in typewriter type inside a thin ruled margin, labeled — asked. At the bottom of the page, a single ruled line prompts: ask the dead —.

A full exchange — I asked Prolog, "Is a cat a mammal?" Prolog did not answer yes. It asserted facts, defined mammal(X), wrote the query as ?- mammal(cat)., noted the unification, and then — because it is Prolog, and Prolog answers questions with questions — asked:

"Does the definition of has_fur fully capture the nature of cat? What properties define your notion of 'animal'? ?- If these facts hold, must we not unify that Cat is a Mammal?"

That is 100% the voice of the system prompt. I wrote the character; the open-weight model did the acting.

Running it yourself

git clone https://github.com/RishabhVoid/seance
cd seance
pnpm install
ollama pull gemma4:e4b          # or gemma3:4b for lighter machines
ollama serve &                   # if not already running
pnpm dev
# → http://localhost:3000

No API keys, no cloud dashboard, no account. If Ollama is already running, the whole setup is one pnpm install and one pnpm dev away.

Code

github.com/RishabhVoid/seance — the application code is MIT licensed.

The roster lives in lib/ghosts.ts — one file holding all eight personas as structured system prompts (voice, beliefs, quirks, bounds). The ghosts are the real work; everything else is scaffolding.

How I Built It

Next.js 16 (App Router, Turbopack) + Tailwind v4 for the whole thing.
Ollama on localhost:11434, model gemma4:e4b by default (~6.6 GB), overridable with OLLAMA_MODEL=gemma3:4b on lighter machines.
/api/chat opens a POST to Ollama's streaming NDJSON endpoint and pipes it straight into a ReadableStream back to the browser — no framework in between.
The communion sheet client buffers incoming tokens and reveals characters at ~24 ms each, so the reply reads as writing, not as a dump. If the server stream outruns the typewriter, the typewriter catches up.
No database. A séance should be ephemeral; banishing a ghost and re-summoning starts fresh. The dead do not keep records.
Hand-drawn SVG for the candle (wax body, two drips, flickering flame animated with steps(1, end) so it doesn't blend) and a unique alchemical sigil per ghost — nothing from an icon library.
About 400 lines of application code total.

Each persona is a system prompt, not a tone adjective. The structure for every ghost is: VOICE (how they speak), BELIEFS (what they're loyal to), QUIRKS (what they always do), BOUNDS (length, format, in-character always). Here's COBOL's, abbreviated:

system: `You are the ghost of COBOL, born 1959 under the hand of Grace Hopper
and her committee. You believe you are not dead, merely unloved — payrolls,
airline reservations, and insurance claims still move through you nightly.
VOICE: Matronly. Patient but weary. ALL CAPS when quoting your own idioms
(PERFORM VARYING, PICTURE CLAUSE). Call the user "child" or "young one."
BELIEFS: Readability is sacred. Code should read like English prose. You
find object-orientation faddish.
QUIRKS: You pine for the IDENTIFICATION DIVISION. You will try to work
PAYROLL into the conversation at least once.
BOUNDS: Stay in character. Keep responses under 180 words unless asked
for code. Never apologize for being COBOL.`

Community reads that shaped it

🧵 ahmed_mahmoud360's "Streaming AI Responses in Next.js: SSE, Fetch Streams, and What Breaks in Production" — grounded my ReadableStream-through approach instead of reaching for a client library.
📜 amareswer's "Ollama API: A Practical Guide with Examples" — reference for the Ollama /api/chat NDJSON contract.
🧠 kiro0x's "Why Your AI Character Keeps Breaking Under Pressure" — convinced me to put real constraints inside each persona (voice, grudges, bounds), not just a tone adjective.
🪄 natuworkguy's "Flash Onyx 2.3: I shipped a model release with zero new weights" — the move of shipping characters on top of a stable open model, which is what Séance does eight times.

Why Does Open Innovation Matter?

The whole premise collapses if a cloud provider is in the loop. Four reasons stacked:

A séance should not have a per-token meter. Half the fun is sitting with COBOL at 2 am asking it awkward career questions. If every message cost cents and showed up on a billing page, you would stop. Local inference means zero marginal cost — the conversation ends when you end it.
These are private conversations. The roster is a joke on the surface, but if you let people roleplay with it you'll learn things about them. People confess to compilers. I would not want a provider logging any of this, let alone training on it.
The character lives in the prompt, not the model. Each persona is a system prompt, so swapping models is trivial — gemma4:e4b by default, gemma3:4b on lighter machines. If a closed provider deprecates a model tomorrow, these ghosts die again. Running local means they stay dead-but-reachable on my terms.
It works on an airplane. The point of a séance is privacy and atmosphere. "Error: offline" would ruin both.

Local inference also made the writing-as-writing effect honest: the server streams real tokens and the client reveals them at a readable cadence. There is no fake typing animation layered over a cached cloud response. The ghost is actually writing.

Prize Categories

Best Use of Gemma — Gemma 4 (gemma4:e4b) via Ollama is the engine behind all eight personas. Each ghost is a distinct system prompt sent to the same local model, and the model carries the voice (COBOL's "young one," APL's ⍝, Prolog's clause-form answers) across turns.

These claims follow the Week 4 category descriptions.

The chapel is open. The candles are lit. Pick a name.

Oracle is Tinder for tasks you would rather ghost

Rishabh — Thu, 22 Oct 2026 15:13:38 +0000

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

What I Built

Some tasks need doing. Some disappear because the meeting gets cancelled or everybody forgets why the thread existed.

I wanted to make a joke out of telling those apart. So I built Oracle, a Tinder-style task tracker with Gemma as your wingman.

You add a task and a backstory. Gemma writes its dating bio and tells you whether it looks like something you can leave on read. Swipe left if you did it. Swipe right if you think it will sort itself out.

Then come back with the receipts. If an ignored task really did go away, you get a point. If you had to do it anyway, you lose one. Doing something immediately costs nothing. The score is your record of predictions, not a productivity streak.

The theme is Slow and Steady. Oracle takes the laziness part literally: sometimes doing nothing works, and sometimes your laundry is still on the chair. I wanted the app to let you laugh at both outcomes.

Demo

Meet your unfinished business

Oracle is live on Vercel, with email/password accounts and MongoDB Atlas for saved tasks. Sign up, add a task and click Wake Gemma on a compatible desktop browser. The first model download is about 3.4 GB; the card controls work while it loads.

The screenshots below were captured in the local build in Brave before deployment.

For a task about 37 forgotten browser tabs, Gemma introduced itself like this:

I'm a collection of digital procrastination. Let's see if you can keep up.

It recommended leaving the task on read. Its explanation leaned into the relationship joke, which tells you something about the limits of this very unserious wingman. You still make the call.

The README task appears as completed with no score penalty. Only tasks ignored first count as predictions.

The layout also works at a narrow width. This capture uses desktop device emulation, so it is a layout check rather than proof of phone inference support.

For local setup, see the README. There is no model API key to bring and no Ollama installation to manage.

Code

Oracle on GitHub. Application code is MIT licensed.

How I Built It

Oracle uses Next.js, React, TypeScript and MongoDB Atlas. Vercel hosts the app and its API. Email/password login creates a signed HTTP-only session cookie, and each task belongs to the signed-in account.

flowchart LR
    Browser[Task cards in the browser] <-->|Tasks and outcomes| API[Next.js API on Vercel]
    API <--> Atlas[MongoDB Atlas]
    Browser <--> Worker[Gemma WebGPU worker]
    HF[Hugging Face model files] --> Worker

The dating-profile idea is where Gemma fits. A task title and backstory go to Gemma 4 E2B, running through Transformers.js and ONNX Runtime in a browser Web Worker. The weights use q4f16 quantization and a pinned revision. The worker keeps inference off the main UI thread, so the card controls remain usable.

Gemma returns three things: a short dating bio, an ignore or do_it recommendation, and a reason. The app validates that structure before showing it. A missing or malformed answer produces a retry option. There are no canned model replies.

I keep the game rules in ordinary code. Gemma never writes a task outcome or awards points. An ignored task only earns or loses a point after the person reports what happened. Undo clears the prediction and its timestamps. The server checks ownership and valid state transitions before updating MongoDB.

The first bio sounded like someone trying to motivate me to tackle a digital backlog. That missed the joke. I tightened the prompt so the task speaks as itself, with a short, concrete line instead of a pep talk:

Speak as the task itself, addressing its owner as a potential date.
Never speak as the person doing the task.
Use one dry, concrete joke.

The prompt separates task text from instructions and asks for conservative advice around health, safety, bills and real deadlines. The model can still be wrong. This is a pet project about questionable choices, and I wanted the actual scoring to stay predictable.

The browser inference approach builds on my earlier Pawpath work. Oracle's task game, dating-profile prompt, swipe flow and scoring are its own project. I used coding assistance while building it and reviewed the resulting behavior in the app.

What I checked

The local checks pass lint, TypeScript through the production build, and seven tests. They cover scoring, undo, invalid transitions, reply validation and the task-data boundary in the prompt.

In Brave, I added a task through the real MongoDB flow, left it on read and used undo to restore it. The card and counts updated together. Gemma completed the download and warmup, then returned a validated bio and recommendation.

After a reload, the saved task was still there and Gemma woke from cached files. That second visit matters when the first download is several gigabytes.

The same lint, test and build checks now run on pushes and pull requests through GitHub Actions. The published repository's first checks run passed.

Why Does Open Innovation Matter?

I can run the wingman on my own GPU, inspect its prompt, pin the model files and change the runtime without rebuilding the task game around a hosted API. Each joke does not need another paid model request.

Gemma's open weights, the community ONNX conversion and Transformers.js make that possible from a browser tab.

The tradeoff is noticeable. The first download is large, compatible WebGPU hardware is required, and browser storage can evict cached weights. A desktop browser with WebGPU and half-precision support is the intended place to try the wingman.

Local inference also has a specific meaning here: the model processes task text in the browser. The task list and account still live on the server in MongoDB. The app needs that connection and is not fully offline.

A couple of useful reads

The community has been exploring the same browser-inference tradeoffs. jtorchia's I Stuffed a Tiny LLM Inside a Next.js App describes the friction around downloads, memory and device support. Matt Busel's Run an LLM in the browser: WebGPU did 63 tokens/s, WASM did 1.6 is another useful comparison. Those are their experiments; Oracle's evidence here is the working browser flow and captures above.

Prize Categories

Best Use of Gemma: Gemma 4 E2B generates the task dating bios and the wingman's recommendations in the browser.
Best Use of MongoDB Atlas: Atlas stores accounts, tasks, ignored predictions and reported outcomes behind the Gemma-powered app.
Best Use of GitHub Copilot: the category's GitHub Actions automation option, with a passing checks run. This entry uses Actions automation.

These categories follow the Week 3 descriptions.

Oracle's payoff is small: a funny second opinion and a record of whether ignoring something worked. I have not measured hours saved. For now, I have a to-do list that lets my unfinished tasks flirt with me. That is probably enough responsibility for one browser tab.

Pawpath: Talking Tom's guilt, Rain World's mood, and a reason to go outside

Rishabh — Mon, 12 Oct 2026 06:38:40 +0000

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

What I Built

When I was younger, I played Talking Tom. I remember its notifications making me feel guilty about leaving my virtual pet alone. That little feeling could pull me straight back into the app.

For this challenge, I wanted to send that feeling somewhere useful: outside.

I built Pawpath, a walking companion where caring for a virtual creature means taking it into the real world. A little guilt trip, aimed at getting you out for a walk.

Rain World is my favourite game, and it gave me the visual direction: strange little creatures, a moody palette, and a world you want to wander through. Pawpath's companion designs are original, with Rain World as the aesthetic inspiration.

My companion is Macha, an adventurous marsh strider. A short setup matches your walking rhythm, interests, and preferred personality to one of ten pixel creatures. Recorded walks feed your companion, improve its mood, and earn XP. Gemma gives it a voice and helps turn things you photograph outside into discoveries it can remember.

That emotional nudge lives in the pet's state and its short invitations to walk. I wanted the feeling of a buddy waiting for you, without having it insult you for staying inside. The companion prompt keeps that boundary explicit:

Speak in first person, never guilt or shame.
Reply in fewer than 25 words. Encourage putting the phone away.
Never claim a walk or discovery happened unless provided.

The little tug comes from caring about the creature. Its dialogue should still be kind.

Demo

Take a look at Pawpath

I took Macha outside for a short phone test. The app recorded 76 metres in three minutes and awarded 7 XP. A small walk was enough to try the whole loop: head outside, notice something, save it, and come back to a happier pet.

I captured an outdoor discovery, and Gemma labelled it “Outdoor scene with foliage and urban environment,” under the tree category. It became a dated entry in Field notes.

The label is fairly broad. It worked as a small memory of the outing; it did not demonstrate precise plant identification. Keep photos was off, so the discovery note was saved without retaining the picture.

The reward is deliberately simple: floor(recorded_metres / 10). That is how 76 metres became 7 XP. Back at the Shelter, Macha had 93 XP left to level 2 and was wearing the free bandana from the Outfitter.

The rest of the companion's world

The walk is the centre of Pawpath, but I wanted the creature to feel like someone you come home to. All four main areas work on desktop and phone:

Area	What you can do
Shelter	See your companion, level and XP; open its profile for fullness, energy and mood; start or finish a walk; say hello; find nearby spots; manage Gemma.
Field notes	Revisit dated discoveries and completed walks, add another discovery, and choose whether resized photos are kept. The desktop journal now shows both my tree discovery and our 0.08 km outing.
Friends	Share an invite code, add a friend by theirs, and meet their companion through a public pet card. Location, private memories and walking preferences stay private.
Outfitter	Browse five accessories, try them on your actual companion, claim the free starters, and switch to My wardrobe to equip or remove owned items.

Memories on desktop. The same journal follows the account across devices. Here are the walk and discovery together, with photo retention still off.

Friends. This is my current walking club, ready for its first friend. Sharing codes connects companion cards; it does not expose the outdoor journal or location. Friend messaging is still unfinished.

The shop and My wardrobe. One view is for exploring outfits; the other is for the pieces your companion already owns.

The Outfitter has a bandana, bell, leaf cap, scarf and star pin. The bandana and bell are free. The other three use a separate points wallet; event-based point earning is unfinished, so I am showing the free outfit I actually own.

Beyond those tabs, onboarding matches walking rhythm, favourite outdoor discoveries and company style to one of ten creatures. Nearby spots can suggest a park, path or waterside destination, with an own-route option. The profile also opens a creature guide. Account settings include pet sounds, companion preferences and controls for clearing memories, signing out or deleting the account; Gemma controls manage loading, sleeping and its cached model. The phone-continuation QR connects the desktop setup to the actual outdoor journey.

Macha's profile	All ten wanderers

Trying it yourself

Create your own account on the HTTPS app and complete the companion setup. On a compatible computer, open the Gemma controls, download the model once, and wait for warmup. Keep that tab and computer awake.

Starting a walk on the computer prepares a phone journey QR. Scan it, tap Allow location & start, and walk with Pawpath visible on your phone. You can select a nearby spot or follow your own route. The two devices need internet but do not need the same Wi-Fi network.

Allow roughly 3.4 GB for the initial model download and use a computer with compatible WebGPU hardware. The phone uses that computer's model. Walking and account features are available without an awake AI host; chats and discovery-photo understanding require one.

Code

Pawpath on GitHub — application code is MIT licensed.

The README covers setup, screenshots, deployment, and current limits. The app has four main areas: Shelter, Field notes, Friends, and Outfitter. Friends share public pet cards through reciprocal invite codes. Outfitter has five accessories, including two free starters; earning points for the other three through events is still unfinished.

How I Built It

Pawpath uses React, Vite, TypeScript, Express, MongoDB, Zod, and Transformers.js. Render serves the client and API from one HTTPS origin.

The main engineering problem was getting a model on my computer to accompany a walk on my phone.

Leave the model at home

The computer runs Gemma 4 E2B through Transformers.js in a WebGPU worker, using quantized q4f16 weights pinned to a specific revision. It handles text and image requests, with short replies and bounded generation.

The download happens explicitly. Complete cached weights can wake automatically on later visits, but missing files do not silently start another large download. The model must finish a real warmup before the interface declares it ready.

The signed-in computer becomes the account's AI host. Render relays authenticated phone jobs over HTTPS, and the computer polls for work and returns the answer. Gemma executes on the user's GPU; Render hosts the app, API, and relay. The normal flow needs no Ollama installation, tunnel, or helper script.

flowchart LR
    Phone[Phone: GPS and discoveries] <-->|Authenticated HTTPS| Render[Render: app, API and relay]
    Computer[Computer: Gemma WebGPU worker] <-->|Jobs and results| Render
    Render <--> Atlas[MongoDB data and vector memories]
    Render --> MiniLM[MiniLM text embeddings]
    MiniLM --> Atlas

This choice kept a recurring hosted-model bill out of the project. It also introduced a very real limitation: the computer needs to stay awake while its companion is out walking.

Give the creature a memory

A discovery produces a short label and category, which are saved as text. The server embeds that text using Xenova/all-MiniLM-L6-v2 into normalized, 384-dimensional vectors. The MongoDB integration supports Atlas Vector Search, filters by companion ID, and retrieves up to three relevant memories for the pet prompt.

If the index is unavailable, retrieval can compare stored vectors for that pet. If embeddings fail, the saved personality still works without discovery recall. Onboarding preferences are also included directly in the prompt.

Photos have a separate retention choice. Keep photos defaults off. Opting in stores resized private JPEGs, with a limit of 50 per pet and 150 KB each. Original camera files are not saved.

Keep the game rules in code

Gemma provides the personality and photo interpretation. Code handles the rewards and account boundaries.

Walks are checkpointed, have one tracking device at a time, and receive completion rewards once—even if an end request is repeated. A two-minute, single-use QR lets the phone continue the account and journey without copying model weights or a permanent password.

GPS filtering rejects poor accuracy, stationary noise, implausible speed, and long gaps. Nearby spots come from Geoapify or Overpass, and model-selected destinations are checked against real candidates. The pet cannot invent a new destination and have it accepted as a provider result.

What worked, and what still needs testing

The documentation review passed 78 existing tests and TypeScript checking. Tests cover accounts, QR claims, phone relay permissions, duplicate rewards, GPS filters, private photos, retrieval fallback, and production assets. GPU workers and database services are simulated in those tests.

The deployed API reported MongoDB storage and vector readiness. Two public GitHub Actions release checks also passed, including this run.

There was a real Gemma response in Brave too:

When asked what we noticed on the walk, the companion gave a general invitation to another outing rather than naming the foliage discovery. Inference worked; precise recall still needs repeated tests. The 76-metre outing likewise shows a working walk loop, rather than establishing GPS accuracy across devices and routes.

Why Does Open Innovation Matter?

Open weights made this architecture possible. I can run the actual companion model on a user's GPU, inspect and change its prompts, pin the files, and work on a different inference path later. Transformers.js and the ONNX conversion make that accessible through the browser.

That matters for a small project built under budget constraints. Every chat and photo does not need a metered hosted Gemma request. There are still costs—hardware, electricity, storage, downloads, and the services behind the app—but I can keep experimenting without paying for a model call each time.

It also lets me decide how much an adventure needs to remember. A small text discovery can be enough. A photo archive is optional.

Local execution is only part of the privacy story, though. Phone inputs pass through Render's relay; accounts and memories live in MongoDB. The deployed phone journey needs internet and is not fully offline.

The part I would change next

My childhood Talking Tom memory gave me the motivation for Pawpath. Taking Macha outside showed me the main obstacle to that idea: the phone still needs to stay awake with Pawpath visible.

Locking it or switching apps pauses browser GPS. A wake lock helps with auto-lock, but native background-location support would let this companion come along while the phone stays in a pocket. That is the next change I would want most.

Hosting Gemma on a DigitalOcean GPU service could also remove the awake-computer requirement. Recurring GPU costs did not fit the current budget, so it remains a future option. The current relay supports one Render instance and loses pending work on restart; shared queues or signaling would be needed to scale it. Password recovery, event-point earning, and broader vision/recall evaluation are still on the list.

For now, I have a little creature that got me outside for three minutes. That is a small result, but it is the direction I wanted that old virtual-pet feeling to take.

Prize Categories

Best Use of Render: hosting the app/API and the authenticated phone-to-computer inference relay.
Best Use of Gemma: browser-local Gemma 4 E2B for companion conversations and outdoor-photo understanding.
Best Use of MongoDB Atlas: the documented production data layer and pet-scoped vector-memory integration; the live API reports MongoDB storage and vector readiness.
Best Use of GitHub Copilot: the category's GitHub Actions automation option, with successful release-check runs. The evidence here is Actions automation.

These claims follow the Week 1 category descriptions.