Arturo

Arturo is a modern, independently developed programming language created by Yanis Zafiropoulos. Distinguished by its complete absence of reserved keywords, homoiconic design, and right-to-left evaluation model, Arturo draws inspiration from Rebol, Forth, Lisp, and Ruby to create a language where code is simply a sequence of words, symbols, and values interpreted according to context. Executed on a stack-based bytecode virtual machine, Arturo aims to be expressive, portable, and batteries-included.

History & Origins

Arturo’s story begins in 2019, when Yanis Zafiropoulos (known online as “Dr.Kameleon”), a Greek-born developer based in Granada, Spain, released the first version on GitHub. The language’s name is a tribute to Zafiropoulos’s pet Emperor Scorpion, Arturo, who passed away in early 2020.

The D Implementation

The earliest releases (v0.3.1 through v0.3.9, September-October 2019) were implemented in the D programming language. These versions were listed on DUB, D’s package registry, and described Arturo as a “simple, modern and powerful interpreted programming language for super-fast scripting.” The D implementation required Flex and Bison for parsing alongside a D compiler.

Rewrite in Nim

Between late 2019 and 2020, Zafiropoulos rewrote Arturo in Nim, fundamentally changing its architecture to a bytecode-compiled, stack-based virtual machine. By October 2020, when Arturo appeared on Hacker News as a “Show HN” post describing it as a “REBOL-inspired programming language and VM written in Nim,” the transition was complete. The Nim implementation remains the foundation of Arturo today.

Naming and Identity

The scorpion connection runs deeper than just the language’s name. Release v0.10.0, the most recent major version, carries the codename “Arizona Bark” after the Arizona bark scorpion, continuing the thematic thread established by the language’s namesake.

Design Philosophy

Arturo’s design philosophy centers on several distinctive principles that set it apart from most contemporary languages.

No Reserved Keywords

Perhaps Arturo’s most striking design choice is the complete absence of reserved words. There are no if, for, while, or return keywords baked into the language grammar. Instead, all control flow and operations are handled by built-in functions that can be redefined, aliased, or replaced:

; Control flow uses regular functions, not keywords
if 2 > 1 [
    print "Two is greater than one"
]

; Loops are also just functions
loop 1..5 'x [
    print x
]

Right-to-Left Evaluation

Arturo evaluates expressions strictly from right to left, eliminating the need for operator precedence rules:

; Right-to-left: 3 + 4 = 7, then 2 * 7 = 14
print 2 * 3 + 4    ; outputs: 14

This consistent evaluation order means programmers never need to memorize precedence tables or worry about ambiguous expressions.

Homoiconicity

Like Lisp, Arturo is homoiconic – code and data share the same representation. Blocks (delimited by square brackets) are unevaluated data structures that can be manipulated as data or executed as code:

; A block is just data
code: [print "Hello"]

; But it can be executed
do code    ; outputs: Hello

This property enables powerful metaprogramming, domain-specific languages, and runtime code generation.

Labels for Assignment

Variable assignment uses a label syntax with trailing colons rather than an equals sign:

name: "Arturo"
age: 5
numbers: [1 2 3 4 5]

Key Features

Rich Type System

Arturo includes over 40 built-in value types, including integers with arbitrary precision, rational numbers, complex numbers, and a distinctive ternary logic system with true, false, and maybe values. It also provides built-in support for quantities with physical units, colors, dates, version numbers, and regular expressions.

Batteries-Included Standard Library

The standard library is extensive for a language of Arturo’s size, including built-in support for:

• Web servers and HTTP clients
• Database connectivity (SQLite)
• Cryptographic functions
• HTML templating
• Regular expressions (PCRE-compliant)
• JSON, XML, and YAML processing
• Network socket programming

Attributes for Optional Parameters

Functions in Arturo accept optional named parameters through a distinctive attribute syntax using dots:

; Split a string by words
split.words "hello world"

; Split with a specific separator, every N characters
split.every: 2 "abcdef"

This approach keeps function signatures clean while allowing flexible parameterization.

Standalone Executables

Arturo can bundle scripts into standalone executables, making distribution straightforward without requiring end users to install the Arturo runtime.

Implementation

The current Arturo implementation is written primarily in Nim (approximately 49% of the codebase), with C (approximately 30%) and C++ (approximately 20%) components. The source code is parsed into an abstract structure of words and symbols, compiled to bytecode, and then executed on a stack-based virtual machine.

The language supports multiple platforms including Linux, macOS, Windows, and FreeBSD. Installation is available through Homebrew on macOS, a Unix/Mac installer script, Docker images, and building from source.

Evolution

Early Development (2019)

The initial D-based implementation went through rapid iteration, with nine releases in under a month (v0.3.1 through v0.3.9 between September 27 and October 19, 2019). This rapid pace demonstrated the creator’s vision and energy for the project.

The Nim Era (2020-Present)

The rewrite in Nim brought a proper bytecode virtual machine, improved performance, and a more sustainable foundation for long-term development. The project accumulated over 36,000 commits through years of steady development, primarily driven by Zafiropoulos with contributions from a growing community of over 20 contributors.

v0.10.0 “Arizona Bark” (January 2026)

The most significant recent release introduced a revamped object-oriented programming system, a new module type, structured error handling with dedicated error types, and was built on Nim 2.2.6. Fourteen contributors participated in this release, reflecting the growing community around the language.

Community and Ecosystem

Despite being primarily “a one-person project” as the creator has described it, Arturo has built a modest but engaged community:

• GitHub: Approximately 836 stars and 21+ contributors
• Exercism: An official Arturo track with 72 exercises provides structured learning
• Rosetta Code: Over 800 programming tasks implemented, representing substantial coverage
• Packager (pkgr.art): The official package registry hosts community-contributed libraries
• Community channels: Discord serves as the primary community hub
• Funding: Supported through GitHub Sponsors and Open Collective donations

Notable ecosystem projects include Grafito (a graph database built on SQLite), Aguila (a cross-platform desktop app framework), and various packages for unit testing, benchmarking, and string processing.

Current Relevance

Arturo occupies an interesting niche in the programming language landscape. It is not competing to be a mainstream production language, but rather represents a thoughtful exploration of language design ideas – particularly around keyword-free syntax, homoiconicity, and right-to-left evaluation.

The language remains in active pre-1.0 development, with frequent releases and a creator who is deeply invested in its continued evolution. Its presence on platforms like Exercism and Rosetta Code provides accessible entry points for curious developers.

Why It Matters

Arturo matters as an example of what individual language designers can achieve and as a living experiment in alternative approaches to programming language syntax and semantics. Its Rebol-influenced, keyword-free design challenges assumptions about what a programming language needs to look like, while its homoiconic nature and right-to-left evaluation offer genuinely different ways of thinking about code.

For developers interested in language design, concatenative and functional programming, or the Rebol family of languages, Arturo provides a modern, actively maintained, and approachable entry point. Its combination of a rich type system, batteries-included standard library, and clean syntax makes it a compelling tool for scripting, prototyping, and exploring programming concepts beyond the mainstream.