ILE (Integrated Language Environment)

The Integrated Language Environment (ILE) is IBM’s modular programming model for the AS/400 and its successors (iSeries, System i, and today’s IBM i). Rather than a single language, ILE is a common runtime and compilation framework shared by a family of ILE-enabled languages — ILE RPG, ILE COBOL, ILE C, ILE C++, and ILE CL — that lets code written in different languages be compiled separately and then bound together into a single, efficient program. For the millions of lines of business software running the world’s IBM i shops, ILE is the foundation on which modern application development takes place.

History & Origins

The AS/400, launched by IBM in 1988, inherited a programming model from its System/38 lineage known as the Original Program Model (OPM). Under OPM, each compiled program was a self-contained unit, and calls between programs were always dynamic — resolved at run time — which made cross-program calls relatively expensive and limited code reuse. A second model, the Extended Program Model (EPM), was later added to support languages like C and Pascal that expected a more conventional, stack-based calling convention.

To unify these approaches and to give the AS/400 a modern, modular architecture, IBM announced ILE on February 16, 1993, shipping it with OS/400 V2R3 that year. The first ILE compiler was ILE C/400. The environment reached its core constituency the following year: OS/400 V3R1, released in 1994, delivered ILE RPG (the new RPG IV), ILE COBOL, and ILE CL, bringing the platform’s dominant business languages into the new model. RPG IV — frequently called RPGLE — became the most visible face of ILE, and 1994 is often cited as the year ILE “arrived” for that reason.

Design Philosophy

ILE’s central idea is separate compilation and static binding. Where OPM treated each program as an isolated island, ILE breaks applications into smaller pieces that can be developed independently and then linked together. This brought to the AS/400 a discipline familiar from the C/Unix world — compile units into objects, then bind them — while preserving the platform’s deep integration between language, database, and operating system.

The model rests on a few foundational object types:

• Modules (*MODULE) — the output of compiling a single source member. A module is not directly runnable; it is the basic building block that gets bound into something executable.
• Programs (*PGM) — one or more modules bound together (with a designated program entry point) to form a runnable unit.
• Service programs (*SRVPGM) — collections of modules that export procedures for other programs to call, conceptually similar to a shared library or DLL. Updating a service program can update behavior across many callers without recompiling them.
• Binding directories — lists that tell the binder where to find the modules and service programs needed to resolve a program’s references.
• Activation groups — run-time substructures within a job that isolate a program’s resources (such as open files, dynamic storage, and commitment-control state), so that independently developed applications can coexist in the same job without interfering with one another.

Together these allow bound (static) procedure calls, which avoid the run-time resolution overhead of OPM’s dynamic program calls — generally making them faster — alongside genuine modularity and code reuse.

Key Features

Beyond binding and modularity, ILE introduced capabilities that reshaped how AS/400 developers wrote code:

• Inter-language calls — an ILE RPG program can call procedures written in ILE C, ILE COBOL, or ILE CL (and vice versa) within the same bound program, because they share a common runtime and calling convention.
• Procedures and prototypes — ILE RPG gained true subprocedures with typed parameters, local variables, and return values, encouraging structured, reusable code rather than monolithic programs.
• A common source-level debugger — the ILE debugger can step through bound modules regardless of which ILE language each was written in.
• Structured exception handling — ILE provides a consistent condition- and exception-handling architecture across its languages.
• Activation-group control — developers can scope resources and error recovery deliberately, a key technique for building robust, long-running server applications.

A representative ILE RPG subprocedure, written in free-format RPG IV, illustrates the modular style ILE encourages:

**free
// A small subprocedure that can be compiled into a module and
// exported from a service program for other ILE programs to bind to.
dcl-proc addTax export;
  dcl-pi *n packed(11:2);
    amount packed(11:2) const;
    rate   packed(5:4)  const;
  end-pi;

  return amount + (amount * rate);
end-proc;

This procedure can be compiled to a *MODULE, bound into a *SRVPGM, and called statically from RPG, COBOL, C, or CL programs across an application — exactly the kind of reuse OPM made difficult.

Evolution

ILE has evolved in lockstep with the operating system it lives in. After the 1993–1994 introduction, ILE C++ added object-oriented capabilities around 1995. The platform itself was rebranded repeatedly — eServer iSeries in 2000, later System i, and finally IBM i beginning with IBM i 6.1 in 2008 — but ILE remained the recommended way to build software throughout, with OPM and EPM retained mainly for legacy compatibility.

The hosted languages kept advancing within the ILE framework. ILE RPG in particular moved steadily away from RPG’s punch-card heritage: free-format calculation specifications, and eventually fully free-format source (introduced via Technology Refreshes for IBM i 7.1 around 2013), let developers write RPG that reads like a modern structured language while still compiling into ILE modules and service programs. Successive releases — IBM i 7.2, 7.3, 7.4, 7.5 (2022), and 7.6 (2025) — have continued to enhance the ILE RPG, COBOL, C/C++, and CL compilers.

Current Relevance

ILE is actively supported and developed today. The ILE compiler family ships with current IBM i releases, and IBM continues to add language features, particularly to ILE RPG and ILE COBOL, with each Technology Refresh. IBM i 7.6, released in April 2025, runs on IBM Power10 (and later) hardware and carries the ILE toolchain forward.

The model underpins an enormous installed base of business-critical software in banking, insurance, manufacturing, distribution, and retail — domains where IBM i’s reliability and integrated database have kept it entrenched for decades. Modern IBM i development leans heavily on ILE practices: building applications as collections of service programs, exposing reusable procedures, and integrating with newer technologies (web services, SQL, and open-source runtimes via PASE) while preserving decades of accumulated RPG and COBOL logic.

Why It Matters

ILE represents one of computing’s more successful examples of modernizing a platform without abandoning its software. Faced with a model (OPM) that limited reuse and performance, IBM introduced separate compilation, static binding, and shared service programs to the AS/400 — bringing it conceptually in line with the linker-based world of C while keeping the tight language/database/OS integration that made the platform distinctive. For RPG especially, ILE was transformative: it turned a fixed-format report-generation language into a modular, procedure-oriented language capable of structured, maintainable enterprise applications. More than three decades after its introduction, ILE remains the living programming model for IBM i, quietly running core systems across the global economy.