IBM i modernisation with .NET

NTi data provider allows you to call your RPG, CLP, or even older 36 programs exactly as they exist today, from C# and .NET, without modifying your IBM i code.

Each program is executed natively on the IBM i, with the same parameters, the same libraries, and the same behavior as in 5250.

From .NET you can:

• Open an NTi connection
• Prepare a parameter list (Input, Output or InputOutput)
• Call the program using CallProgram()
• Read returned values (CHAR fields, structures, buffers, etc.)

Your business logic remains 100% IBM i, but integrates immediately into a modern application, web or API, containerised or not. It is the simplest way to expose your RPG assets to the .NET ecosystem, without refactoring, without migration, without risk.

NTi relies exclusively on the security mechanisms of the IBM i:

• System authentication
• Authorizations
• SSL/TLS
• MFA

All the rules remain those defined on the machine, without modifying your existing model. Modernisation happens on the .NET side, but security continues to be ensured by the IBM i, with the same level of reliability and control as your current applications.

Yes. NTi enables incremental modernisation: you keep your programs and DB2 data, then add new .NET modules as needed.

Concrete example:

You already have a CLIENTS file, an RPG program that validates and updates the data, and an interactive screen that calls this logic.
With NTi, you keep exactly this behaviour and build alongside it a modern web interface that uses that same RPG program to validate or save the data, without rewriting.

No. Nothing is installed on the IBM i.

NTi runs only inside your .NET application. You simply add a NuGet package to your .NET project, and it is the application that communicates natively with the IBM i, not the other way around.

Whether you run your app on a Windows server, a Linux system, a Docker container, or in the cloud, NTi always runs within .NET, never on the IBM i.

Result: instant deployment, no need to involve system teams, and a clean architecture where everything stays on the .NET side.

This is the daily reality for many IBM i teams. The programs exist, but their parameters, structures, or business rules are no longer documented.

.NET and NTi simplify this situation because each RPG, CLP or API call becomes explicit in the .NET code. You define your parameters, your types, your lengths, your buffers, and this definition becomes your documentation.

As you integrate your programs into .NET, you automatically rebuild clear documentation: which programs are called, with which parameters, in which order, and with what return values.

Even without historical documentation, your system becomes readable, manageable, and structured again. You give new life to your IBM i assets, supported by widely available and sustainable .NET skills.