ICARUS

ICARUS is a proprietary scripting language created by Raven Software to direct the interactive drama inside its Quake III-engine games: which door opens, where the camera swings, what an NPC does when the player walks into a room. It first shipped inside Star Trek: Voyager - Elite Force in September 2000, went on to power Star Wars Jedi Knight II: Jedi Outcast, Soldier of Fortune II: Double Helix, and Star Wars Jedi Knight: Jedi Academy, and - according to the community’s DEvaheb decompiler project - made a final appearance in 2009’s X-Men Origins: Wolverine.

Most languages in this encyclopedia were designed to be languages. ICARUS was designed to be a pipeline: a way for level designers who were not programmers to choreograph characters and cameras without touching the C code of the game engine. That practical origin shaped everything about it - and, unusually for an in-house game tool of its era, the whole system eventually became free software.

History and origins

At the turn of the millennium, Raven Software was shipping story-heavy shooters on id Software’s Quake III engine, which provided no built-in scripting layer for single-player cinematics. ICARUS was Raven’s answer: an interpreter embedded in the game code, plus a toolchain for authoring scripts outside it. The first game to use it was Elite Force (2000), whose campaign leaned hard on scripted crew interactions and set-piece sequences.

The language reached the public in stages. Players never saw it directly, but when Raven released the Jedi Outcast editing tools in 2002, modders received BehavEd - a visual editor that assembles scripts from clickable command blocks - and IBIze, the command-line compiler that turns script text into the binary .ibi files the engine actually loads. The Jedi Academy SDK in 2003 added the official ICARUS scripting manual, which remains the language’s canonical documentation.

Inside Raven, the system kept evolving. A header in the released source code, dated around October 2002 and credited to Mike Crowns and Aurelio Reis, describes a rewritten “Icarus Interface”: an abstract layer designed so that any game engine could host the scripting system by implementing a defined set of callbacks. The released code carries two generations side by side - an older interpreter marked version 1.33 and the rewritten implementation marked 1.40.

Design: scripts as stage directions

An ICARUS script reads less like a program and more like stage directions. Scripts are written per-scene or per-character, compiled to .ibi files, and triggered from the game world - a level entity fires a script when the player crosses a boundary, finishes a conversation, or completes an objective.

The language is procedural and deliberately small. Its core flow-control vocabulary includes:

• affect ( "entity", ... ) { ... } - the signature construct: pushes a block of commands onto another entity’s command queue. The affected NPC or object executes them on its own, asynchronously, while the calling script continues.
• task, do, wait, dowait - named tasks provide synchronization: start a task, continue other work, and wait for its completion (dowait does both), so a cutscene can hold the camera until an actor reaches a mark.
• loop ( n ) - repeats a block, with loop ( -1 ) running forever (a patrol route, a flickering light).
• if / else and wait ( milliseconds ) for conditions and timing, flush to clear an entity’s pending commands, and run to invoke another script.
• declare / set / get / free manage variables of three types - FLOAT, VECTOR, and STRING.

The workhorse is the set command, which writes to a large table of engine-defined properties: SET_BEHAVIORSTATE switches an NPC between behavior states like BS_DEFAULT, BS_WANDER, or BS_CINEMATIC; SET_NAVGOAL sends it walking to a named map tag; other properties control animation, weapons, health, and dozens more. Map-placed ref_tags let scripts refer to coordinates symbolically, and parameters (SET_PARM1 through SET_PARM8) let one script serve many entities. A camera command set (move, pan, zoom, fade, shake) covers cinematography.

A small example in the style BehavEd generates - a guard set to patrol between a post and a doorway:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

//Generated by BehavEd

rem ( "Hangar guard patrol loop" );

affect ( "hangar_guard", /*@AFFECT_TYPE*/ FLUSH )
{
    set ( /*@SET_TYPES*/ "SET_BEHAVIORSTATE", /*@BSTATE_STRINGS*/ "BS_CINEMATIC" );

    loop ( -1 )
    {
        task ( "walk_to_door" )
        {
            set ( /*@SET_TYPES*/ "SET_NAVGOAL", "door_tag" );
        }
        dowait ( "walk_to_door" );
        wait ( 3000.000 );
    }
}

The odd-looking /*@...*/ comments are BehavEd’s machine-readable annotations - a reminder that the text form was always meant to round-trip through a visual tool.

Evolution

ICARUS changed less as a language than as an architecture. The visible syntax stayed stable across games; the significant shift was the 2002 interface rewrite, which decoupled the interpreter from any particular engine so Raven could carry the system between projects. The version constants in the released source - 1.33 for the older interpreter, 1.40 for the rewritten implementation used by Jedi Academy’s single-player code - mark that transition. After Jedi Academy (2003), no new public documentation appeared, and the language’s last known shipping appearance is X-Men Origins: Wolverine in 2009, per the DEvaheb project’s compatibility list.

The decisive event in its afterlife came from outside. When Disney shut down LucasArts in April 2013, Raven released the complete source code of Jedi Outcast and Jedi Academy - ICARUS interpreter, game code, and tools - under the GNU GPL version 2. The initial SourceForge upload was withdrawn for legal reasons, but the code survived, and the JACoders community organized OpenJK, a GPLv2 project that still maintains both engines. A proprietary studio scripting language becoming fully free software, with its interpreter readable by anyone, is a rare ending.

Current relevance

ICARUS is dormant as a language: no new versions, no evolution of the syntax, no use in new commercial games. But it is unusually alive for a dormant language. The Jedi Knight modding community - centered today on JKHub - continues to write ICARUS scripts with BehavEd and IBIze for new single-player mods and cutscenes, supported by tutorials that have been refined for over twenty years. OpenJK keeps the interpreter building and running on modern systems, and tools like DEvaheb, a decompiler that reconstructs script source from compiled .ibi files (rewritten in C# in recent years), support the archaeology of scripts whose original text was never shipped.

Why it matters

It put scripting in designers’ hands. ICARUS belongs to the generation of game-studio languages - alongside contemporaries like UnrealScript and QuakeC-derived systems - that separated what happens in the game from how the engine works, so that level designers could iterate on encounters and cinematics without recompiling C code. Its BehavEd front end, assembling scripts from visual blocks years before visual scripting became an industry standard, made that separation genuinely accessible.

Its concurrency model fit its domain. The affect block - fire-and-forget command queues pushed onto entities, coordinated by named tasks - is a simple, honest answer to the problem every cutscene system faces: many actors doing things at once, with occasional synchronization points. It gave non-programmers a workable model of asynchronous execution without ever using the word.

It became inspectable history. Because of the 2013 GPL release, ICARUS is one of the few proprietary game-scripting systems of its era whose full implementation - interpreter, task manager, block streams, compiler tools - can be read, studied, and modified today. For anyone curious how a 2000s story-driven shooter actually orchestrated its drama, the answer is no longer folklore; it is source code.