Haxe

Cross platform programming language

Haxe is a high level cross platform programming language and compiler that can produce applications and source code for many different computing platforms from one code base. It is free and open source software, released under the MIT License. The compiler, written in OCaml, is released under the GNU General Public License (GPL) version 2. Haxe includes a set of features and a standard library supported across all platforms, like numeric data types, strings, arrays, maps, binary, reflection, maths, Hypertext Transfer Protocol (HTTP), file system and common file formats. Haxe also includes platform specific API's for each compiler target. Kha, OpenFL and Heaps. io are popular Haxe frameworks that enable creating multi platform content from one codebase. Haxe originated with the idea of supporting client side and server side programming in one language, and simplifying the communication logic between them. Code written in the Haxe language can be compiled into JavaScript, C++, Java, JVM, PHP, C#, Python, Lua and Node. js. Haxe can also directly compile SWF, HashLink, and NekoVM bytecode and also runs in interpreted mode. Haxe supports externs (definition files) that can contain type information of existing libraries to describe target specific interaction in a type safe manner, like C++ header files can describe the structure of existing object files. This enables to use the values defined in the files as if they were statically typed Haxe entities. Beside externs, other solutions exist to access each platform's native capabilities. Many popular IDEs and source code editors have support available for Haxe development. No particular development environment or tool set is officially recommended by the Haxe Foundation, although VS Code, IntelliJ IDEA and HaxeDevelop have the most support for Haxe development. The core functionalities of syntax highlighting, code completion, refactoring, debugging, etc. are available to various degrees.

Development of Haxe began in October 2005. The first alpha version was released on November 14, 2005. Haxe 1.0 was released in April 2006, with support for Adobe Flash, JavaScript, and NekoVM programs. Support for PHP was added in 2008, and C++ was added in 2009. More platforms such as C# and Java were added with a compiler overhaul in 2012. Haxe was developed by Nicolas Cannasse and other contributors, and was originally named haXe because it was short, simple, and "has an X inside", which the author asserts humorously is needed to make any new technology a success. Haxe is the successor to the open source ActionScript 2 compiler MTASC, also built by Nicolas Cannasse and is released under the GNU General Public License version 2 or later.

The Haxe language can compile into bytecode that can be executed directly by the virtual machines it targets. It can compile to source code in C++, JavaScript, PHP, C#, Java, Python, and Lua. Haxe also has an interpreter called eval. This same interpreter is also used compile time to run macros, which allow modification of the abstract syntax tree (AST). This strategy of compiling to multiple source code languages is inspired by the write once, run anywhere paradigm. It also allows the programmer to choose the best platform for the job. Typical Haxe programs run identically on all platforms, but developers can specify platform specific code and use conditional compilation to prevent it from compiling on other platforms. The Haxe compiler is an optimizing compiler, and uses field and function inlining, tail recursion elimination, constant folding, loop unrolling and dead code elimination (DCE) to optimize the run time performance of compiled programs. The Haxe compiler offers opt in null safety, it checks compile time for nullable values.

Haxe is a general purpose language supporting object oriented programming, generic programming, and various functional programming constructs. Features such as iterations, exceptions, and code reflection are also built in functions of the language and libraries. Unusual among programming languages, Haxe contains a type system which is both strong and dynamic. The compiler will check types implicitly using type inferencing and give compile time errors, but it also enables the programmer to bypass type checking and rely on the target platform's dynamic type handling. All of the native target APIs can be used.

Haxe has a sophisticated and flexible type system. The type kinds it offers are classes, interfaces, function method types, anonymous types, algebraic data types (called enum in Haxe), and abstract types. Parametric polymorphism is possible with classes, algebraic types and function types, giving the language support for generic programming based on type erasure. This includes support for variance in polymorphic functions, although not in type constructors. The type system is static unless annotations for dynamic typing are present, for use with targets that support them. Type checking follows nominal typing with the exception of anonymous types where structural typing is used instead. Finally, type inference is supported, allowing for variable declarations without type annotations.

The Haxe compiler is divided into one frontend and multiple backends. The frontend creates an abstract syntax tree (AST) from the source code, and performs type checking, macro expansion, and optimization on the AST. The various backends translate the processed AST into source code or generate bytecode, depending on their target. The compiler is written in OCaml. It can be run in server mode to provide code completion for integrated development environments (IDEs) and maintain a cache, to further speed compiling.