Just Call It RPG (and Stick the OS Version On the End)

There is a special breed of IBM i programmer who will fight you to the death over the name of the box. Call it an IBM i Power system and watch their blood pressure climb. Mention Power Systems running IBM i and they start twitching. No, they insist, it is still an AS/400, always has been, always will be, and any other name is marketing nonsense dreamed up by people who never punched a card.

The same people will then turn around and argue until they are blue in the face that RPG and RPG ILE are completely different languages, as if the compiler somehow reinvented itself one Tuesday afternoon in the mid-nineties. Meanwhile another camp casually calls everything written after 1995 “RPG4” as though that single digit magically captures thirty years of continuous improvement.

So let me propose a simple, clean, and almost certainly unpopular solution that will upset all of them at once.

The Language is called RPG!

Java is Java. COBOL is COBOL. Nobody walks around saying “Java 17 on the OpenJDK HotSpot JVM for Linux x86-64” every time they mention the language. They just say Java. The version number only appears when it actually matters.

So why do we still dance around RPG?

I propose we stop. Call the language RPG. Then, when you need to be precise about the flavour, tack on the platform generation that defined it.

• RPG 38 for the System/38 days
• RPG 400 for the classic AS/400 era
• And once ILE arrived and the continuous improvement model kicked in, simply use the IBM i version: RPG 7.6

That is it. No more “RPG IV”, “RPGLE”, “ILE RPG”, “free-format RPG”, or any of the other marketing labels that have accumulated over the decades. It is still RPG. It has just been getting better with every release of the operating system it lives on.

Why the Name Matters

The endless arguments about “AS/400 is dead, long live Power Systems running IBM i” miss the point. The language did not die and get replaced. It evolved. The same way Java evolved from 1.0 to 21 without anyone insisting we rename it every few years. The same way COBOL is still COBOL even though the 1985 standard looks nothing like the original 1959 version.

RPG started life in 1959 as a Report Program Generator on the IBM 1401. It grew into RPG II on the System/3 family, then took a massive leap with RPG III on the System/38 in 1978. That is where structured programming (IF/ENDIF, DO loops, subroutines) arrived and the cycle started becoming optional for most of us.

When the AS/400 landed in 1988 it brought RPG/400, which was essentially RPG III with a new name and a few tweaks. Then in the mid-1990s ILE arrived and we got the real modern RPG: procedures, prototypes, modules, service programs, and eventually free-format source. Every Technology Refresh and every major IBM i release since then has quietly improved the language. We just kept inventing new labels for the same thing.

Calling it RPG 7.6 makes the continuity obvious. The language that ran on your System/38 in 1980 is the direct ancestor of the code you write today on IBM i 7.6. Same family. Better tools. More features. Still RPG.

Old School vs New School

Here is the classic fixed-format, column-based style that many of us cut our teeth on (RPG 400 era, still perfectly legal today):

     H DEBUG(*YES)
     FCUSTMAST  IF   E           K DISK
     D Name            S             30A
     C     Key           CHAIN     CUSTMAST
     C                   IF        %FOUND
     C                   EVAL      Name = CUSTNAME
     C                   ENDIF
     C                   EVAL      *INLR = *ON

And here is the same idea in modern free-format RPG (what we should just call RPG 7.6):

**free
ctl-opt debug(*yes);

dcl-f custmast disk(*ext) keyed;

dcl-s name char(30);

chain key custmast;
if %found;
  name = custname;
endif;

*inlr = *on;

Or of course, using SQL RPGLE where it’s still pure RPG under the covers… just with SQL doing the heavy lifting:

**free
ctl-opt debug(*yes);

dcl-s name char(30);
dcl-s key  char(10); 

exec sql
  select custname
    into :name
    from custmast
   where keyfld = :key;

if sqlcode = 0;
  // record found – name already contains custname
endif;

*inlr = *on;

Same language. Same compiler family. One is constrained by columns that made sense on punch cards. The others reads like every other modern language. The free-format version is simply the current state of RPG after decades of incremental improvement.

Continuous Improvement Is the Point

IBM has never stopped improving RPG. Every major IBM i release and almost every Technology Refresh has added something useful:

• Fully free-form source (no more column 8 restrictions)
• Nested data structures, better NULL handling, %SUBARR, %LOOKUP family, and a mountain of new BIFs
• Support for longer names, better CCSID handling, and tighter integration with SQL
• Modern development tooling (Code for IBM i in VS Code, improved RDi, Git-friendly workflows)

The recent IBM i 7.6 technology refreshes continue that tradition.

In TR1 (Fall 2025) we finally got proper typed enumerations. You can now define an enum with a data type and then declare variables, parameters, and return values “like” that enum. The compiler enforces that only the named constants from the enum are valid. No more magic numbers leaking into your procedures.

Example:

dcl-enum colorCodes int(3) qualified;
  blue 1;
  green 2;
  yellow 3;
  no_color -1 dft;
end-enum;

dcl-s color like(colorCodes);
dcl-s favourite like(colorCodes) inz(colorCodes.blue);

In TR2 (2026) we got assertion operations: ASSERT-F and ASSERT-T. These let you write self-documenting checks that can throw exceptions during development, write warnings to the job log in production, or be completely disabled. Perfect for unit testing and defensive coding.

assert-f cust_id = 0 %msg('Customer ID cannot be zero');
assert-t %upper(name) = name %msg('Name should already be upper case');

There are also nicer ON-EXCP generic message IDs, the ability to define a field LIKE(*EXT) from an external file, and new lookup BIFs such as %LOOKUPNE.

None of these features required inventing a new language name. They are just the next set of improvements to RPG, delivered with the operating system that hosts it.

Welcome to RPG 7.6!

Stop arguing about whether the platform is still “AS/400” or “Power Systems running i”. That conversation is a distraction. The language is RPG. It has been RPG since 1959. The version that runs on current IBM i systems is RPG 7.6, the direct descendant of RPG 38 and RPG 400, continuously improved with every release.

Write free-format. Use the new BIFs and enums and assertions. Keep the old fixed-format code running if you still need it (the compiler is remarkably tolerant). And when someone asks what language you are writing, just say RPG.

Welcome to RPG 7.6.