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.

• Class Contracts (require/ensure sections and invariants)
• Multi-cast Events and delegates as language-native element
• True Virtual properties and events
• Namespace support
• Synchronization support (locking/locked)
• Extended for loop syntax (for each, for each matching)
• Improved with syntax (requiring variable declaration and adding optional "matching")
• using sections for safe object disposal
• loop infinite loops
• new operator for object instantiation
• empty methods
• async methods
• final class members
• sealed classes
• Enhanced case of statement with support for strings and case type of
• Operator overloading
• "unsafe" code
• Scoped Enums and Flags
• Sets
• Partial Classes
• method keyword to supersede "procedure" and "function"
• exit with result (like C-style "return")
• Inline read expressions for properties
• Boolean double comparisons (if 20 < x < 30 then …)
• is not operator (if foo is not String then …")

...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.

• Generics
• Syntax for binary number constants ("%101010")
• Iterators
• Nullable types
• Nested types
• Extended Constructor Calls (b := new Button(Name := 'Click Me');)
• Type Inference
• Fixed Size Buffers
• Different visibility levels for property getters and setters
• not in operator

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.

• Support for the Silverlight platform
• Partial Methods
• "index" support on "for each" loops
• Colon (":") operator and enhanced nullable expressions
• Support for consuming extension methods
• "sequence of" types
• Query Expressions (LINQ)
• "param"-style array parameters
• "implies" operator for Class Contracts
• Support for double-quoted (C-style) string literals
• Enhanced "exit" keyword
• Polymorphic delegates

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.

• "Cirrus": Aspect Oriented Programming
• "future" types
• Parallel "for" loops
• "async" statements
• Generic type variance
• Range enum types ("var teens: 13..19")
• Volatile fields
• Read-only classes
• "query-able sequences" and "parallel sequences"
• "locked" properties

• "raise" statements for events

• Optional warnings on Case Mismatch

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.

• Language-native Extension methods syntax
• if, case and for loop expressions
• Read-only local variables
• Tail recursion optimization
• Support for classic "begin/end." application entry points
• dynamic types
• Advanced lambda expressions with "begin/end" body
• Improved Delphi compatibility mode

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.

• The Oxygene Language expanded to the Java Runtime and WinRT
• Language-native Tuples
• Mapped Types
• ≤, ≥ and ≠ operators
• Duck Typing and Soft Interfaces
• Anonymous/Inline interface implementations
• Support for the "await" keyword
• More readable number literals ("c = 299 792 458";)
• Improved {$IF directives for condition compilation

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.

• A new Cross-Platform Compatibility Mode in the compiler
• Improved language parity between platforms, including * LINQ for Cocoa and Java * Multi-Part Method names for .NET and Java

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.

• New Unified Class Syntax for Oxygene
• Default interface implementations via Extensions
• New platform: Android NDK (via Island)

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.

2017

• 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)

2018

• Support for Interpolated Strings: var x := $'value is {Count}';
• Default interface implementations
• instancetype on all platforms
• Show require/ensures constraints in CC and enforced some at compile time
• Back-mapped methods in Mapped Types
• New platform: .NET Core

2019

• Support for Multiple Object Models on Island
• Native COM support on Island
• const var Method Parameters
• Support for Local Properties
• Allowing trailing commas in array literals
• await for Closure Callbacks
• Support for published members
• Trailing Closures
• Asynchronous Sequences and loops

2020

• Support for using the in operator on Arrays and Collections.
• Countless improvements to Delphi Compatibility Mode and to allowing more unsupported syntaxes in code that is IFDEF'ed out
• while matching loops

2021

• Static anonymous functions
• Support for using params with sequence types.
• Combined Interfaces
• Support for multiple uses clauses
• Support for await using
• Loop variable type inference for for/to loops

2022

• Support for unconstrained Generics on Island
• Support for multiple where clauses for Generic Constraints
• Easier custom operator declarations with InstanceType
• available() on all platforms

2023

• Support for type-checks with inline variable declaration.
• Required properties
• Simplified custom operator declarations
• Support for using the colon operator on indexers
• Support for the new Delphi Object Model and creating and using Delphi-compatible binary APIs