Recovering the knowledge behind forgotten software.
The Lostware Initiative is dedicated to discovering, documenting, preserving, and modernizing legacy software whose original design knowledge has been lost to time.
This project is not about rewriting old software.
It is about understanding it.
Every legacy application tells a story. Beneath years of updates, abandoned features, missing documentation, and forgotten design decisions lies the work of developers solving real problems with the tools available to them.
The goal of the Lostware Initiative is to recover that story before changing it.
Modernizing software begins with understanding—not replacement.
Rather than asking:
"How do we rewrite this?"
we ask:
"Why was it built this way?"
Every expedition follows the same philosophy:
- Observe before changing.
- Document before refactoring.
- Preserve knowledge before replacing code.
- Modernize only after understanding.
The objective is not simply to produce better software.
The objective is to become better engineers by learning from the software that came before us.
The inaugural expedition focuses on an abandoned Qt4 application designed to create BattleTech characters.
Originally developed years ago and left largely undocumented, it represents an ideal case study in software archaeology.
This project serves two parallel goals:
- Recover and preserve the application's architecture and design intent.
- Learn modern C++ and software engineering by understanding—not replacing—a real legacy codebase.
Every discovery is documented before significant changes are made.
docs/
│
├── explorers-journal/
│ Personal reflections, lessons learned,
│ and the human side of each expedition.
│
├── expeditions/
│ Technical investigations for each project.
│
├── architecture/
│ High-level system documentation,
│ diagrams, and design analysis.
│
├── field-reports/
│ Deep dives into individual subsystems.
│
├── restoration/
│ Modernization strategies and implementation plans.
│
└── glossary.md
The Lostware Initiative records every expedition from two complementary perspectives.
Objective technical documentation.
These logs answer questions such as:
- How does the software work?
- Why was it designed this way?
- What assumptions does it make?
- How can it be safely modernized?
Topics include:
- Architecture
- Code analysis
- System behavior
- Historical research
- Restoration planning
- Engineering decisions
The Explorer's Journal documents the learning process behind each expedition.
Rather than describing the software itself, it records the journey of understanding it.
Topics include:
- New concepts learned
- Questions raised
- Breakthrough moments
- Mistakes and lessons
- Personal reflections
- Future investigations
One documents the software.
The other documents the explorer.
Together they tell the complete story.
The Lostware Initiative is built around several core principles.
- Understand before changing.
- Every design decision deserves investigation.
- Legacy code is history—not failure.
- Documentation is as valuable as code.
- Preserve knowledge before replacing implementation.
- Curiosity is more important than assumptions.
The BattleTech Character Creator is only the beginning.
The long-term goal is to build a growing archive of software archaeology projects documenting how legacy systems were designed, how they evolved, and how they can be understood by future developers.
Each expedition preserves more than source code.
It preserves knowledge.
Over time, the Lostware Initiative aims to become a resource for developers interested in:
- Legacy software
- Software architecture
- Reverse engineering
- Code modernization
- Software preservation
- Learning through real-world projects
The Lostware Initiative is developed through a collaborative workflow between a human investigator and AI.
AI is used to assist with:
- analyzing legacy code
- explaining historical technologies
- identifying architectural patterns
- brainstorming modernization strategies
- drafting and refining documentation
- reviewing design decisions
- organizing research
- preserving technical knowledge
All conclusions, engineering decisions, and implementation changes are reviewed and approved by the project's maintainer before being accepted.
The goal is not to replace human understanding.
The goal is to accelerate it.
The Lostware Initiative also explores how modern AI can help developers recover, document, and preserve software whose original design knowledge has been lost.
Rather than replacing human expertise, AI serves as a collaborative research assistant—helping uncover knowledge that might otherwise remain buried.
Knowledge is preserved through collaboration.
Whether you're an experienced developer, a software historian, or someone exploring their first legacy codebase, contributions are welcome.
You can help by:
- Documenting discoveries
- Improving architecture diagrams
- Researching historical technologies
- Verifying application behavior
- Modernizing code
- Reviewing documentation
- Asking thoughtful questions
Curiosity is just as valuable as expertise.
See the LICENSE file for licensing information.
Lostware is software that still exists but can no longer be fully understood without investigation.
Unlike abandonware, Lostware is not defined by its availability or licensing. A project may be open source, actively used, or even commercially supported and still qualify as Lostware if its original architecture, rationale, documentation, tooling, or institutional knowledge has been lost.
The Lostware Initiative focuses on recovering that knowledge through careful study, documentation, and restoration rather than replacement.
"The code survived. The understanding didn't."