Io (language)
Io is a small, dynamic, prototype-based programming language in which everything is an object and all computation happens by sending messages between objects, drawing inspiration from Self, Smalltalk, Lua, and NewtonScript.
Definition
Io is a small, dynamic, prototype-based programming language in which everything is an object and all computation happens by sending messages between objects, drawing inspiration from Self, Smalltalk, Lua, and NewtonScript.
Overview
Io was created by Steve Dekorte starting in 2002 as an exploration of extreme conceptual minimalism combined with prototype-based object orientation: the entire language is built from just a handful of core concepts — objects, messages, and slots (named references an object holds to other objects, including methods) — with no separate syntactic categories for classes, control structures, or literals beyond what those primitives can express. Like Self, Io has no classes; new objects are created by cloning existing prototype objects, and behavior is shared through delegation to one or more 'protos' rather than class-based inheritance. Even Io's control flow is implemented via ordinary message sends rather than special-cased syntax — constructs that look like keywords in other languages (if, while, for) are simply messages sent to objects, resolved and potentially overridden using the same mechanism as any other method call, which makes Io highly homoiconic and reflective: programs can inspect and modify their own structure, including redefining what look like core language constructs, at runtime. Concurrency in Io is provided through lightweight coroutines called 'vms/coros' and an actor-like model where every object can optionally run asynchronously, with futures used to retrieve results once an asynchronous computation completes. Io's minimalist core is written in portable ANSI C, making it straightforward to embed in other applications, and it ships with a small but capable standard library. Because nearly everything in Io is uniform, dynamic, and message-based, it has been used mainly as a teaching and research language for exploring prototype-based and highly reflective object systems, and by programming-language enthusiasts drawn to languages (alongside Self and early Smalltalk) that push message-passing purity further than mainstream class-based OOP languages. It has not seen significant production or commercial adoption, remaining a niche language primarily of academic and hobbyist interest.
Key Features
- Prototype-based object model — no classes; objects are created by cloning prototypes
- Entire language built from a minimal core: objects, messages, and slots
- Control-flow constructs (if, while, for) are implemented as ordinary message sends, not special syntax
- Highly homoiconic and reflective — programs can inspect and rewrite their own structure at runtime
- Lightweight coroutines ('vms/coros') and an actor-like model for concurrency, with futures for results
- Small, portable ANSI C implementation suitable for embedding
- Draws inspiration from Self, Smalltalk, Lua, NewtonScript, and Act1