With ioL

ioL is the interface language in the Proxima computing system.

Just as HTML is the markup language used to express rich content on the web, ioL can be thought of as a 'markup language' for computing in general.

ioL = input / output Language

The requirements for a desktop app are very different from a website, and therefore ioL doesn't work the way HTML does.

While a website normally loads content a page at a time, an interactive application may exchange pieces of input and output with the user on a continuous basis. It also needs to manipulate or replace content that might have already been placed on the screen. While web content is usually transmitted via the HTTP protocol, a simple software app shouldn't require the overhead of a complex network protocol just to interact with the user.

i/o is everything

Fundamentally, all software is built on the premise of receiving input and producing output.

All major operating systems include an ancient mechanism (called 'standard i/o') to allow software to output text and request keyboard input through a terminal. However, moving to displaying rich content or a graphical user interface has traditionally required a totally different approach, the use of additional software libraries and very different program execution logic, making GUI apps an order of magnitude more complicated to write, debug and distribute than old-school text-based software.

ioL allows a program's text output to be augmented with rich content and interactive interface elements, without the traditional need for additional software libraries.

When a program runs, Proxima's VUI system looks for markup instructions in the program's output, which indicate when the program requires something other than simple text output.


For programmers, the advantages over traditional GUI software development approaches are numerous:

A very simple example

By tradition, the simplest example used to demonstrate any software development environment is an app that simply produces the text, 'Hello World!' and then quits.

ioL doesn't dictate what programming language a program should be written in; only for how the output should be written, to allow it to be presented correctly to the user. Let's use Python for the sake of this example.

Here's the code for our extremely simple 'Hello World' app:

print('Hello World!</n>')
print('<button {Close} onClick=putLn>')

It outputs some text on the screen, then adds a button to the output (on a new line) that the user can click in order to close the app.

(Compare that to the total number of lines code for the same kind of app in a traditional GUI framework.)

Hello World!

Here, we've given our button a very simple function. When clicked, the button sends a blank line of input back to our program, which the program waits for in order to know when it's time to quit. (If this were a terminal program, the program might ask the user to press Enter to quit, which also sends a blank line back to the program)

Don't let the simplicity of that example fool you.

ioL can be used to create software of varying complexity, from the simplest app to a complete desktop environment.

As you add more features to your program, you'll find that your code grows gradually, not exponentially like with traditional GUI frameworks.

In fact, much of the Proxima desktop environment is crafted from ioL output markup. Without it, Proxima would require a much larger development team.

More than markup

Inspired by functional programming paradigms, ioL incorporates language features you'd find in many complete programming languages, like variables, arrays, even pointers.

All designed to help you express rich user interfaces as concisely as possile.

Let's dive in