sota.io
2026-03-31·8 min read·sota.io team

Deploy Haxe to Europe — EU Hosting for Haxe Web Backends in 2026

Most languages make you choose a target. You write Python, you run on CPython. You write Rust, you compile to native binaries. You write TypeScript, you target Node.js or Deno. The language and the runtime are tightly coupled.

Haxe breaks this assumption. It is a single, strictly-typed language that compiles to ten distinct targets: JavaScript, Python, C++, C#, Java, PHP, Lua, Flash (historically), HashLink (a dedicated VM), and JVM. You write Haxe once, and the compiler produces idiomatic code for whichever platform you're targeting — not a lowest-common-denominator transpilation, but code that a native developer of each target would recognise as well-structured.

This idea did not come from a well-funded Silicon Valley startup or a university research group. It came from Nicolas Cannasse 🇫🇷, a French independent game developer and one of the founders of Motion Twin, a worker-owned cooperative in Bordeaux, France. Cannasse built the original version of Haxe in 2005 while working on games that needed to ship on Flash, JavaScript, and native desktop simultaneously — back when managing cross-platform code was mostly a matter of writing it multiple times and keeping everything in sync manually. Haxe was the tool he built to stop doing that.

This guide shows how to deploy Haxe web backends — targeting HashLink/C or the JavaScript runtime — to European infrastructure with sota.io, with EU data residency by default.

The European Roots of Haxe

Haxe's story is grounded in the French independent game development scene and the European open-source community.

Nicolas Cannasse 🇫🇷 (Motion Twin, Bordeaux) — creator and principal designer of Haxe. Cannasse is a co-founder of Motion Twin, a worker cooperative (SCOP) based in Bordeaux, Nouvelle-Aquitaine. The studio is best known for Dead Cells (2018), a rogue-lite action platformer that has sold over 5 million copies and was built substantially with Haxe and the Heaps engine — a game engine Cannasse also wrote in Haxe. The lineage from "I need to ship cross-platform games" to "I will build a cross-platform language" to "that language powers one of the best-selling indie games in history" is unusually clean. Cannasse created Haxe not as a research project but as infrastructure to solve a real problem in a real company.

Motion Twin 🇫🇷 (Bordeaux, SCOP) — the studio co-founded by Cannasse, structured as a worker cooperative where all employees share ownership equally. Motion Twin has been in operation since 2001, making it one of the longer-lived indie studios in Europe. The decision to build core tooling in-house rather than depend on commercial engines is typical of the studio's culture of technical autonomy. Dead Cells was the public proof that Haxe could ship commercial, performance-intensive products.

Haxe Foundation 🇫🇷 — the non-profit organisation responsible for maintaining the Haxe compiler and ecosystem. The Foundation is based in France and coordinates the open-source development of the language. Cannasse remains involved in the direction of the language while also continuing to develop the Heaps game engine and HashLink VM.

HashLink — the bytecode VM Cannasse designed for Haxe, with a C target for AOT compilation. HashLink provides garbage collection, JIT compilation, and a clean C FFI. When you compile Haxe to HashLink/C for a backend service, you get a native binary that runs without a JVM or Node.js runtime, with performance characteristics closer to Go or Rust than to interpreted languages. HashLink is used in production by several Haxe game studios for hot reloading during development and fast startup in production.

European Haxe Community — Haxe has a disproportionately strong following in Europe, particularly in the game development and creative coding communities. The Haxe Summit conference has historically been held in European cities. HaxeFlixel (the open-source game framework) and Heaps have active European contributors. For EU organisations that value supply chain independence — the compiler is developed under French open-source governance, not inside a US tech company — Haxe is structurally different from most mainstream alternatives.

What Makes Haxe Different

Haxe occupies a unique position in the language landscape. It is simultaneously a general-purpose language, a cross-compilation tool, and a framework for defining your own DSLs.

Multi-target compilation with idiomatic output. When Haxe compiles to JavaScript, it generates clean JavaScript — not obfuscated or wrapped output. When it compiles to Python, it generates Python you can read and debug. This means you can inspect, debug, and profile Haxe-generated code in each target's native tools. You are not locked into a Haxe-specific debugger.

Strict static typing with inference. Haxe's type system is ML-influenced: algebraic data types, parametric polymorphism, structural subtyping via interfaces. The type inference engine eliminates most annotation boilerplate. You get the safety of a statically-typed language with the ergonomics of a dynamic one in practice.

Macros. Haxe has a compile-time macro system that operates on the AST. Macros can inspect types, generate code, and build DSLs — similar in power to Rust proc-macros or Common Lisp macros, but integrated into a language with a clean, modern syntax. Several Haxe frameworks (including the tink family) are built entirely around macros.

The abstract type system. Haxe has a concept called abstract types — wrapper types that add behaviour at the type level but compile to their underlying representation, with zero runtime overhead. This is how you get type-safe wrappers for primitive values (like a UserId type backed by Int) with no cost.

// Zero-cost type-safe wrapper
abstract UserId(Int) {
  public inline function new(id: Int) this = id;
  public inline function toInt(): Int return this;
}

abstract Email(String) {
  public inline function new(s: String) this = s;
  @:from static function fromString(s: String): Email return new Email(s);
  public inline function toString(): String return this;
}

// These are distinct types at compile time, both Int/String at runtime
var user = new UserId(42);
var email: Email = "user@example.com";  // auto-cast via @:from

Building an HTTP Backend in Haxe

For web backends, Haxe targeting HashLink/C provides the best production characteristics: native binary, fast startup, no runtime dependency. The tink_web library provides a type-safe routing and request handling DSL.

Here is a complete backend service using Haxe with haxe-http targeting HashLink:

// src/Main.hx
import sys.net.Host;
import sys.net.Socket;
import haxe.Json;
import sys.db.Connection;

class Main {
  static var db: Connection;

  static function main() {
    // Connect to PostgreSQL via environment variables
    db = sys.db.Mysql.connect({
      host: Sys.getEnv("DB_HOST") ?? "localhost",
      user: Sys.getEnv("DB_USER") ?? "postgres",
      pass: Sys.getEnv("DB_PASS") ?? "",
      database: Sys.getEnv("DB_NAME") ?? "app",
      port: 5432
    });

    var server = new sys.net.TcpServer();
    server.bind(new Host("0.0.0.0"), 8080);
    server.listen(10);
    trace("Haxe backend listening on :8080");

    while (true) {
      var client = server.accept();
      handleRequest(client);
    }
  }

  static function handleRequest(client: Socket) {
    var input = client.input;
    var requestLine = input.readLine();
    var parts = requestLine.split(" ");
    var method = parts[0];
    var path = parts.length > 1 ? parts[1] : "/";

    // Read headers (skip for brevity)
    while (input.readLine() != "") {}

    var response = route(method, path);

    client.output.writeString(
      "HTTP/1.1 200 OK\r\n" +
      "Content-Type: application/json\r\n" +
      "Content-Length: " + response.length + "\r\n" +
      "Connection: close\r\n\r\n" +
      response
    );
    client.close();
  }

  static function route(method: String, path: String): String {
    return switch [method, path] {
      case ["GET", "/health"]:
        Json.stringify({status: "ok", runtime: "haxe-hashlink"});
      case ["GET", "/api/items"]:
        getItems();
      case _:
        Json.stringify({error: "not found"});
    }
  }

  static function getItems(): String {
    var rows = db.request("SELECT id, name FROM items ORDER BY id LIMIT 50");
    var items = [];
    for (row in rows) {
      items.push({id: row.id, name: row.name});
    }
    return Json.stringify(items);
  }
}

For a more modern approach using the tink_web routing DSL:

// src/Api.hx — tink_web REST API definition
import tink.web.routing.*;
import tink.web.proxy.Remote;
import haxe.Json;

@:router
class Api {
  // Type-safe route definitions — the path and HTTP method are inferred from the type signature
  @:get public function health(): tink.core.Promise<{status: String}> {
    return Promise.resolve({status: "ok"});
  }

  @:get('/api/items') public function getItems(): tink.core.Promise<Array<Item>> {
    // tink_web generates the routing glue at compile time via macros
    return database.fetchItems();
  }

  @:post('/api/items') public function createItem(body: {name: String}): tink.core.Promise<Item> {
    return database.insertItem(body.name);
  }
}

The @:router macro analyses the method signatures at compile time and generates routing code — no runtime reflection, no string-based dispatch, and the route table is checkable at compile time. If you rename a method, the routes update automatically.

Multi-target Strategy for Haxe Backends

One of Haxe's practical advantages for backend development is the ability to switch compilation targets based on your deployment constraints:

HashLink/C target — for production backends where startup time and memory footprint matter. HashLink compiles to C and then to native binaries. No JVM startup overhead, no Node.js runtime required. A Haxe/HashLink binary behaves like a Go or Rust binary: a single file, fast startup, predictable memory.

JavaScript/Node.js target — for teams already running Node.js infrastructure or who want to share code between frontend and backend. Haxe compiles to idiomatic JavaScript, works with npm packages via externs (typed FFI bindings), and produces code that Node.js profilers handle normally.

Python target — for data pipelines or ML serving where you want Haxe's type safety on top of the Python ecosystem. Haxe/Python output can import arbitrary Python libraries. This is unusual — a statically-typed frontend language targeting the Python runtime — but it works cleanly and can be valuable for teams with mixed Python/typed codebases.

For EU backends on sota.io, HashLink/C is the recommended target: smallest Docker image, fastest startup, lowest runtime dependency footprint.

Dockerfile for Haxe (HashLink/C Target)

# Build stage — compile Haxe to HashLink/C, then to native binary
FROM haxe:4.3.4 AS builder

WORKDIR /app

# Install haxelib dependencies
COPY haxelib.json ./
RUN haxelib install all --quiet

# Copy source and compile
COPY src/ ./src/
COPY build.hxml ./

# Compile to HashLink bytecode (fast iteration) or HL/C (production)
RUN haxe build.hxml

# For HL/C: additionally compile C to native binary
FROM debian:bookworm-slim AS native-build
RUN apt-get update && apt-get install -y gcc libpthread-stubs0-dev && rm -rf /var/lib/apt/lists/*
COPY --from=builder /app/out /build
RUN gcc -O2 -o /build/app /build/*.c -lpthread -lm

# Runtime stage — minimal image
FROM debian:bookworm-slim

RUN apt-get update && apt-get install -y libssl3 ca-certificates && rm -rf /var/lib/apt/lists/*

COPY --from=native-build /build/app /usr/local/bin/app

EXPOSE 8080
CMD ["app"]

For the HashLink VM target (faster builds, slightly larger image):

FROM haxe:4.3.4 AS builder
WORKDIR /app
COPY haxelib.json ./
RUN haxelib install all --quiet
COPY src/ ./src/
COPY build.hxml ./
RUN haxe build.hxml

FROM hashlink:latest
COPY --from=builder /app/out/app.hl /app/
EXPOSE 8080
CMD ["hl", "/app/app.hl"]

sota.yaml Configuration

# sota.yaml
name: haxe-api
runtime: docker
region: eu-central-1  # Frankfurt, Germany

build:
  dockerfile: Dockerfile

deploy:
  port: 8080
  health_check: /health
  min_instances: 1
  max_instances: 10

env:
  - DB_HOST
  - DB_USER
  - DB_PASS
  - DB_NAME

resources:
  memory: 256mb  # HashLink/C binaries are very lean
  cpu: 0.5

Deploying to sota.io

# Install sota CLI
curl -fsSL https://sota.io/install.sh | sh

# Authenticate
sota login

# Deploy — builds Docker image, pushes to EU registry, deploys to Frankfurt
sota deploy

# Verify health check
curl https://your-app.sota.io/health
# {"status":"ok","runtime":"haxe-hashlink"}

# Attach managed PostgreSQL
sota db create --name haxe-db --region eu-central-1
sota db attach haxe-db

Your Haxe backend is now running in Frankfurt. All data stays in the EU. The GDPR data residency requirement is satisfied without any additional configuration.

Why EU Teams Choose Haxe

Game industry backend parity. For studios and publishers running games on European servers — which under GDPR includes any game that stores EU user data — Haxe's cross-platform backend tooling maps cleanly to multi-platform client builds. A studio that uses Haxe + Heaps for a game client can use the same codebase for leaderboard, matchmaking, and telemetry backends. Shared types, shared validation logic, one language.

Gradual migration from PHP. Haxe compiles to PHP, which means a team with a legacy PHP backend can migrate service-by-service: compile new services to HashLink/C for performance-critical paths, compile glue code to PHP to interface with existing infrastructure. The migration is incremental and the types stay consistent across both targets.

Type safety across full-stack TypeScript projects. When compiling to JavaScript, Haxe interoperates with TypeScript via generated .d.ts definitions. Teams that want stronger type guarantees than TypeScript provides — particularly around null safety and exhaustive pattern matching — can adopt Haxe on the backend while sharing types with the TypeScript frontend.

EU open-source governance. The Haxe Foundation is a French non-profit. The Haxe compiler is not a Google project, a Microsoft project, or an Amazon project. For EU procurement teams evaluating software supply chain risk — particularly public sector and financial services — this matters. The entire Haxe toolchain can be audited, forked, and self-hosted within EU jurisdiction without dependency on US-headquartered infrastructure.

Motion Twin production proof. Dead Cells is a peer-reviewed benchmark for Haxe in production. When a game ships 5 million copies with Haxe as the core technology, the question "is Haxe ready for production?" has a concrete answer. For a European-origin language with a European open-source governance model, this production pedigree is worth noting.

Haxe was created by Nicolas Cannasse at Motion Twin in Bordeaux, France. The Haxe Foundation is a French non-profit. This deployment guide covers Haxe 4.3.x targeting HashLink/C on sota.io's EU infrastructure (Frankfurt, Germany). sota.io is GDPR-compliant by default — no data transfer agreements required.

Start deploying Haxe to Europe →