Pure Object-Oriented Language, Experimental

EO (stands for Elegant Objects or ISO 639-1 code of Esperanto) is an object-oriented programming language based on 𝜑-calculus. We're aware of popular semi-OOP languages and we don't think they are good enough, including: Java, Ruby, C++, Smalltalk, Python, PHP, C#. All of them have something we don't tolerate:

• types (why?)
• static/class methods or attributes (why?)
• classes (why?)
• implementation inheritance (why?)
• mutability (why? and why not?)
• NULL (why?)
• global scope (why?)
• type casting (why?)
• reflection (why?)
• scalar types and data primitives
• annotations (why?)
• operators
• traits and mixins (why?)
• flow control statements (for, while, if, etc)

Quick Start

First, install Java SE and npm.

Then, install eoc:

bash npm install -g eolang@0.32.1

Then, start with a simple EO program in the app.eo file:

```eo

Just prints hello.

[args] > app QQ.io.stdout > @ "Hello, world!\n" ```

Compile it like this (may take up to a minute or so):

bash eoc --easy link

Then, run it:

bash eoc --easy --alone dataize app

You should see "Hello, world!" printed.

Simple Tutorial

In the example above, we create a new abstract object named app, which has a single attribute named @. The object attached to the attribute @ is a copy of the object stdout with a single argument "Hello, world!". The object stdout is also abstract. It can't be used directly, a copy of it has to be created, with a few required arguments provided. This is how a copy of the object stdout is made:

text QQ.io.stdout "Hello, world!\n"

The indentation in EO is important, just like in Python. There must be two spaces in front of the line in order to go to the deeper level of nesting. This code can also be written in a "horizontal" notation:

text QQ.io.stdout "Hello, world!"

Moreover, it's possible to use brackets in order to group arguments and avoid ambiguity. For example, instead of using a plain string "Hello, world!" we may want to create a copy of the object stdout with a more complex argument: a copy of the object sprintf:

```eo

Says hello to Jeff.

[] > app QQ.io.stdout > @ QQ.txt.sprintf "Hello, %s!" * "Jeffrey" ```

Here, the object sprintf is also abstract. It is being copied with two arguments: "Hello, %s!" and "Jeffrey". This program can be written using horizontal notation:

```eo +alias org.eolang.io.stdout +alias org.eolang.txt.sprintf

Also says hello to Jeff.

[] > app stdout (sprintf "Hello, %s!" (* "Jeffrey")) > @ ```

The special attribute @ denotes an object that is being decorated. In this example, the object app decorates the copy of the object stdout and through this starts to behave like the object stdout: all attributes of stdout become the attributes of the app. The object app may have its own attributes. For example, it's possible to define a new abstract object inside app and use it to build the output string:

```eo

Says hello to Jeff.

[] > app QQ.io.stdout (msg "Jeffrey") > @ [name] > msg QQ.txt.sprintf "Hello, %s!" (* name) > @ ```

Now, the object app has two "bound" attributes: @ and msg. The attribute msg has an abstract object attached to it, with a single "free" attribute name.

This is how you iterate:

eo [args] > app malloc.for > @ 0 [x] >> seq * > @ x.put 2 while x.as-number.lt 6 > [i] >> [i] >> seq * > @ QQ.io.stdout QQ.txt.sprintf *1 "%d x %1$d = %d\n" x x.as-number.times x x.put x.as-number.plus 1 true

This code will print this:

text 2 x 2 = 4 3 x 3 = 9 4 x 4 = 16 5 x 5 = 25

Got the idea?

Backus-Naur Form

This is our EBNF of EO language:

The PNG image was auto-generated. It's better to use ebnf/Eo.svg.

What's Next?

Join our Telegram group.

Watch video about EOLANG basics.

Read our blog, especially the section with recently published papers.

Learn XMIR, a dialect of XML, which we use to represent EO program: XSD and spec.

See the full collection of canonical objects: objectionary.

Read more about integration with Maven.

Benchmark

This is how many milliseconds were spent on different XSL stylesheets during the execution of mvn install of the eo-runtime module:

text to-java.xsl 78929 41.08% classes.xsl 60946 31.72% set-locators.xsl 14251 7.42% set-original-names.xsl 9729 5.06% attrs.xsl 7444 3.87% data.xsl 6765 3.52% package.xsl 4721 2.46% anonymous-to-nested.xsl 4702 2.45% tests.xsl 4639 2.41%

The results were calculated in this GHA job on 2025-08-21 at 17:15, on Linux with 4 CPUs. The total is 192126 milliseconds. We show only the first 16 most expensive XSL stylesheets.

You can run this benchmark locally with the following commands. First, to generate the measures.csv file:

shell mvn clean install --errors --batch-mode -Deo.xslMeasuresFile=measures.csv

Then, to generate the report:

shell awk -F ',' '{ a[$1]+=$2; s+=$2; } END { for (k in a) \ printf("%s.xsl\t%d\t%0.2f%%\n", k, a[k], 100 * a[k]/s)}' \ eo-runtime/measures.csv | sort -g -k 2 | tail -16 | column -t | head "-16"

How to Contribute

Fork repository, make changes, then send us a pull request. We will review your changes and apply them to the master branch shortly, provided they don't violate our quality standards. To avoid frustration, before sending us your pull request please run full Maven build:

bash mvn clean install -Pqulice

You will need Maven 3.3+ and Java 11+ installed. Also, if you have xcop installed, make sure it is version 0.8.0+.

Contributors

Special thanks

We are using the YourKit Java Profiler to enhance the performance of EO components: