haxeui-core VS hammerfest

The creator of http://haxeui.org/ makes a lot of (closed) projects for the health sector.

Haxe Lang has some really nice UI frameworks including HaxeUI[1] and CoconutUI[2] which can both compile for the web using the javascript target. You get AOT type checking + compile-time macros. Haxe, I think, had the poor luck of coming about in the same general time as TypeScript which had a mega corporation propelling its hype and adoption.

[1]: https://github.com/haxeui/haxeui-core

[2]: https://github.com/MVCoconut/coconut.ui

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/...