Haxe 3, OpenFL, Arch, Android

haxeTom and I went through and installed Haxe 3 and OpenFL on our machines today.  OpenFL is the updated Haxe 3 version of NME.  These are a few notes, updating from my Haxe 2 comments, some of which are still applicable. All in all, the process seems smoother than it was for Haxe 2/NME on Arch… I’m excited!


First install Neko out of the AUR:

sudo packer -S neko

Then Haxe 3:

sudo packer -S haxe

Note that you can do those two steps at once. If you receive an error about an incorrect Neko package version, it’s because the Haxe package doesn’t denote the version dependency. Running them separately as above will force Neko to be updated first, and then Haxe.

At this point you should setup haxelib:

haxelib setup

Tom sets the haxelib location to be in his home directory, which is most proper. I leave it in the default /usr/lib/haxe, for no good reason. In that case you need to modify the install directory to be owned by your user:

cd /usr/lib/haxe
sudo chown -R joe .


Next, install OpenFL following their instructions:

haxelib install openfl && haxelib run openfl setup

When it asks for sudo permission, it’s installing a simple script aliasing haxelib run openfl to just openfl, so you can skip it if you wish.


export HAXE_STD_PATH=/opt/haxe/std

After that you should be able to create and run a demo:

openfl create DisplayingABitmap
cd DisplayingABitmap
openfl test linux
openfl test flash



Next, try to set up OpenFL’s Android support:

openfl setup android

That script will pull down the Android NDK, SDK, Apache Ant, and Java, but if you already have all that installed simply say no to each download request and enter the path manually.  You can then try to build a sample:

openfl create DisplayingABitmap
cd DisplayingABitmap
openfl test android

If you’re using a recent 64 bit android NDK, that will fail with a root cause of not finding g++:

sh: arm-linux-androideabi-g++: command not found

To begin with, in your haxelib directory, edit build-tool/BuildTool.hx. Specifically, the Linux parameter by line 1355 in the Android block should be altered from just the value linux-x86 to the following:

m64 ? "linux-x86_64" : "linux-x86"

The block will then look like:

      else if (defines.exists("android"))
         if (!defines.exists("ANDROID_HOST"))
            if ( (new EReg("mac","i")).match(os) )
            else if ( (new EReg("window","i")).match(os) )
            else if ( (new EReg("linux","i")).match(os) )
                          m64 ? "linux-x86_64" : "linux-x86");
               throw "Unknown android host:" + os;

That last ANDROID_HOST setting is what matters; as shipped, it does not point to the 64 bit toolchain correctly.

Then in build-tool/android-toolchain.xml, edit the toolchain version to 4.6. Edit line 7 setting TOOLCHAIN_VERSION as follows:

<set name="TOOLCHAIN_VERSION" value="4.6" unless="TOOLCHAIN_VERSION" />

In build-tool/ then run:

haxe Compile.hxml

OpenFL, specifically openfl-tools, defaults to Android API 8. If you have that installed, you should then be able to build the OpenFL samples for Android. You will though need to stipulate 64 bit hxcpp:

openfl test -DHXCPP_M64 android

To change the target Android API, in your haxelib directory edit openfl-native/1,0,6/templates/android/template/build.xml and change the target property on line 7, e.g., from:

  <property name="target" value="android-::ANDROID_TARGET_SDK_VERSION::"/>


  <property name="target" value="android-16"/>

OpenFL should then build, push, and run the target on your phone using this API version, stipulating the 64 bit toolchain as above. Hooray!

Success on my S3!

Success on my S3!

Installing Haxe/NME on Arch Linux x86_64

haxeSome updated notes on Haxe 3 and OpenFL are now available.

I love Haxe and NME.  But they’re at times not the most pleasantly packaged of software.  There are some definite lapses in checking the released versions for packaging problems, the nightly snapshots often have problems, and few of the setup scripts will work if you’re not using an apt-based system (i.e., Ubuntu). Having just installed on two 64bit machines running Arch Linux, the following are some notes on getting it all to work.

Flash Player

You’ll have to install the 32bit multilib stuff in order to install the Flashplayer standalone debug player.  You definitely want this as the debug player seems to be the only way to get reports on null pointers and such in your Flash programs.

Enable the multilib repository by editing /etc/pacman.conf to uncomment:

SigLevel = PackageRequired
Include = /etc/pacman.d/mirrorlist

Then udate the repo DB and install the multilibs:

sudo pacman -Syu
sudo pacman -S gcc-multilib

Accept everything pacman asks in running that command. Then install the player.

sudo packer -S flashplayer-standalone-debug

Haxe/NME Toolchain

The Haxe/NME stack includes a number of components. You could try installing these from the NME install script, but it’s based on Ubuntu and several components won’t work even after you adjust for that. Instead you need to cherry pick some parts and replace others.  The rest of this sort of follows the script, but injects some variations and other steps.

The first thing to install is Neko. You want to do this from the AUR package, e.g.:

sudo packer -S neko

Installing from the tarball like the NME script does will result in a broken dependency with libpcre3. Manually compiling from source to fix that seems to be a rathole, and using the AUR package seems cleaner than jury-rigging a .so fix.

Next is Haxe itself. Tragically, you seemingly don’t want to pull this from the AUR package. I haven’t looked at it closely to confirm, but believe it pulls from SVN, which often leads to problems. Today on installing from that I get errors along the lines of “Missing Standard library.” (not an exact quote). Instead, download the stable release and patch up an install:

wget -c http://haxe.org/file/haxe-2.10-linux.tar.gz
tar xzvf haxe-2.10-linux.tar.gz
sudo mkdir -p /usr/lib/haxe/lib
sudo chmod -R 777 /usr/lib/haxe/lib

sudo cp -r haxe-2.10-linux/* /usr/lib/haxe
sudo ln -s /usr/lib/haxe/haxe /usr/bin/haxe
sudo ln -s /usr/lib/haxe/haxelib /usr/bin/haxelib
sudo ln -s /usr/lib/haxe/haxedoc /usr/bin/haxedoc

haxe /usr/lib/haxe/std/tools/haxelib/haxelib.hxml
sudo cp haxelib /usr/lib/haxe/haxelib

haxe /usr/lib/haxe/std/tools/haxedoc/haxedoc.hxml
sudo cp haxedoc /usr/lib/haxe/haxedoc

sudo haxelib setup /usr/lib/haxe/lib

wget -c http://www.haxenme.org/builds/hxcpp-2.10.3.zip
sudo haxelib test hxcpp-2.10.3.zip

Finally, install NME and friends.  Begin with the basic download.

sudo haxelib install nme

From here I have tremendous problems.  Nothing will actually work yet, including the rest of the setup process; I simply get errors from tls.ndll about missing libopenssl.so.0.9.8. Seemingly there is a persistent problem in the packaging of NME such that it’s not properly searching the appropriate 64/32 bit Neko libraries. At this point you’re standing on the edge of a huge rathole. Compiling NME from source seems to be fairly complex to setup outside of the assumed Ubuntu environment. Installing that version of OpenSSL doesn’t work because it’s 32 bit. After repeatedly screwing around with this at length on several major releases of NME, short of setting up NME from source I don’t think you have any option here but the ugliest:

cd /usr/lib
sudo ln -s libssl.so.1.0.0 libssl.so.0.9.8
sudo ln -s libcrypto.so.1.0.0 libcrypto.so.0.9.8
cd -

Now you can continue installing and hope you haven’t just set some lurking booby trap to slam you on some other project months down the road…

sudo haxelib run nme setup
sudo haxelib install actuate
sudo haxelib install svg
sudo haxelib install swf

At this point things should work. However, I had trouble getting some of the RocketHaxe demos to compile with NME 3.5.4. It produced inscrutable and inexplicable errors about exceptions creating the output files. Updating to 3.5.5 seemed to fix these; I have no idea what else it broke in return. You can upgrade to a nightly build by downloading a new version from the NME builds repository. Then have haxelib switch to that version, e.g.:

sudo haxelib test nme-3.5.5-165-g354e1e6.zip


Now you should be able to test everything out. Go into a random temporary directory and build a sample program:

nme create Addingtext
cd AddingText
nme build project.nmml flash
flashplayerdebugger Export/flash/bin/AddingText.swf

If that works, it works. If it doesn’t… Slaugther a chicken and call a priest or something. Please leave any comments you have about improvements to this process or other notes. Thanks!

Further notes about setting up Haxe for Android development are here.

Sponsorship of Flash Games in Haxe

haxeRecently magneticat asked on FGL about getting sponsorships for Flash games developed in Haxe. Having just gone through the process of publishing Gold Leader I’d been thinking about and dealing with those specifics quite a bit.  These are some of my thoughts (adapted from the thread).

The basic question is whether or not there’s any obstacle toward getting sponsorships when developing in Haxe.  From the sponsor’s perspective I can’t see that it would matter, provided you can integrate with their API(s) and branding.  It’s a game, it runs in Flash, users won’t know any difference, so why would the sponsor care?  Certainly Haxe probably lends itself toward some types of games and not others, but that’s no different from developing in Flex/raw AS3 rather than the Flash UI.  The latter lends itself more to very graphical, simple games that you can construct on the timeline.  The former lends itself to more programmatic, performance oriented games with a lot of reusable elements (sprites, tiles, etc.).  Haxe is no different, just higher performing and more pleasant to develop in.

From the developer’s perspective then it’s all about how possible or easy it is to incorporate sponsors’ APIs and branding assets.

Access to Adobe Flash

At the highest level, that question divides into two camps based on whether or not you have access to and/or choose to use Adobe Flash.  If you want to use Haxe but also have access to and are willing to use the Adobe UI, then you’re pretty much good to go.  You should be able to develop the game and then bring it in as an SWF or such if you really need to incorporate some elements using the actual Flash UI.

If you don’t have or aren’t willing to use Adobe Flash, the biggest concerns seem to be how rich the sponsor’s splash screen is, how they’re willing to provide it, and whether or not they have their own preloader they want you to use.  Basically, if you’re going to have to work with a .fla and you don’t have Adobe Flash, there’s essentially no workaround and you’re stuck.

Otherwise you can probably figure something out and/or integrate it all together at the end in Flash.  You could probably do this without paying, or at least not paying much, by using either the trial version or Adobe’s new cloud service to effectively rent it for just a month or whatever you need.  If you’re on Linux you should be able to do all of this in a Windows VM. Success under WINE or similar seems pretty iffy.

Integration Details

The real question then is how much you can do without access to or using Flash.

Integrating with AS3 code libraries is actually generally really straightforward.  Haxe’s whole approach to Flash makes this capability integral to the system, and there are many blog posts and other docs on it.  If the library is precompiled you can just link it in. If it’s AS3 source, you can use Adobe’s free Flex SDK tools to compile it for linking from Haxe.

There are a couple other gotchas, like a different default network security model, but they’re all easily fixed once you realize that’s what’s going on.

If the splash screen is just a movie the sponsor can provide as an SWF then you’re probably good to go.  NME has increasing cross-platform support for SWFs (read the comments for updates), though it doesn’t currently seem to support sound.  Fortunately, you can instead use the Flash API to play the SWF directly.  However, if the splash screen is some complex thing with buttons and different events that requires you work with the .fla, then you’re in big trouble if you don’t have access to the Flash tools.  Basically nothing else, even the Flex tools, will work with .fla files so you’ll realistically probably need to have access to and use Flash to hook it all up.

If the sponsor is providing their own preloader as code, you should be able to work with it somewhat like any other AS3 library, though it’s much trickier.  I wrote some AS3 preloaders for Haxe games a while back before NME’s preloader support was greatly improved, so it’s doable.  It does require a fair bit of understanding of the Flash boot process though and isn’t for the faint of heart.  It might be a lot easier now though that NME’s preloader hooks have been cleaned up.  Writing your own preloader in Haxe is really simple in the latest versions of NME.

My Experience

I personally use Linux and do not want to install a Windows VM, so I’m working without the Flash tools.  That could definitely be constraining.  Looking at some portals’ branding, you would need Flash to work with their .fla files.  Part of why I jumped on GameShed’s offer for Gold Leader was because the integration sounded straightforward (they turned out great in every way as well).

The final published Gold Leader is all in Haxe and other than whatever the artist and musician used, it was developed entirely on Linux using only free tools.  In terms of integration, it incorporates an AS3 library from Adobe for Google Analytics (my internal tracking and play instrumentation), Mochi’s AS3 libraries (MochiScore leaderboard), GameShed’s AS3 API (site achievements), and their SWF splash screen.  It definitely took some time to figure a couple of these out, but the actual code is easy so doing similar in the future will be a breeze.  GameShed provided its API as AS3 source.  Interestingly, it was essentially trivial to make a couple syntactic edits (to package, float, and for loop declarations) and compile it directly in Haxe.  That was quicker and easier to do than to compile with Flex and link against, though that also would not have been a big challenge.

rockethaxe-100x100All of the non-game-specific code from Gold Leader is open sourced and available in RocketHaxe.  The library is not super comprehensive yet, but what it does is useful and seems fairly high performance.  It also includes code showing how to incorporate Google Analytics, Flash native cursor support, and a few other platform features.  As I clean up and generalize some of the last-minute code from Gold Leader‘s final push I’ll be adding SWF player helpers, the Mochi API library, and some other bits.