Io is small prototype-based programming language. The ideas in Io are mostly inspired by Smalltalk (all values are objects), Self, NewtonScript and Act1 (prototype-based differential inheritance, actors and futures for concurrency), LISP (code is a runtime inspectable/modifiable tree) and Lua (small, embeddable).

Here are some key features of "Io programming language":

· open source BSD license
· pure object language
· small VM (~10K lines)
· small memory footprint (between 64K-200K depending on the platform)
· reasonably fast (comparable to Python, Perl, Ruby)
· incremental garbage collector, weak links supported
· differential prototype-based object model
· strong, dynamic typing
· exceptions
· ANSI C implementation (except for use of inlines and a few lines of coroutine code)
· embeddable
· multi-state (multiple independent VMs can run in the same application)
· actor-based concurrency using coroutines/light weight threads
· 64 bit clean

The language should be small, simple, multi-platform and well suited for embedded use.

Uses

The target uses are web scripting, internet server applications and desktop application development.

It Just Works

The goal for the feel of Io is to be the Apple of programming languages. That is, things should "Just Work". For example, you shouldn't have to be a sysadmin to install it or need to set environment variables to use it. You should be able to drop the executable somewhere and it just works. An Io desktop application should not require an installer, and should work without having to be placed (or to stay) at a particular file path.

Bindings are Good

The Smalltalk/LISP/Java communities generally view any code outside the VM as "unpure" or bad. Io instead embraces the idea of using C bindings for advanced functionallity and performance sensitive features (graphics, sound, encryption, array processing, etc). It does this while maintaining multi-platform support by encouraging the use of platform independent or multi-platform C libraries (OpenGL, PortAudio, etc).

Objects are Good

When possible, bindings should provide an object oriented interface and not simply minic low-level C APIs, as Python's APIs often do. Also, concrete design is favored over the abstract - you shouldn't have to use a dozen classes to do a simple operation, as Java's APIs often require you to do.

IDE

Eventually, I'd like to see Io have an interactive visual programming environment for Io. Something similar to Self, but with visually structured editing down to the method source code level.

Compiling

Running "make" in the IoVM source directory will compile the Io VM executable ("io") and library ("libIoVM.a"). It's ANSI C, so it should compile on most any platform though Coroutines are only supported on certain platforms. Io is known to compile and support coroutines on:
OSX on PPC
Linux on x86, AMD Opteron, and ARM
BSD on x86 and Alpha
Irix
Win32 on x86 (using Cygwin, Mingw or Visual C)
Symbian

Running make in the directory above it will compile the complete distribution with addons.

Installing

Io doesn't need to be put in a particular directory or to have any environment variables set.

Running

In any of the main folders (IoVM, IoServer and IoDesktop), running:

make test

will run a set of tests to make sure it is working.

There are some example scripts in the _tests/examples/ directory. You can run them from the command line like this:

./io _tests/examples/HelloWorld.io
./io _tests/examples/Account.io
./io _tests/examples/Conditions.io
./io _tests/examples/Foreach.io

Command line arguments after the file name are put into a List object and stored in the Lobby's "args" slot. Here's an example of one way to print them out:

Lobby args foreach(k, v, write("'", v, "'n"))

There is no main() function or object that gets executed first in Io. Scripts are executed when compiled.

Also, the Lobby slot "launchPath" is set to the location on the initial source file that is executed.

Command Line Interface

Running:

./io

with no arguments will open the Io interpreter prompt. You can evaluate code by entering it directly. Example:

Io> "Hello world!" print
Hello world!

Statements are evaluated in the context of the Lobby:

Io> print
[printout of lobby contents]

What's New in This Release:

· A new isLaunchScript predicate was added to test if the current file is the launch file.
· A new Cairo addon was provided along with a newly redesigned Regex addon and new NetworkAdapter addon.
· REPL now uses the new ReadLine addon for CLI history.