hxcpp VS hammerfest

I used it on conjunction with OpenFL a few months ago to port a Flash project. My impression is Haxe itself is a pretty solid as a language but I could only get the web-based target to work consistently. The C++ backend seems dead based on the repo activity[1] and I got GC-related crashes with no workaround. I could never get the native Android support working either since it crashed on startup.

Also OpenFL was missing some Flash features the project relied on and I had to spend a lot of time on a fork of their repos patching them in.

[1] https://github.com/HaxeFoundation/hxcpp/graphs/contributors

There's lots of features but very little documentation, so you learn features by reading tests and source code. OK for advanced devs, not great for most however

Since I've got current pet hobby regarding static compiles (Zig is good friend at this point, the cached static cross-platform output C compiles via musl is crazy good!) I has to look up if Haxe supports this, turns out yes* when targeting C++.

*https://github.com/HaxeFoundation/hxcpp/issues/729

I'm using Haxe actively today to preserve the very reason why Haxe exists.

Haxe was created by Nicolas Cannasse, also known as warp. He was a software developer at french game studio Motion-Twin in the 2000's. At the time they were producing web games using PHP and Flash. This required some shared logic both in the client and server; which caused some duplication. As any engineer in his situation, he decided to solve this with his own compiler. :D

One of the earliest languages he created was Motion Script, a an AS inspired language compiling to the AVM1 bytecode (SWF). You can see some examples in their 2006 game Hammerfest [0]. Haxe is a successor language with the promise of being compatible with many platforms. It's pretty remarkable in this way as one of the first languages offering expansive target of multiple _platforms_. Not just CPU architectures or OSes, or languages with a dedicated VM. Haxe was pretty successful, and and all Motion-Twin games since around 2008 used this language. It's used even today with their latest releases such as Dead Cells. Warp left Motion-Twin to create his own studio Shiro Games and is also obviously still using his language: Evoland, Northguard, Dune spice wars all use it.

From my side, I'm working on Eternaltwin [1], a project to preserve Motion-Twin's web games. Games that were more reliant on the server side were migrated to regular JS; but client heavy games such as Hammerfest, AlphaBounce, their Kadokado games, Fever, etc. use Haxe.

We use Haxe as a way to migrate off Flash. In particular, we had many user-made content using Flash. In the last five years, we migrated almost all of it to Haxe while still compiling to Flash 8; and we are now preparing to target HTML5 - but it requires removing all the Flash specific-bits. Doing it in two steps allows to perform the migration incrementally. It also requires use to move to more recent versions of Haxe. Due to the specifics of our project, we're stuck using Haxe 3.1 (to target Flash 8), we even sent a few bugfixes to this old version to ensure it keeps compiling today...

Regarding Haxe itself, I'd say that it's a very impressive language and probably a very solid choice if you are creating a video game and need to target multiple targets. It's good for final applications. However, I feel that it falls short as a language for libraries. It felt very well suited for me to implement schema validation and client libraries. Write them once in Haxe and export for Node, the JVM, Python, PHP, etc. in one go. To support all those targets, it needs to bring its own compat layer that makes it less ergonomic to use Haxe libs from target-native code. It also requires a lot of macros; which tend to be less well supported by editors. Regarding tooling, their package manager improved a lot I feel and now supports project-local dependencies with lock files and they have a nice builtin doc generator.

Regarding integration, there are still some slight oddities; like _requiring_ an env variable to find the standard lib.

To sum it up; it's a pretty nice language, but I feel like it's also showing its age (it still feels very attached to older OOP styles found in Java or AS3).

[0]: https://github.com/motion-twin/hammerfest/blob/master/class/...