Agena

Agena is a procedural scripting language implemented as an interpreter on top of the ANSI C source code of Lua, but wearing a completely different face: where Lua is deliberately minimal, Agena presents an ALGOL 68-flavoured surface syntax with if ... then ... fi, do ... od and esac, borrowings from the Maple computer algebra system, a handful of SQL-inspired constructs, and a standard library stuffed with real and complex arithmetic, statistics, calculus, linear algebra, arbitrary-precision numbers, interval arithmetic, fractals, curses terminal UIs, SQLite bindings and an xBase reader. It has been written and maintained by one person, Alexander Walz, for roughly twenty years, and at the time of writing it ships new releases every few days.

The name comes from Beta Centauri - Agena, one of the brightest stars in the night sky - and from the Agena, the unmanned target vehicle NASA docked with during the Gemini programme in the 1960s.

History and Origins

Agena’s origin is recorded in unusual detail in its own primer, and it is a practical rather than a theoretical one. According to that account, Walz took up Lua in 2005 to write procedures for phonetic analysis, and ANSI C in order to move those procedures into a compiled package. What began as a user of Lua turned into a modifier of it: the first changes to the Lua parser were made in autumn 2006, with extensive rework of the lexer, parser and virtual machine following in the summer of 2007. Most of the intended functionality was complete by March 2008, and the first data structure with no Lua counterpart - Cantor sets - arrived a month later.

The first public release went up on SourceForge in January 2009; the SourceForge project itself was registered on 21 January 2009. Walz introduced the language to the wider world on 26 March 2009, in a message to the Lua mailing list:

In summary, Agena is an easy-to-learn interpreted language suited for sophisticated procedural programming and your everyday needs. Its syntax looks like a very simplified Algol 68 with elements taken from Lua and SQL.

That announcement already listed binaries for Solaris, Linux, Windows, OS/2 and eComStation, and Novell DOS 7 - the pattern of unusually broad, unusually retro platform coverage that has held ever since.

A note on dating. Agena is frequently listed with a first-appearance year of 2006, which is the year work on the Lua fork began rather than the year anything was released. The first release the public could obtain was in January 2009, and that is the date used in this entry.

Design Philosophy

Agena is not a Lua dialect in the sense that Luau or Terra are. It reuses Lua’s C implementation as an engine and then diverges on almost every visible decision.

Readability over minimalism. Lua’s design ethos is to keep the language small enough to hold in your head and let libraries do the rest. Agena goes the other way: closing keywords instead of end everywhere, a case ... of ... esac statement, try/catch/yrt exception handling, extended loop constructors, compound assignment operators for arithmetic, bitwise and shift operations, and a very large built-in library. The stated audience is scientific, educational and everyday scripting use, and the language is pitched as easy to learn rather than easy to implement.

Batteries in the kernel, not in packages. Many of Agena’s data structures are built into the interpreter core rather than layered on top, which is the justification the project gives for having so many of them. The project’s own documentation states that Cantor sets consume roughly 40% less memory than ordinary tables, and has described sequences as faster than tables for appending values. These are the author’s own figures; the documentation does not publish the benchmark programs, input sizes or hardware behind them, and no independent benchmarks of Agena against comparable interpreters appear to exist. Treat them as design intent rather than measured results you can reproduce.

Mathematics as a first-class concern. Complex arithmetic is in the language, not a library - x!y constructs a complex number and exp(1+2*I) just works. Arbitrary-precision arithmetic is provided through a bundled MAPM-based package, alongside statistics, calculus, combinatorics, linear algebra and interval arithmetic. The influence of Maple is visible in both the notation and the choice of what belongs in the box.

Optional type assertions in a dynamic language. Procedure parameters, locals and return values can carry :: type assertions (and -: for “not of this type”), checked at runtime. It is closer to a contract than to a type system, but it lets library code fail early and legibly.

Key Features

Procedures use the ALGOL-descended proc ... is ... end shape, with type assertions and recursion:

factorial := proc(n :: number) :: number is
   if n < 0 then return fail
   elif n = 0 then return 1
   else return factorial(n-1) * n
   fi
end;

The Mandelbrot membership test from the project’s own sample-code page shows complex arithmetic, a combined for/while loop, and the ! complex constructor together:

mandelbrot := proc(x :: number, y :: number, iter) :: number is
   local c, z;
   if unassigned(iter) then
      iter := 128
   fi;
   z := x!y;
   c := z;
   for i from 0 to iter while abs(z) < 2 do
      z := z^2 + c
   od;
   return i
end;

Data structures go well beyond Lua’s single table type:

Strings are sliceable by range - str[3 to 6] - and the string library is large enough to be the reason some users are there at all.

Control flow includes if/elif/fi, case ... of ... esac, numeric for, for ... in, while, do ... until, and try ... catch in err then ... yrt. Procedures support full lexical scoping, lambda-style short-cut functions, and remember tables for automatic memoization of recursive calls.

The 6.x and 7.x series added a number of conveniences that give a sense of the language’s direction: chained relational operators (1 < x < 3), compound bitwise and shift assignment (&&:=, <<:=), a with clause for binding intermediate locals inside an expression, begin/end scopes, and Perl-style autovivifying tables via tables.auto().

Evolution

The most striking thing in that table is the discontinuity around mid-2023. The bundled change log covers 3.1.0 (12 July 2023) through 7.7.10 (23 July 2026) and contains approximately 336 dated releases in that span - well over a hundred a year, against a 2.x series that took nearly a decade to work through its point numbers. Whatever changed in the author’s circumstances in 2023, the project has been in a sustained sprint since.

Recent work has leaned toward correctness and memory safety rather than language surface. Releases are routinely described as Valgrind-tested on x64 Linux and Dr. Memory-tested on Windows, and the 7.7.x entries document fixes for out-of-memory handling across dozens of functions and a latent use-after-free in the hash-map garbage-collection metamethods.

Where the change log does make a performance claim, it tends to be better contextualised than most: release 7.7.10 replaced the DJB2/BKDR polynomial hash in the bundled khash library with CRC32 in the strmap, strhash and uintmap packages, reporting collisions falling from 0.05599% to 0.00637% - an 89% reduction - at a stated 10% speed penalty, measured against a reference set of 517,996 surnames. Release 7.7.8 reports that strings.ljustify and strings.rjustify became 63% faster after being rewritten in C, though without stating the input or the measurement method.

Platform Support

The project’s own download page for release 7.7.10 lists installers for:

• Windows (32-bit setup, plus portable EXE and ZIP), including AgenaEdit
• OS/2, eComStation and ArcaOS (WarpIN package)
• Linux (DEB for x86 and x64, RPM for x86), including AgenaEdit
• Mac OS X (PKG, Intel), including AgenaEdit
• Solaris 10 / OpenIndiana (x86 package), including AgenaEdit
• DOS (ZIP)
• Raspberry Pi (ARMv6 32-bit and ARMv8 64-bit)

Source is published as a tarball, along with a separate test suite. Haiku appeared in the platform list around 2010 to 2015 and no longer does. Because the platform set has moved over time - Raspberry Pi and Solaris builds were reportedly withdrawn in 2024 and later restored - check the download page for the specific release you intend to use rather than relying on any historical list, this one included.

Licensing

Per the project’s own legal page, the Agena source files are distributed under the MIT licence, while the binary distributions are under the GNU Library General Public License, version 2 or later - the latter reflecting the GPL/LGPL-licensed libraries the binaries link against. The SourceForge project lists both GPLv2 and MIT accordingly.

Current Relevance

Agena occupies an odd position: by release activity it is one of the most actively developed languages you have never heard of, and by adoption it is essentially invisible.

The activity is not in doubt. Version 7.7.10 shipped on 23 July 2026, three days before this entry was written, and the change log records hundreds of releases over the preceding three years. Documentation is thorough and versioned in lockstep with the interpreter - a primer, a reference, a crash course and a spreadsheet quick reference, all reissued at 7.7.10.

The adoption is equally clear. SourceForge reported on the order of a hundred downloads a week across all binaries at the time of writing. There is no package registry, no conference, no framework ecosystem, no distribution packaging of consequence, and the single public discussion channel is a SourceForge forum opened in 2015. The largest visible body of third-party code is roughly 149 Rosetta Code pages. The project itself reportedly withdrew some platform builds in 2024 “due to lack of public interest.”

Encyclopedic listings that mark Agena dormant are reading the adoption signal, and it is a fair signal to read - but it is wrong about the software. This is a maintained, tested, documented, currently released language.

Why It Matters

Agena is a useful specimen for two reasons.

The first is what it shows about forking an implementation rather than a language. Lua’s C sources have spawned a number of derivatives, most of which stay recognisably Lua-shaped. Agena took the engine and rebuilt the surface into something an ALGOL 68 or Maple user would recognise, then grew a standard library an order of magnitude larger than Lua’s. It is a demonstration that “based on Lua” can mean the runtime and nothing else - and that a single maintainer can carry that much divergence for two decades.

The second is what it shows about the gap between maintenance and adoption. Agena does almost everything the conventional advice says to do: it is documented, cross-platform, permissively licensed at the source level, easy to install, easy to learn, and shipped relentlessly. It still has no user community. Its closest analogue in this encyclopedia is AFNIX - another decades-long single-author project with thorough documentation and no users - and the pair together make the point more sharply than either does alone. Languages are not adopted for being good. They are adopted for arriving attached to a problem someone urgently needs solved, and neither of these ever did.

For anyone with an OS/2 machine, a DOS box, a Solaris 10 install or a first-generation Raspberry Pi, though, Agena remains one of the very few modern, actively maintained scripting languages that will still install and run - and that is not a small thing.