Your RPG codebase keeps the business running.
The people who understand it are leaving.
We migrate RPG systems to Java using a transpiler built specifically for RPG, not a generic tool. We start with a fixed-price pilot on your real code, then continue iteratively until the result is something your team can own and build on.
The window for an orderly migration is closing
Three pressures are converging. Each one is manageable alone. Together, they are not.
Key-person dependency
In most RPG shops, one or two people hold the real knowledge of how the system works. When they retire, resign, or fall ill, that knowledge goes with them. Replacing them is not possible. There is no meaningful RPG hiring pool for organisations that are not IBM itself.
Operational fragility
Systems that cannot be understood by your current team cannot be safely changed. Every patch is a risk. Every business requirement that touches the core system requires the same one or two people. The system is running, but it is increasingly brittle. The people who could fix a serious failure are not going to be there forever.
The cost of delay
Migration becomes harder, not easier, over time. The fewer people who understand the system, the more the migration depends on code archaeology rather than direct knowledge transfer. A migration started today, with your senior developers still available to answer questions, will be better and cheaper than one started in three years without them.
Two steps. No lock-in until you're confident.
Migration Pilot
We take a real program from your codebase (typically up to 1,000 lines of code), analyse its dependencies, and deliver a working Java translation backed by tests. Not a generic demo. Your own code, correctly migrated.
- Fixed price: EUR 3,000
- Real program from your codebase
- Delivered with a test suite
- 15-day money-back guarantee
Migration Flow
Once the Pilot is complete, we continue the migration in short, structured iterations. At the start of each iteration, you know exactly what will be translated. At the end, you receive the code, the tests, and the opportunity to give feedback.
- Priced after the Pilot, based on your actual codebase
- Structured into milestones; you fund one at a time
- Output tailored to your team's conventions and standards
- Previously migrated code updated to stay consistent
We don't promise perfect Java on day one. We deliver working Java and improve it with you.
Automated translation produces code that is semantically correct: it does what the original RPG did. That is the starting point, not the finish line.
From there, we work with you iteratively. Each iteration, you review the output: naming conventions, package structure, integration patterns, how the code fits your team's existing practices and architecture. That feedback shapes the next iteration and, where it applies, is applied retrospectively to code already delivered.
The result is Java that your team can understand, maintain, and extend. Not because we promised it would be clean, but because we built it that way together over several iterations.
Working translation
The first output is code that compiles, runs, and produces the same results as the original RPG. Verified by tests. This is the baseline.
Structured review
You and your team review the output. We discuss naming, structure, patterns, and anything that does not fit your conventions or architectural preferences.
Iterative refinement
Feedback is incorporated in the next iteration and applied consistently to previously delivered code. The codebase converges toward your standards, not generic ones.
Code you own
At the end of the engagement, you have Java code that your team understands and can build on, along with the tests and runtime needed to operate it.
RPG systems are complex. We do not treat implementation questions as details to figure out later.
If you have specific questions about how we handle a particular aspect of your system, read our technical deep dive. It covers the questions that experienced RPG developers and architects actually ask.
Read the technical deep dive →"The migration completed on time, on budget, and our team was writing new features in Java within a month of handover."
— IT Director, European manufacturing company
ERP system migrated from RPG to Java
A European manufacturing company was facing a critical talent gap: their senior RPG developers were retiring, and their ERP system (hundreds of thousands of lines of business logic) was at risk. Strumenta delivered a complete migration within the agreed timeline and budget, preserving all business logic and handing over a Java codebase their new team could immediately work with.
Read the full case study →
By the author of
Migrating RPG Code to Modern Languages
A practical playbook for teams modernising IBM i applications, covering migration strategies, target language selection, testing approaches, and how to manage the human side of a migration. Written by Federico Tomassetti, founder of Strumenta.
Why Java, specifically?
Java is not just a modern language; it is the right target for IBM i migrations. It runs on the JVM, which means it can co-exist with your RPG systems during the transition. It has the largest enterprise developer talent pool in the world. And code written in Java today will still be maintainable in 2045.
- Runs on IBM i alongside RPG (phased migration possible)
- Largest global talent pool, easy to hire
- Mature enterprise ecosystem (Spring, Jakarta EE, etc.)
- Excellent tooling: IntelliJ, Maven, Gradle
- Long-term language stability (30+ year track record)
Strict confidentiality
Your source code is handled under strict confidentiality. It is used only to perform the migration and is never shared or retained beyond the engagement.
You own everything delivered
The translated code, the test suite, and the runtime are yours. There is no subscription, no licence fee, and no ongoing dependency on us to operate what we delivered.
European infrastructure available
For European clients with data sovereignty requirements, we can run the entire migration toolchain on European-hosted infrastructure, with no dependency on U.S.-based services.
"We built RPG2Java because we had seen too much value lost in migration. RPG systems are the result of decades of work, refinement, and business reasoning. They deserve better than fragile rewrites, unreadable generated code, or unpredictable AI output. We wanted a better path: one that preserves what matters and still helps companies move faster."
— Federico Tomassetti, Strumenta
See what migration looks like on your own code.
The Migration Pilot takes a real program from your codebase (up to 1,000 lines), translates it to Java, and delivers it with tests. You evaluate the result before committing to anything further.
Start with a Migration PilotEUR 3,000 fixed price. 15-day money-back guarantee. We respond within 2 business days.