Armory

Armory is an open-source 3D game engine built directly into Blender, eliminating the fragmented workflow between asset creation and game development. Instead of exporting models and reimporting them into a separate engine, Armory treats Blender itself as the game editor — every mesh, material, animation, and scene is live game data. The result is a single-tool pipeline that takes a project from concept to shipped game across desktop, mobile, and web targets.

Under the hood, Armory uses Haxe as its scripting language, which compiles down to optimized C++ for native targets and JavaScript for WebGL — giving developers a high-level, statically-typed language without the runtime overhead of an interpreted scripting layer. The rendering system is fully scriptable, with deferred and forward paths available out of the box and compile-time flags that strip unused features for each target platform.

Game logic can be authored two ways: through Haxe code attached as Trait components to scene objects, or through a visual Logic Node system that compiles node graphs to typed Haxe at export time rather than interpreting them at runtime. This means visual scripting carries no performance penalty compared to hand-written code.

Physics is powered by Bullet (supporting rigid bodies, soft bodies, and ray casting) or the lighter Oimo engine, with Recast/Detour navigation meshes for NPC pathfinding. Export targets include Windows, Linux, macOS, iOS, Android, and WebGL — all configured within Blender’s properties panel with no target-specific code required.

What You Get

• Blender Integration - Armory runs as a native Blender add-on, giving you a complete game editor inside Blender where every scene change is instantly reflected in your game without any import/export step.
• Haxe Scripting - Write game logic in Haxe, a statically-typed language that compiles to C++ for native performance on desktop and mobile, and to JavaScript for WebGL targets.
• Logic Nodes (Visual Scripting) - Design game behaviors using a node graph editor inside Blender; nodes compile to typed Haxe at export time, so visual scripting carries no runtime performance penalty.
• Multi-Target Export - Deploy to Windows, Linux, macOS, iOS, Android, and WebGL from a single Blender project with no platform-specific code or separate build pipelines.
• Scriptable Render Paths - Choose between deferred and forward rendering, with compile-time feature flags that strip unused passes to optimize performance for each target device tier.
• Bullet and Oimo Physics - Built-in support for both the full-featured Bullet engine (rigid bodies, soft bodies, constraints, ray casting) and the lightweight Oimo engine for simpler simulations.
• Recast/Detour Navigation Meshes - Auto-generate pathfinding meshes from scene geometry and attach NavAgent traits to NPCs for real-time A* navigation without external tooling.
• GPU Particle Systems - Emitter and hair particle systems rendered via GPU instancing, supporting thousands of particles with configurable CPU or GPU simulation modes.
• Advanced Post-Processing - Built-in passes for bloom, depth of field, chromatic aberration, screen-space ambient occlusion, motion blur, and dynamic resolution scaling.
• VR and Raytracing Support - Optional VR rendering path and experimental raytracer path, both configurable as compile-time render path targets.

Common Use Cases

• Indie developers building cross-platform 3D games - Solo developers and small teams use Armory to take a game from Blender concept to shipped WebGL, desktop, or mobile builds without learning a second toolchain or reformatting assets.
• 3D artists prototyping interactive experiences - Artists who already know Blender use Armory’s logic nodes to add interactivity to scenes — walk-around environments, product demos, or interactive installations — without writing code.
• Game dev educators teaching unified pipelines - Instructors use Armory to teach modeling, animation, physics, and scripting in a single tool, reducing the number of software licenses and context switches students need to manage.
• Web game developers targeting WebGL - Developers use Armory’s Haxe-to-JavaScript compilation to ship performant browser games with hardware-accelerated rendering, physics, and audio — all exported from a Blender project.
• Mobile game studios prototyping with physics - Studios prototype physics-heavy mobile games in Blender with Bullet, then export directly to iOS and Android SDK targets using Armory’s built-in mobile build pipeline.
• Technical artists building custom render pipelines - Render engineers use Armory’s fully scriptable render path API to write custom GLSL passes, post-process effects, and shader pipelines without forking the engine.

Under The Hood

Architecture

Armory employs a two-layer architecture split between a Python-based Blender add-on that handles authoring, export, and build orchestration, and a Haxe/C++ runtime that runs the actual game. The runtime uses an entity-component model via Trait objects attached to scene nodes — the iron framework provides foundational abstractions (App, Scene, Object) while the armory layer adds game-specific systems on top. Render paths (forward, deferred, raytracer) are selected at compile time via conditional compilation flags, enabling zero-cost abstraction without runtime branching overhead. The visual logic node system generates typed Haxe code during the Blender export pass rather than interpreting node graphs at runtime, which means visual scripting incurs no execution penalty over hand-written code.

Tech Stack

The stack is genuinely polyglot: Python via Blender’s bpy API handles the entire authoring pipeline, UI, and export process; Haxe is the primary scripting language, compiling to C++ for native targets and JavaScript for WebGL; C++ underpins the Kha and Krom runtime layers for platform-level rendering and asset loading; GLSL covers a large library of render passes. Bullet and Recast/Detour are integrated as C++ submodules for physics and navigation. The Kha framework abstracts rendering and audio across all supported platforms, while the Krom runtime serves as the native host for desktop builds. No web frameworks, ORMs, or traditional databases are involved — the pipeline is entirely centered on Blender’s ecosystem.

Code Quality

No formal test infrastructure exists in the repository — no test directories, CI configuration files, or automated test runners were found. Error handling in Haxe source leans on null returns and trace-based debugging rather than typed exceptions or Result-style patterns. The Python add-on code is extensive but inconsistently structured, with limited defensive error propagation. A checkstyle configuration exists for Haxe but there is no evidence of it being enforced in a CI pipeline. The codebase is large, actively maintained, and well-organized by domain, but lacks the automated quality scaffolding that would be expected of a project at this scale.

What Makes It Unique

Armory’s core innovation is treating Blender not as an asset pipeline but as the live game editor itself — scene changes appear in game immediately without an import/export round-trip. The logic node system compiles visual graphs to typed Haxe at export time rather than interpreting them at runtime, eliminating the performance gap that usually separates visual and code-based scripting. Multi-target compilation via Haxe — producing optimized C++ for native platforms, JavaScript for WebGL, and targeting mobile SDKs — from a single codebase is a technically distinctive design that very few open-source engines replicate. The scriptable render path system using compile-time flags makes it possible to ship zero-overhead, target-optimized render pipelines for different device tiers from one code path.

Self-Hosting

Armory is released under the zlib/libpng License, one of the most permissive open-source licenses available. You can use it commercially, modify it, redistribute it, and embed it in proprietary products without any copyleft obligations — the only requirements are that you do not misrepresent the software’s origin and that you mark altered versions as modified. There is no dual-licensing, no open-core model, and no paid commercial license required for any use case.

Running Armory yourself means owning the full build pipeline: a working Blender installation with the Armory add-on, Haxe compiler toolchain, and target-specific SDKs (Xcode for iOS, Android NDK for Android). Desktop and web builds are straightforward from within Blender, but mobile builds require platform SDKs configured outside of Blender. There is no hosted build service or CI integration provided — you are responsible for setting up your own build environment, keeping Blender and Armory versions in sync, and managing updates as new releases ship roughly every three months.

Armory has no official managed hosting, SaaS tier, or enterprise support contract. Community support is available through the Armory forums and GitHub issues, and the wiki provides documentation covering most engine features. There is no SLA, no guaranteed response time, and no commercial support channel. Teams evaluating Armory for production should factor in the cost of self-managed build pipelines, the relatively small contributor base, and the fact that engine updates may require updating project configurations or Blender versions — operational work that a commercial engine’s vendor would handle for you.