# This is a submission for title: "Echoes of the Forgotten: Bringing Forgotten Computing to Life with AI" > Source: > Published: 2026-10-28 17:30:30+00:00 **This is a submission for the MLH x DEV Writing Challenge.** **Echoes of the Forgotten: Bringing Forgotten Computing to Life with AI 👻 ** What if exploring the history of computing felt less like reading an encyclopedia and more like entering a mysterious digital archive? That question inspired Echoes of the Forgotten, an interactive project that combines retro terminal aesthetics, historical computing, and AI to create an experience where users can explore forgotten technologies and interact with the past. Instead of presenting information through a conventional website, I wanted to create something that felt like discovering an abandoned computer system that still had stories to tell. Here's how I built it, the technical decisions behind it, and what I learned along the way. **What I Built** Echoes of the Forgotten is an interactive, haunted digital archive that brings forgotten computing history to life. The experience takes inspiration from old computer terminals, historical programming languages, and the mysterious atmosphere of abandoned digital systems. Users can explore the archive, search for information, and interact with AI-powered characters. **The main features include:** **👻 AI Character Conversations:** Interact with AI-powered characters that make exploring the archive more engaging. 🔎 Archive Search: Search through historical computing content to discover relevant information. 📚 Source-Grounded Answers: Retrieve relevant passages from the archive using BM25 search, helping connect answers to available source material. 🔗 Citations: Provide references to supporting information so users can investigate the underlying sources. 💾 Persistent Discoveries: Store discoveries and conversations in SQLite, allowing the application to preserve relevant information between sessions. ⌨️ Safe Terminal Commands: Explore the experience through controlled commands rather than unrestricted system access. 🛟 Offline-Friendly Fallback: When AI inference is unavailable, users can still explore the archive through its fallback functionality. I wanted the project to feel atmospheric without sacrificing usefulness. The retro interface creates the experience, while search, retrieval, and persistent storage make it functional. **Why This Idea?** Computing has a fascinating history, but many older technologies and programming languages receive little attention outside specialized communities. I wanted to explore a different way to present that history. What if a digital archive could feel like a character in its own story? What if users could discover information through exploration rather than simply scrolling through static pages? That led to the idea of a forgotten digital system that users could investigate. The goal wasn't just to build another chatbot. It was to create an experience in which the interface, information retrieval, and AI interaction work together. **Demo** Explore the project and its source code: **🔗 GitHub Repository:** [https://github.com/Ganesh-978/Echoes-of-the-Forgotten](https://github.com/Ganesh-978/Echoes-of-the-Forgotten) The repository contains the project implementation and is the best place to explore how the application works. A short walkthrough would be especially useful for showing the terminal-inspired interface, archive search, AI conversations, and how the application behaves when AI is unavailable. **Partner Technologies** Building this project involved bringing together frontend development, backend APIs, information retrieval, persistent storage, and hosted AI inference. Here are the technologies I used. React and TypeScript I used React to build the interactive user interface and TypeScript to add static type checking. This combination helped organize the frontend into reusable components while making data structures and component interactions easier to reason about. Python and FastAPI The backend uses Python and FastAPI to handle application logic and expose API endpoints. Keeping the backend separate from the frontend makes the application easier to organize and provides a clearer boundary between the user interface and the underlying services. BM25 Information Retrieval One of the important technical decisions was using BM25 for archive search. BM25 is a lexical information-retrieval algorithm that ranks documents according to how well their terms match a query. This gives the application a way to find relevant passages from the available archive without relying entirely on an AI model to generate information from memory. It also provides a foundation for connecting answers to supporting source material. Groq and Llama 3.1 8B Instant For AI-powered interactions, I used Llama 3.1 8B Instant through Groq's hosted inference service. Using hosted inference meant I didn't need to download and run the model locally. That was an important practical decision because local model execution can require substantial memory and computing resources. It allowed me to experiment with AI-powered interactions while keeping the application's model execution separate from my local development environment. SQLite I used SQLite to persist discoveries and conversations. SQLite is a lightweight relational database that works well for projects that need persistent storage without the operational complexity of running a separate database server. It was a practical choice for this application's current scope. A note on MLH partner technologies: Groq is the AI inference provider used in this project, but I have not verified whether it qualifies as an official MLH partner technology for this challenge. I don't want to misrepresent that relationship. **Hackathon Experience** This project was an opportunity to explore how several technologies could work together in a single interactive application. Rather than focusing exclusively on AI, I needed to think about the entire user experience: how users discover information, how the backend retrieves relevant content, how conversations are stored, and what happens when an external AI service becomes unavailable. A few decisions shaped the implementation. First, AI shouldn't be the only way to access information. External model services can become unavailable or encounter errors. Providing fallback functionality makes the application more resilient and allows users to continue exploring. Second, retrieval and generation solve different problems. BM25 helps locate relevant information in the archive. The language model provides conversational interaction. Keeping these responsibilities distinct makes the system easier to understand and reason about. Third, the interface should support the idea behind the project. The terminal-inspired presentation isn't just decoration. It helps establish the atmosphere of exploring a forgotten digital system and makes the experience more distinctive than a conventional chatbot interface. Working through these decisions reminded me that building an AI application involves much more than connecting a model to a user interface. Retrieval, persistence, error handling, and product design all matter. **What I Learned** Building Echoes of the Forgotten reinforced several lessons for me. An interesting idea can attract attention, but the implementation determines whether the experience is actually useful. I had to consider how the interface, backend, retrieval system, database, and AI integration would work together. A language model can produce a convincing answer without necessarily grounding it in the information available in a particular archive. Using BM25 to retrieve relevant material creates a separate information-retrieval step. Connecting answers to supporting sources makes the experience more transparent. Hosted inference makes it easier to experiment with models without running them locally, but it introduces dependencies on network connectivity and service availability. A useful application should account for those limitations instead of assuming every request will succeed. The visual experience gives the project its identity, but the underlying architecture makes that experience functional. I learned to think about both sides: what the user experiences and what the system needs to do behind the scenes. Even a relatively focused application introduces questions about API boundaries, data persistence, retrieval quality, failure handling, and maintainability. These are the kinds of engineering decisions I want to keep improving as I build more complex applications. What's Next? Echoes of the Forgotten is a starting point for exploring more interactive ways to present computing history. Future improvements could include expanding the historical archive, improving retrieval quality, adding more interactive characters, and making the source material easier to explore. I would also like to continue improving the application's reliability and testing how well the retrieval system handles different kinds of queries. The broader idea is simple: learning about computing history doesn't have to feel like reading a static document. It can be an experience worth exploring. Let's Talk! I'm interested in hearing how other developers approach projects that combine AI with creative interfaces. **A question for the community:** If you were building an interactive archive powered by AI, what would you prioritize first: better retrieval, more engaging AI characters, or a more immersive interface? I'd love to hear your thoughts and ideas in the comments. Thanks for reading, and happy building! 🚀