We have Docker to freeze environments, but nothing to freeze logic. If you wrote a sorting algorithm in C++ 10 years ago, that code is "legacy" today. I wanted a way to deal with software rot.
Glupe is a "Reverse engineering engine" for logic. Normally it is intent -> code, I went the other way aroound code -> intent.
It works in two steps:
Refine: It "melts" source code into a high-level Intent file (.glp). This file is pure logic, stripped of syntax. Build: It re-compiles that Intent into any target language (C++, Python, Rust, Go).
I tested it on a legacy COBOL file. It successfully transpiled it to modern Python, correctly handling the PIC 9(5)V99 decimal logic that usually breaks other tools.
Example (COBOL -> Intent -> Python): https://github.com/alonsovm44/glupe/tree/master/experiments/...
Key Features:
Self-Healing: It has a built-in compilation loop. If the generated code fails (e.g., syntax error), Glupe feeds the error back to the AI and fixes it automatically.
Spaghetti Detection: If Glupe detects messy code (global variables, god loops), it attempts to refactor it into clean, modular intent before saving.
Language Agnostic: You can write logic once and deploy to C++ (high performance) and Python (prototyping). It's written in ~3k lines of C++ and runs locally with Ollama or cloud via API.
Repo: https://github.com/alonsovm44/glupe
I'd love feedback on the architecture or the "Intent" paradigm. Do you think this solves the legacy code crisis, or is it just a fancy transpiler?