NetRexx

NetRexx is a general-purpose programming language for the Java Virtual Machine that takes its syntax and philosophy from Rexx and its object model, static typing and libraries from Java. Its designer, Mike Cowlishaw, had created Rexx at IBM in 1979 with “just one objective: to make programming easier than it was before”, and NetRexx applies the same objective to Java: the language reference describes it as “a dialect of Rexx that can be as efficient and portable as languages such as Java, while preserving the low threshold to learning and the ease of use of the original Rexx language.” A NetRexx program can be a single line - say 'Hello, World!' - or a full set of classes that Java code can call without knowing they were not written in Java, because “NetRexx classes and Java classes are entirely equivalent.”

NetRexx holds a particular place in JVM history. Its first public build, 0.50, was released on 22 April 1996, less than a year after Java itself, which makes it - by the project’s own account and by common consent - the first language other than Java to target the JVM; Per Bothner’s Kawa Scheme, the other candidate, first appeared that June. The language reached 1.00 in January 1997, gained an interpreter in 2000, was bundled with IBM’s VM/ESA mainframe operating system, and provided the prototype for the decimal arithmetic that went into Java 5’s BigDecimal. IBM handed the implementation to the Rexx Language Association in June 2011, and RexxLA has released a new version roughly every year since, most recently NetRexx 5.10 in March 2026, with support for the Java module system, a Language Server Protocol implementation and a new concurrency instruction. Thirty years on it remains a small language with a small community, but it is neither abandoned nor frozen.

History and origins

An IBM Fellow’s experiment (1995-1997)

In 1995 Cowlishaw, then an IBM Fellow at the company’s Hursley laboratory in England, ported Sun’s new Java to OS/2 as part of IBM’s multi-platform Java strategy. The RexxLA Programming Guide tells the rest: he “soon after started with an experiment to run Rexx on the JVM.” The acknowledgements in the language reference are frank about what made that possible - “my appointment as an IBM Fellow made it possible to make the implementation of NetRexx a reality in months rather than years” - and the early release notes show how quickly it went. NetRexx 0.50, “the first non-‘IBM internal’ release of NetRexx - the OS/2 Rexx prototype”, appeared on 22 April 1996. Its translator was written in Rexx, tokenised and turned into an OS/2 executable, and it emitted Java source that the JDK’s javac then compiled. A trickle of releases followed through 1996: 0.54 (30 April) added a substantial sample application, 0.88 (1 December) delivered “the full function intended for NetRexx 1.00”, including the power operator and forward references, and 0.90 (17 December) was the “gamma” release, which moved the compiler into the COM.ibm.netrexx.process package “to comply with the Java language recommendations” of the time - a short-lived convention of upper-casing the top-level domain that, the 2012 release notes note wryly, “NetRexx was one of the few packages that followed this advice.”

Self-hosting came early: with 0.67 (27 June 1996) “the compiler is now entirely written in NetRexx, and so should run on all platforms that support the Java toolkit”, superseding the OS/2 Rexx translator that had ended at 0.62. NetRexx 1.00 was released in January 1997 with, as the RexxLA Programming Guide puts it, “a translator bootstrapped to NetRexx”. Cowlishaw presented “NetRexx - an alternative for writing Java classes” at IEEE COMPCON 97 in early 1997 and published The NetRexx Language (Prentice-Hall, ISBN 0-13-806332-X) the same year; the book, like The Rexx Language before it, was typeset from GML markup with IBM’s Document Composition Facility and doubled as the language definition. Updates to 1.00 continued through May 1997 (one 15 April note records that the translator “now runs 35% faster than the first (January) 1.00 release”), 1.01 (15 June) introduced the NetRexx Supplement documenting extensions beyond the book, and 1.02 (25 June) added the shared visibility keyword and array initialisers. The 1.1xx line, requiring Java 1.1, ran from 1.103 in July 1997 to 1.160 in February 2000.

IBM got behind it. The International Technical Support Organization’s Redbook Creating Java Applications Using NetRexx (SG24-2216, September 1997) walked through GUI, database, socket, RMI, CGI and JavaBeans programming in NetRexx on OS/2 Warp, Windows 95 and Windows NT, and thanked “Mike Cowlishaw, IBM Fellow, UK Laboratories Hursley, for inventing NetRexx and supporting our effort all the way.” An independent NetRexx Tutorial by Pierantonio Marchesini of ETH Zürich reportedly circulated in the same period, though it is no longer hosted on the project site. And on the platform where Rexx had been born, IBM shipped “Java Development Kit and NetRexx” as part of VM/ESA Version 2 Release 3, available 24 March 1998, following it with a second Redbook, VM/ESA Network Computing with Java and NetRexx (SG24-5148, November 1998), whose authors argued that NetRexx was the natural bridge for the mainframe’s large population of Rexx programmers.

NetRexx 2 and the quiet years (2000-2010)

NetRexx 2.00, released on 26 August 2000, was “a major new release” for one reason above all: it added an interpreter. Until then NetRexx had been purely ahead-of-time - source went through the translator to Java source to javac to class files - and 2.00’s “NetRexx interpreter, which allows programs and classes to be run without being compiled” turned it into a scripting language as well as a compiled one, with a -prompt option that kept the translator loaded for “sub-second compilation and interpretation.” Maintenance releases 2.01 (April 2001) and 2.02 (May 2001) followed, and then the pace slowed sharply; the IBM line ended with 2.05, and the mainframe bundling ended too, IBM’s z/VM Version 5 Release 1 migration guide recording in 2004 that “Java and NetRexx support has been removed from z/VM.”

The most consequential NetRexx work of these years was not in NetRexx releases at all. From about 1998 (the package’s copyright notice starts that year) Cowlishaw developed an enhanced BigDecimal class, com.ibm.math.BigDecimal with a companion MathContext, implementing the decimal floating-point arithmetic of ANSI X3.274-1996 (the Rexx standard) so that Java could “do arithmetic the way people do.” It was “fully implemented and… available in both Java and NetRexx”, reached version 1.09 in April 2003, “formed the basis for a Java Specification Request completed in 2004” - JSR 13 - and “the revised BigDecimal class and the new MathContext class were shipped in Java 5.” That is the one clear case of NetRexx influencing Java rather than the other way round; the same decimal arithmetic specification later formed the basis of the decimal parts of IEEE 754-2008.

By 2009 a language reference titled NetRexx 3, dated 22 May and jointly credited to “Rexx Language Association and Mike Cowlishaw”, was already circulating - the open-sourcing was being prepared. Cowlishaw took early retirement from IBM in March 2010, and for a while the future of the IBM code was uncertain.

RexxLA and the open-source era (2011-2026)

On 8 June 2011 IBM announced the transfer of the NetRexx source code to the Rexx Language Association under the ICU licence, “14 years after the v1.0 release.” The first RexxLA commit, on 11 June, was labelled NetRexx 3.00, “the first build of the sourcecode by RexxLA” - essentially IBM’s 2.05 with ICU notices and small fixes so that it compiled on Java 1.5 and later. The language reference thanks Matthew Emmons “for piloting NetRexx through the convoluted legal and other processes, and… René Jansen for massaging the NetRexx reference implementation into shape for its Open Source release.” A RexxLA NetRexx Architecture Review Board, with Cowlishaw as Language Architect, took over the language definition.

NetRexx 3.01 (23 August 2012) was “the first official RexxLA release.” It renamed the translator package to org.netrexx.process, bundled the Eclipse batch compiler so that NetRexx could compile without a JDK, added an Ant task, an in-memory translation API, and “100+ Rosettacode.org examples by Alan Sampson”, and consolidated Cowlishaw’s book, overview and supplement into a single donated Language Reference. Releases then came roughly yearly: 3.02 (June 2013), 3.03 (May 2014), 3.04 (June 2015, which integrated Ed Tomlinson’s Pipes for NetRexx and adopted the JSR 199 compiler API so that Java source no longer needed to touch disk), 3.05 (April 2017, “the first release after Kermit Kiser’s passing”, moving the project from Subversion to Git), 3.06 and 3.07 (2017-2018), 3.08 (2019, which revived Martin Lafaix’s NetRexx Workspace as the nrws REPL and added a Docker image to the distribution, dropped again in 3.11), and 3.09 and 3.11 (2020), dominated by Jeff Hennick’s CMS-compatible Pipelines stages.

The Java module system introduced in JDK 9 was an existential problem for a translator that leaned on the old class-loading rules, and NetRexx 4.01 (20 March 2021) - “the first NetRexx release compatible with the JDK >=9 module system, thanks to Marc Remes” - solved it while retaining Java 8. The 4.x releases then turned toward Classic Rexx compatibility: ADDRESS and DATE/TIME in 4.01, ADDRESS WITH and Rexx-style stream I/O in 4.03 (May 2022), a non-object “scripting mode” and interactive TRACE in 4.04 (September 2022), shebang support and Classic Rexx functions in 4.05 (May 2023), fixes in 4.06 (March 2024). NetRexx 5.01 (2 May 2025) added INTERPRET, multi-line text blocks and Java-8-format class files by default; 5.10-GA (20 March 2026) added a GO instruction and RexxChannel for concurrency, default methods on interfaces, and a Language Server Protocol implementation with Visual Studio Code and IntelliJ plugins. Commits to the repository continue as of August 2026.

Design philosophy

The language reference lays out the reasoning in a section titled “A hybrid or a whole?”, and it is candid that the outcome was not obvious: “when first designing NetRexx, it was not at all obvious whether the new language would be an improvement on its parents, or would simply reflect the worst features of both.” The design rests on a handful of commitments carried over from Rexx and adjusted for the JVM:

• Readability first. “One concept was central to the evolution of Rexx syntax, and hence NetRexx syntax: readability.” Punctuation is required “only when absolutely necessary to remove ambiguity”; the language is case-insensitive; clauses can be spread over lines or packed onto one. Cowlishaw designed Rexx “to make life easier for its users, rather than for its implementers”, and NetRexx keeps that priority.
• Keyword safety. Rexx keywords are recognised only in context, never globally reserved, which is how Rexx grew for decades without breaking programs. NetRexx “takes the concept of keyword safety even further than in Rexx.” You can name a variable class or loop if you must.
• Natural data typing and decimal arithmetic. By default, values are strings, and numbers are strings that look like numbers, handled with arbitrary-precision decimal arithmetic under the control of numeric digits. “There are, for example, no fundamentally different concepts of integer and real; there is just the single concept of number.” The reference traces this idea to Kemeny and Kurtz’s BASIC.
• Strong typing without more typing. Types matter “at interfaces - where it provides most value - but within methods it is subservient and does not obscure algorithms.” Method signatures are typed; local variables take their type from the first assignment. The slogan the project has used for years is “strong typing without more typing.”
• Binary when you ask for it. “A simple concept, binary classes, also lets the programmer choose between robust decimal arithmetic and less safe (but faster) binary arithmetic for advanced programming where performance is a primary consideration.” A single options binary switches a class to Java primitive arithmetic.
• Be a full JVM citizen. Rather than fight the JVM’s object model, exception model and primitive types, NetRexx adopts them, so that “NetRexx can use any Java class (and vice versa).” The price, acknowledged in the reference, is that “unlike Object Rexx, it could not be a fully upwards-compatible extension” of Rexx.

Key features

Low-boilerplate programs

The reference’s “simplest, documented, NetRexx program that has an effect” is one line:

/* This is a very simple NetRexx program */
say 'Hello, World!'

There is no class declaration and no main method because the translator generates them: a file that begins with instructions rather than a class becomes a class named after the file with a static main. Since 4.04 this “scripting mode” also accepts Rexx’s traditional function notation - left(s, 4) as well as s.left(4) - so a great deal of Classic Rexx runs unchanged. Comments use /* */ or --, strings take single or double quotes, and adjacent expressions concatenate with a blank (say 'Total:' n * 2) or, with ||, without one.

Rexx strings and unlimited-precision arithmetic

The default type is Rexx, a string class from netrexx.lang that is also a number. Arithmetic is decimal, exact to numeric digits places (nine by default), with the rounding and exponent rules of the ANSI Rexx standard:

numeric digits 40
say 2 ** 100                  -- 1267650600228229401496703205376
say 1 / 3                     -- 0.3333333333333333333333333333333333333333
say '   padded  '.strip       -- padded
say 'Hello'.reverse           -- olleH

Every Rexx built-in function - substr, pos, word, translate, format, d2x, c2x and the rest - is a method on Rexx, so s.substr(2, 3) works, and the class implements Comparable, Serializable and Iterable and can be constructed from any CharSequence; the translator converts between Rexx, String, char, int, double and the other primitives automatically “where safe”, so a Rexx can in practice be handed to a method expecting a String.

Parsing

Rexx’s parse instruction, with its template of literal patterns, positional markers and placeholder dots, is intact:

parse arg first last .
parse '2026-08-27' year '-' month '-' day
parse line 1 code +3 rest
say year month day code

Control structures

There is one loop, loop, which covers all the forms:

loop i = 1 to 10 by 2
  say i
end

loop while queue.size > 0
  say queue.remove(0)
end

text = 'the quick brown fox'
loop i = 1 to text.words
  say text.word(i)
end

loop label outer for 3
  loop for 3
    leave outer
  end
end

if/then/else and select/when/otherwise come from Rexx; do ... end groups instructions and, crucially, any block - a do, a loop, a method - can carry catch and finally clauses, so “exception handling can be applied to all blocks rather than requiring an extra construct”:

do
  n = Integer.parseInt(text)
  say 'Parsed' n
catch NumberFormatException
  say text 'is not a number'
finally
  say 'done'
end

Exceptions are Java exceptions. A method that lets a checked exception escape declares it with signals, and signal raises one.

Classes, methods and properties

class Account
  properties private
    balance = Rexx 0
    owner   = String

  method Account(name = String, opening = Rexx 0)
    owner = name
    balance = opening

  method deposit(amount = Rexx)
    if amount <= 0 then signal IllegalArgumentException('deposit must be positive')
    balance = balance + amount

  method getBalance returns Rexx
    return balance

  method toString returns String
    return owner':' balance

class opens a class that runs to the next class or the end of the file; properties introduces fields with a visibility (private, public, shared, inheritable) and optional static, constant or indirect (which generates JavaBean getters and setters); a method with the class’s name is a constructor. Arguments are written name = type, and a default value after the type makes the argument optional. Single inheritance is spelled class Savings extends Account, interfaces implements, and method ... static, abstract, final, protect (synchronised) and binary map to their Java meanings. The Rexx class is itself indexable - switch['on'] = 1, loop key over switch - which gives NetRexx the associative arrays that Rexx calls stems, with [] instead of the dot.

Java without ceremony

Any Java class is available after an import, and no new is required:

import java.util.
import javax.swing.

names = ArrayList()
names.add('Ada')
names.add('Grace')
loop n over names
  say n
end

frame = JFrame('NetRexx')
frame.getContentPane.add(JLabel('Hello from the JVM'))
frame.setSize(240, 100)
frame.setVisible(1)

Booleans are 1 and 0, as in Rexx; Rexx values convert to String and back automatically; and, since 4.01, the JDK module system is understood, so javafx, java.sql and the rest resolve as they would from Java.

Compile, interpret, or both

The nrc command drives the translator: nrc hello translates hello.nrx to Java and compiles it (with javac, or with the bundled Eclipse compiler when no JDK is present); nrc -run hello compiles and runs; nrc -exec hello interprets without producing class files; nr hello.nrx is the scripting shortcut, and #!/usr/bin/env nr makes a script executable on Linux and macOS. -keepasjava keeps the generated Java source, which is readable enough that some people have used NetRexx as a Java-generation tool. trace results and trace var print every clause and value as the program runs, and nrws offers a workspace with history, editing and direct pipeline execution. NetRexx is also a JSR 223 scripting engine, so Java programs can embed it through javax.script.

Pipelines

NetRexx ships with an implementation of IBM’s CMS Pipelines, a data-flow language in which records pass through a chain of stages:

pipe < input.txt | locate /error/ | change /error/ERROR/ | > errors.txt

Pipelines can be run from the pipe command, compiled with pipc, or issued from a NetRexx program with ADDRESS PIPE, and new stages are written as NetRexx classes; stages are multi-threaded and multi-stream, as on VM.

Evolution

The direction of travel since 2021 is instructive: rather than chase Java’s newest syntax, RexxLA has been pulling NetRexx back toward Rexx - making Classic Rexx scripts run unchanged, adding the ADDRESS environments and stream functions that Rexx programmers expect - while keeping the JVM plumbing current. The audience the project is serving is the one Cowlishaw designed for in 1995: Rexx programmers who want the JVM’s libraries and portability without giving up the language they know.

Current relevance

NetRexx is actively maintained. The repository shows sustained activity - over 300 commits in 2020, 260 in 2022, more than 100 in each of 2023 and 2025, and commits through August 2026 - and general-availability releases have appeared every year since 2017. The three manuals (Language Reference, Programming Guide, Pipelines Guide and Reference) are kept in step with each release and are available as PDFs; the Language Reference has also been sold as a printed book since the 4.06 release in 2024, and the Pipelines Guide carries its own ISBN. Documentation, downloads, a mailing list at groups.io and a Rosetta Code presence of roughly 300 pages give a newcomer plenty to work from, and René Jansen’s Docker image (Debian, JDK 17, Pipelines and workspace included) removes the installation step entirely.

It is also, unavoidably, a small language. Its natural constituency - mainframe and OS/2 Rexx programmers - is shrinking, IBM’s own bundling ended in 2004, and the JVM has since acquired Groovy, Scala, Clojure and Kotlin, each with far larger communities. NetRexx’s niche is specific: people who already think in Rexx, who need decimal arithmetic that behaves like arithmetic, or who want to write JVM code with as little syntax as possible. Within that niche it works, on any JDK from 8 upward, on Linux, macOS and Windows - the platforms the release notes and Docker image cover - and on z/OS, whose compatibility the 3.04 notes specifically restored.

The “Dormant” status attached to NetRexx in some language catalogues (including the master list this encyclopedia is drawn from) reflects the IBM years and the modest size of the community rather than the current state of the project; by any reasonable definition - releases, commits, documentation, tooling - NetRexx in 2026 is alive.

Why it matters

NetRexx matters first as a historical marker. It was the first demonstration that the Java Virtual Machine was a general-purpose target and not merely Java’s runtime: a language with a completely different syntax, a different numeric model and a different attitude to typing could compile to class files that Java could load, subclass and call without noticing. Cowlishaw’s 1997 COMPCON paper called it “an alternative for writing Java classes”, and the language reference framed the JVM as a “concrete interface between language and machine” - the idea that, a decade later, would make the JVM home to dozens of languages. Kawa followed within weeks, Jython within a year or two; NetRexx got there first.

It matters, second, as the vehicle for decimal arithmetic in Java. The BigDecimal and MathContext classes that ship in every JDK since Java 5 were prototyped in NetRexx, drawing on the arithmetic that Cowlishaw had defined for Rexx and standardised in ANSI X3.274. Anyone who has written new MathContext(10, RoundingMode.HALF_EVEN) has used NetRexx’s legacy, whether they know it or not.

Third, NetRexx is the purest expression of a design philosophy that ran against the grain of its era. In 1996 the fashionable answer to “how do we make Java easier?” was tooling; Cowlishaw’s answer was to strip the language back to what people actually need to write - no new, no semicolons, no reserved words, one loop construct, exception handling on any block, numbers that behave like numbers - while keeping every ounce of static typing that mattered at interfaces. “Strong typing without more typing” anticipated the type inference that Java itself would not get until var in 2018, and the case for decimal-by-default arithmetic in a business language has never been answered so much as ignored.

And it matters as a case study in survival. IBM built it, bundled it, then let it drift; a volunteer association took it on in 2011, kept it compiling through the module system upheaval that broke far larger projects, and has shipped eighteen general-availability releases since. That a thirty-year-old language with a small community has a Language Server Protocol implementation and IntelliJ plugin in 2026 says something about what a determined small community can do - and about the durability of a design that was, from the start, made “for people, not computers.”

Further reading

• netrexx.org - the official site: downloads, the Language Reference, Programming Guide, Pipelines Guide and Reference, and release announcements
• RexxLA/NetRexx on GitHub - mirror of the SourceForge repository, including releasenotes.md with the complete release history back to 0.50 in 1996
• Mike Cowlishaw, The NetRexx Language, Prentice-Hall, 1997, ISBN 0-13-806332-X
• Mike Cowlishaw, “NetRexx - an alternative for writing Java classes”, Proceedings of IEEE COMPCON 97, pp. 200-205, Spring 1997
• IBM Redbooks: Creating Java Applications Using NetRexx (SG24-2216, September 1997) and VM/ESA Network Computing with Java and NetRexx (SG24-5148, November 1998), both mirrored at netrexx.org
• Decimal Arithmetic for Java - Cowlishaw’s BigDecimal package, in NetRexx and Java, that became JSR 13
• René Jansen, “From Rexx to NetRexx”, 36th International Rexx Symposium, Vienna, 2025, and Marc Remes, “NetRexx internals”, RexxLA 2025 - both on rexxla.org
• rvjansen/netrexx on Docker Hub - the community Docker image