I built Glupe because I was frustrated that code "rot."

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?