Evolution of the Oxygene Language | Oxygene | RemObjects Software
Languages Platforms IDEs | Download Pricing |
The Oxygene Language. This is not your Daddy's Pascal.

Evolution of the Oxygene Language

This page takes a look at the evolution of the Oxygene language since its inception in 2004, from the very first release (then called "Chrome"), to our very latest.

Even when we started out in 2004 (working towards an early 2005 release), Oxygene took the Pascal language and thoroughly reinvigorated it with state-of-the-art features such as Class Contracts, "for each" loops and more, and started to make the language cleaner and more consistent with the Object Oriented model, with the "method" keyword, improved/cleaner visibility modifiers and other enhancements.

Over the following years, Oxygene only grew more powerful, as it advanced ahead of C# and Java (the two major languages of the time), integrated generics, sequences, queries, and parallelism ahead of its contemporaries and innovated the development space with vastly better nullable expressions, future types, and more.

Chrome 1.0 Early 2005

The first release of Oxygene came out in early 2005, and supported version 1.1 of the .NET Framework (the then current version), as well as the beta releases of .NET 2.0 available at the time. The 1.0 revolutionized Object Pascal, cleaned up a range of inconsistencies with other Pascal dialects (such as introducing the "method" keyword and doing away with the highly unsafe "wit"e as we knew it), and brought it up to date with language innovations from C#. It also introduced Class Contracts, an innovation inspired by the Design by Contract feature in Eiffel.

...and probably more features that we forgot about because they have become so natural and second-nature to use by now that we take them for granted.

Chrome 'Floorshow' (1.5) Late 2005

Despite its version moniker, 1.5 was really a major new release of the language, but versioned as .x release to make it available at no charge to existing users (our products were still licensed by version at the time). The main focus for 1.5 was to bring Oxygene up to date with official support for the .NET 2.0 framework (which, alongside C# 2.O, only shipped shortly after our release), with features such as Generics and Nullable types that were new to .NET 2.0.

One seemingly small feature that had a large impact (and would two years later be adopted in C# 3.0) was the introduction of Type Inference with the inline var keyword.

Chrome 'Joyride' (2.0) 2007

Once again being ahead of C# and the underlying .NET Framework, version 2.0 of the Oxygene language embraced "Sequences and Queries", making the concept of enumerable types a language-native construct, and adding support for LINQ.

2.0 also completely revamped the nullable types introduced in the previous release and fully integrating them into the language in ways that allow them to be used seamlessly in expressions and making possible the colon (":") operator — another small change that makes a big difference in day-to-day code.

Oxygene 3.0 2008/2009

Oxygene 3.0 (the first release under the language's new and final name) added two major new areas to the language.

The first was a focus on making multi-threaded development easier for the days of slowing CPU speed improvements and increasing number of CPU cores. Next to parallel for loops and improvements to asynchronous statements and thread synchronization options, the new future types are most interesting, allowing to define variables and fields whose value will be calculated out-of-band and asynchronously at a later time & mdash; with the types still seamlessly being usable in expressions or regular code patters without worrying about their asynchronous nature.

The second big addition was the introduction of Cirrus, a combination of language extensions and helper library that allows developers to leverage Aspect Oriented Programming (AOP) to achieve separation of concerns.

Oxygene 4.0 2010

A comparatively small update on the language side and focusing on other areas of the product, Oxygene 4.0 still brought a list of significant language enhancements, including the introduction of "if", "case" and "for" loop expressions, which promoted these three core language constructs from mere statements to being used inside of more complex expression trees and returning values.

Also introduced was language-native support for "dynamic" types, a feature that set the ground for becoming very important for Cocoa support in Oxygene 6.0.

Oxygene 5 2011

Oxygene 5's most distinguishing feature is the support for using the Oxygene language actively against the Java (and Android's Dalvik variant) frameworks and runtime, in addition to .NET/Mono.

Once again, the new version brought significant new features to the language, including support for drastically reducing the complexity of writing asynchronous code with the "await" keyword and the introduction of Duck Typing and its related Soft Interfaces.

Version 5.1 also introduced the new Mapped Types, a feature for framework designers to easily create zero-overhead mapping between different target APIs. Mapped Types lay the foundation for a major new feature, code named "Sugar", that is in the works for Oxygene 6.

Oxygene 6 2013

The major new feature for Oxygene 6 was the addition of Oxygene for Cocoa as third major platform. Oxygene 6 is scheduled to be released in early-to-mid 2013, and will of course be a update for all active subscribers.

  • unit level visibility
  • New write() and writeLn() compiler magic functions
  • Unified Entry Point syntax/signature
  • Improved block types
  • Multi-Part method names (Cocoa)
  • Automatic Reference Counting (Cocoa)
  • support for strong, weak and unretained object references (Cocoa)
  • inline methods (Cocoa)

Oxygene 7 Early 2014

The Version 7 product cycle focused mainly on RemObjects C#, the new sister language that uses the same compiler back-end as Oxygene. Nonethe less, Oxygene 7 introduces a range of new language features.

and more.

Oxygene 8 Late 2014 thru mid-2016

Similar to its predecessor, the version 8 product cycle focused mainly on RemObjects Silver, the third sister language that uses the same compiler back-end as Oxygene and C#. Oxygene 8 still got a few new language features:

  • not nullable type references
  • lazy properties
  • Smarter record support on Cocoa
  • Generic type aliases
  • Operator overloading for Cocoa and Java
  • Cross-platform await support
  • Labeled break and continue statements
  • Support for Events and Sets on Cocoa

Oxygene 9 Late 2016 thru mid-2017

The headline feature for Oxygene 9 is the addition of the new Island platform for creating native Linux and Windows apps with Oxygene. Language syntax wise, a highlight is the new Unified Class Syntax that (optionally) brings Oxgene closer to C# and Swift in not having to maintain interface and implementation of a class separately.

Oxygene 10 & 11 – Late 2017 and beyond

Oxygene 10 will be an ongoing flow of weekly releases, many of which adding new functionality to there Oxygene language itself.


  • Conditional compilation as part of code flow, with defined()
  • Platform checks with available()
  • Support for out var variable declarations
  • Support for discardable in tuples var (lName, nil) := ...
  • Support for general Discardables: nil := lFoo.SomePropertyWithSideEfefcts;
  • Support for out var parameters
  • Support for raise in expressions
  • Full support for nested methods
  • New platform: WebAssembly (via Island)







Love the idea of Oxygene, but prefer a different language?
Check out RemObjects C#, Swift or Iodine (Java)!