Haxe: A Multi-target Programming Language Begun in 2005

Haxe, originally styled haXe, was initiated by French developer Nicolas Cannasse in the context of his game development work at Motion-Twin. The project manual dates its beginning to October 22, 2005. It followed Cannasse’s MTASC compiler for ActionScript 2 and drew on experience with the internal experimental language MTypes, which applied type inference to object-oriented programs.

A web application at the time might combine browser scripts, a Flash interface and server-side logic. Programmers had to switch between languages and tools while managing different execution environments and duplicated code. Haxe placed a common language in front of these technologies, with its compiler generating programs suited to each target.

References: [1] [3]

The compiler’s original change log lists a lexer, parser and type checker for alpha 1 on November 14, 2005. Alpha 2 added SWF generation on November 25, and alpha 4 added Neko generation on December 10. The first releases therefore represented an evolving language implementation, with output targets introduced in stages.

Beta 1 arrived on February 4, 2006, and beta 3 added a JavaScript generator on March 11. After release candidates, version 1.0 appeared on May 17. Its changes addressed JavaScript XML parsing, Neko networking, remoting proxies and type handling, showing how the release depended on work on both language rules and platform interfaces.

References: [2]

By 2008, Haxe could generate SWF files for Flash, JavaScript for browsers and bytecode for the Neko virtual machine. Neko supported server-side logic and command-line programs, while Flash and JavaScript served different forms of interaction on web pages.

Application rules and data processing were commonly shared. Display, input and host interfaces were connected through platform-specific code and conditional compilation. Developers organized these parts in the common language before choosing an output target.

References: [3] [2]

A minimal example illustrates the relationship. In the current manual, a Main class has a static main entry point that calls trace("Hello World"), and the source file is saved as Main.hx. For Neko, the command haxe --neko hello.n --main Main generates hello.n, which Neko then executes. The source file itself is not the finished program supplied to the virtual machine.

The same language can also produce browser programs. The manual’s JavaScript example creates a button, sets a click handler and adds it to the page. The compiler generates a .js file loaded by HTML. These two routes reflect the division of work: developers express logic, the compiler generates the required form, and the host executes it. These commands and interfaces are demonstrations from later documentation.

References: [1]

Haxe uses a static type system while allowing the compiler to infer types from context. The manual gives an empty array as an example: var x = [] initially establishes only that x is an array. After x.push("foo"), its element type becomes a string and the array has type Array<String>. Some explicit annotations can be omitted while the compiler still checks type constraints.

This approach explains why Haxe combines classes and interfaces with inference ideas from functional languages. Programs can remain concise while their data relationships satisfy type rules. A shared program structure and type information also provide a foundation for generating code for different platforms.

References: [1] [3]

The project history records that Franco Ponticelli’s PHP target shipped with Haxe 2.0 in July 2008, opening a route to PHP environments. Hugh Sanderson’s C++ target followed in July 2009; its generated output still had to pass through a C++ compiler.

These contributions took Haxe beyond its early combination of web technologies. Teams could share program logic and connect display and host interfaces for individual platforms. Multiple generators allowed a common set of language tools to take part in a wider range of projects.

References: [4] [1] [2]