Armory 3D: The Open-Source Game Engine Inside Blender, Its Haxe Core, and Its Status in 2026

Armory is a free, open-source 3D game engine that lives inside Blender. Instead of moving your scenes into a separate editor, you build levels, materials and animation in Blender, add game logic with Haxe scripts or logic nodes, and press Play to run the game. Slovak developer Lubos Lenco started it in 2015, and it’s released under the permissive zlib licence. Most of the engine is written in Haxe, running on the cross-platform Kha framework, with only its lowest layer in C and C++.

This profile covers what Armory is, how its layers fit together, a tested Haxe trait, its rendering and physics features, its releases, and whether it’s still developed in 2026. Facts were checked against the project’s repository and website in October 2026, and the example was type-checked against the current engine source.

What Is Armory 3D?

Armory is a free, open-source 3D game engine integrated into Blender, released under the zlib licence. Games are built in Blender and scripted in Haxe or with visual logic nodes, then exported to Windows, macOS, Linux, Android, iOS and the web. The engine is written mainly in Haxe on the Kha framework, and the latest SDK release is 26.02 (February 2026).

A Short History of Armory

Armory’s repository begins in October 2015 (Armory on GitHub), when Lubos Lenco began building a game engine around Blender rather than beside it. Blender had its own built-in Game Engine at the time, but it was ageing, and Blender 2.80 removed it in 2019. Armory offered a different approach: keep Blender as the editor, and export scenes to a separate, modern runtime written in Haxe.

The project was open source from the start. By 2018 it had a full feature set, from physically based materials to physics and logic nodes, and the GameFromScratch blog described it as an engine that “runs inside Blender” (GameFromScratch’s look at Armory). Since then, more than 6,000 commits have gone into the main repository, with large contributions from community developers alongside Lenco. In December 2024, most of the engine’s separate repositories were merged into one, leaving Kha as the only external module.

Armory is now distributed as the Armory SDK, a Blender add-on bundled with everything it needs, with releases named by year and month: 24.12, 25.01, 25.06, 25.09 and 26.02.

How Armory Works

Armory is a stack of layers, and you only touch the top ones:

• Blender is the editor. You model, texture and animate in Blender, build materials with Cycles shader nodes, and set up lights, cameras and physics there.
• The Armory add-on, written in Python, adds Armory panels to Blender. It exports the scene, compiles materials into shaders, builds the project and launches the game.
• The Armory and Iron engine, written in Haxe, runs the game: the scene graph, renderer, animation, physics integration, traits and logic nodes.
• Kha, also in Haxe, is a low-level framework that abstracts graphics, audio and input across platforms.
• Kore and Krom, in C and C++, form the native layer. Krom is the runtime that plays the game inside Blender while you work.

Game logic is attached to objects as traits. A trait can be a Haxe class, a logic-node tree built visually in Blender’s node editor, or a bundled trait for common jobs, such as a first-person controller.

Hello, Armory: A Haxe Trait

This trait spins any object it’s attached to. In Blender, select an object, open Object properties › Armory Traits, add a Haxe trait named Spinner, and paste this into the generated file:

package arm;

import iron.Trait;
import iron.math.Vec4;
import iron.system.Time;

/**
	Spins the object it's attached to around the Z axis.
	Attach it to any object in Blender: Object properties > Armory Traits > + Haxe.
**/
class Spinner extends Trait {

	@prop
	var degreesPerSecond: Float = 90.0;

	public function new() {
		super();

		notifyOnUpdate(function() {
			// Convert to radians and scale by the frame's time step.
			var angle = degreesPerSecond * Math.PI / 180 * Time.delta;
			object.transform.rotate(new Vec4(0, 0, 1), angle);
		});
	}
}

notifyOnUpdate registers a function that runs every frame, and Time.delta is the length of the frame, so the speed doesn’t depend on the frame rate. The @prop tag makes degreesPerSecond editable in Blender’s trait panel without changing the code.

Tested: we type-checked this trait with Haxe 4.3.3 against Armory’s current source code (October 2026) and the Kha framework it builds on, and it compiled cleanly. To confirm the check was real, we passed a string where rotate() expects a Vec4, and the compiler rejected it. We didn’t run it inside Blender, because the test machine had no GPU for Armory’s OpenGL player.

Rendering, Physics and Platforms

According to Armory’s website and repository, the engine includes:

• A scriptable renderer with deferred and forward paths. Materials come straight from Blender’s Cycles shader nodes.
• Lighting features including optional voxel global illumination or voxel ambient occlusion, lightmap baking, area lights, reflection probes and IES light profiles.
• Physics through Bullet, with Oimo as a lighter option, for rigid bodies and soft bodies, plus navigation meshes for AI movement.
• GPU particles and GPU skinning for animated characters.
• A built-in UI editor, with interfaces drawn by the engine’s own immediate-mode UI library.

Exports target Windows, macOS, Linux, Android, iOS and the web (Armory engine features). For native builds, the Haxe code is compiled to C through the HashLink toolchain, and a Windows C++ target using Haxe’s hxcpp compiler was added in October 2026. Web builds compile to JavaScript and run on WebGL.

Is Armory Written in C?

No. Armory is written mostly in Haxe. The engine itself, Armory and Iron, is a Haxe codebase of more than 700 source files, and its Blender add-on is Python. C and C++ appear only at the bottom of the stack, in Kore and Krom, which give Haxe code access to each platform’s graphics, audio and input. Haxe compiles to other languages, C for native builds and JavaScript for the web, which is how one codebase reaches every target.

Two other details are often misreported:

• The licence is zlib, not MIT. Both are permissive, and zlib lets you use, change and sell games built on the engine. Its main condition is that you don’t misrepresent where the source code came from.
• Consoles aren’t supported. Armory’s official targets are desktop, mobile and the web. There’s no public PlayStation, Xbox or Switch export.

Games Made with Armory

No widely known commercial games are built on Armory. Its showcase is mostly game-jam entries, demos and hobby projects shared on its forum and on itch.io. The best-known project from the same developer is ArmorPaint, a 3D texture-painting application that grew out of Armory’s technology and shares its core libraries.

Is Armory Still Developed in 2026?

Yes. The repository’s latest commits are from October 2026, and it has seen steady work every year since 2015, including more than 500 commits in 2025. The current SDK, 26.02, was released in February 2026 and is available free on itch.io for Windows, macOS and Linux (Armory SDK on itch.io). The development branch has moved on to support Blender 5.2, and recent work adds the new Windows C++ export target.

The caveats are the usual ones for a small open-source engine. Documentation lags behind the code, the community is small, and an Armory version is tied to a specific Blender version, so upgrading Blender can mean waiting for the next SDK. If you already know Blender and want a game engine that keeps you inside it, Armory is the most complete option. For a large commercial project, a bigger engine is the safer choice.

Armory 3D Alternatives

• Godot: a free, open-source engine with its own editor and a much larger community. It imports Blender files directly. See our Godot engine profile.
• UPBGE: a community fork of Blender that keeps the old Blender Game Engine alive and modernised, with Python scripting (UPBGE on GitHub). It’s still developed, with version 0.50 released in January 2026.
• Panda3D: an open-source engine scripted in Python or C++, with a Blender exporter. See our Panda3D engine profile.
• Unity: a large commercial ecosystem with console support, if you need it. See our Unity engine profile.

For more open-source engines, see our directory of open-source C++ game engines.

Key Takeaways

• Armory is a free, open-source 3D game engine that runs inside Blender, started by Lubos Lenco in 2015 and licensed under zlib.
• It’s written mainly in Haxe, on the Kha framework, with only its native layer in C and C++.
• Game logic is written as traits, in Haxe or with visual logic nodes, and materials come from Blender’s Cycles nodes.
• It exports to Windows, macOS, Linux, Android, iOS and the web; consoles aren’t supported.
• The latest SDK is 26.02 (February 2026), and development is active, with Blender 5.2 support in progress.
• It’s best for Blender users and small projects; no major commercial games are known to use it.

Conclusion

Armory answers a question many Blender users ask: why leave Blender to make a game? It keeps modelling, materials and gameplay in one place, on a lean, portable Haxe engine under one of the most permissive licences available. It’s still a small project, but ten years and more than 6,000 commits in, it’s also one of the most steadily developed open-source engines of its kind.

For more engines across every genre, browse our game development hub.