Ofrenda of the Machines: Remembering the Ghosts We Left in Space

Shubhi Merchant — Sat, 31 Oct 2026 18:14:47 +0000

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

What I Built

Ofrenda of the Machines is an interactive 3D memorial for spacecraft that explored space and are now inactive, lost or still travelling.

I read "Ghost in the Machine" in a way that suits a memorial. A ghost is what remains after something is gone, and these machines leave a trace of that kind: Opportunity's last transmission from Mars, Voyager 1's signal from interstellar space, and a lander that went silent without anyone being sure why. The "ghost" in my machine is the voice that tells their stories, and the project is built around catching that voice when it makes things up.

The idea comes from the ofrenda, a memorial made to remember people who are no longer physically present. It is about keeping someone's story alive by arranging names, objects and memories in one place. I applied that to space machines and sorted them into three categories:

Resting: machines whose missions have ended.
Restless: machines that are still travelling or operating.
Lost: machines that were lost, or whose missions ended unexpectedly.

My first three machines are Opportunity, the Mars rover (Resting), Voyager 1, the interstellar probe (Restless), and Mars Polar Lander (Lost). Each story is available at a younger and an older reading level.

Demo

Live site: https://merchantshubhi.github.io/ofrenda/

The demo is a floating 3D altar. You drag to look around, scroll or pinch to zoom, and choose a spacecraft's name to open its panel. The panel covers what the machine was, what it found or did, how it worked, a fun fact and its sources, and you can read the story at a younger or older reading level. A List view is available as an alternative to the 3D altar.

The stories were generated ahead of time with Gemma and saved into machines.json, so the live site doesn't call a model. There is nothing to install, and the site makes no network requests while running.

Not affiliated with NASA. The illustrations are original and simplified.

Code

merchantshubhi / ofrenda

An interactive, AI-powered digital memorial celebrating robotic spacecraft through 3D experiences, verified mission facts, and age-adaptive storytelling.

Ofrenda of the Machines

Stories for the spacecraft we left behind.

Ofrenda of the Machines is an interactive, AI-powered digital memorial dedicated to robotic spacecraft that have explored our Solar System and beyond.

Some machines have completed their missions and now rest on distant worlds. Others continue travelling through interstellar space. Some were lost before they could fulfil their missions.

This project gives each of them a place to be remembered.

Through an interactive 3D experience, visitors can explore spacecraft, discover their missions and scientific contributions, and read their stories in two age-appropriate formats.

The project combines human-verified scientific information, locally generated AI storytelling, and an interactive 3D frontend to create an educational experience that is both informative and reflective.

View on GitHub

The repo is split into three parts:

data/machines/ holds the hand-verified JSON fact sheets, one per spacecraft.
ghosts/ is the Python backend: schema.py validates the fact sheets, llm.py talks to Gemma through Ollama, verify.py checks the generated stories, and build.py runs the pipeline and writes site/generated/machines.json.
site/ is the Three.js frontend. Three.js and OrbitControls are vendored in site/vendor/, so there is no CDN dependency.

To rebuild the stories, run python -m ghosts.build --model gemma4:e4b. To run the site locally, run python -m http.server 8000 --directory site. The README has the full setup and covers the tests: pytest for the backend, Node's test runner for the frontend and Puppeteer browser checks.

Adding a new spacecraft means adding a fact sheet and an entry in site/machine-config.json.

How I Built It

The data flow is a chain:

Human-verified fact sheets → Python validation → local LLM → story generation → verification → generated JSON → frontend

Fact sheets. Each machine has a JSON fact sheet containing information I verified by hand, with sources. These are the single source of truth. Python validates them before anything else runs, so an incomplete sheet is caught early.

Story generation. I use Ollama to run a local Gemma model, with no hosted AI API involved. It receives one fact sheet and writes a short first-person story at two reading levels. It is told to rephrase the facts, not add to them.

Verification. A verification module checks each generated story against its fact sheet: every number, date and proper name has to appear in the sheet, and the text can't contain anything scary for a young reader. If a story fails, the model gets one retry. If it fails again, a fallback builds the story from deterministic templates filled with fact-sheet data. This means every machine always has a story, even when the model gives me something I can't trust.

This happened in my real build. Of the six stories (three machines, two levels each), five came from Gemma.

The older-level story for Voyager 1 failed verification, so the site shows the template version instead. Each story on the page carries a short note saying whether it was written by the local AI or retold directly from the facts, so a reader can tell which is which.

Build and frontend. A build module writes everything to site/generated/machines.json. The Three.js frontend reads only that file (plus a small config that says what 3D shape each machine gets). It never talks to the model or the verifier.

Offline-first. Assets are local, the model is local and there are no CDN dependencies. Once built, the site doesn't need the internet.

Why Does Open Innovation Matter?

Does it work with the lights and the internet off? Yes, by design. The model runs locally through Ollama, the assets are local and there are no CDN dependencies. The Three.js frontend reads a single file, site/generated/machines.json, so the finished memorial needs neither a network connection nor a running model. A closed API would have broken this. If story generation depended on a hosted model, the site could not be built offline, and the project would depend on someone else's servers being up.

Does it keep my data on my own machine? Nothing in this pipeline is sent to an outside service. I should be honest that privacy wasn't my main reason for going local. The facts about Opportunity, Voyager 1 and Mars Polar Lander are public. But the same setup would work for something personal. An ofrenda is a personal kind of memorial, and I can see someone building one for their own family with a local model so the photos and stories never leave their device.

Is it locked inside a service that might disappear? This is where the open approach mattered most to me. Gemma is an open-weight model, so I download the weights and keep them. Hosted models get updated, renamed or retired, and when that happens the same prompt can start producing different stories. With a local model I control which version I use, and I can regenerate stories whenever I want. The generated JSON is also a plain file that I own, so even the model is not needed to keep the memorial running.

Prize Categories

Best Use of Gemma: Gemma is the model behind the generated stories in Ofrenda of the Machines. I run gemma4:e4b locally through Ollama, with no hosted API. It writes each machine's story from a hand-verified fact sheet, and a verification module checks the output before it reaches the site. Without Gemma there would be no generated stories, only the template fallback.

What's Missing, and What I'd Do Next

I built this on my own, in a limited amount of time. I'd rather be clear about what exists than let the post suggest it's bigger than it is.

What exists now. Three machines with hand-verified fact sheets, locally generated stories at two reading levels, a verification step with a template fallback, and a 3D frontend built with Three.js.

What I'd add with more time.

More machines. Three is enough to show the three categories, but not enough to make it feel like a real memorial. Each new machine would start the same way, with a human-verified fact sheet, since the data is what limits growth here. Writing and checking sources by hand takes time. The frontend already arranges several machines per category in an arc, but I haven't filled it yet.
Richer interaction. I'd like visitors to have more ways to explore the machines and their stories, such as a Moon and Mars map.
Stronger verification. The verifier lowers the chance of a wrong story reaching the site, but it doesn't guarantee correctness. A story can pass the checks and still have a loose turn of phrase, and more time would let me test it against more cases.

None of these are built yet. They're what I'd work on next.

DEV Community: Shubhi Merchant