Armory is an open-source 3D game engine designed for developers who want a seamless, end-to-end workflow within Blender. Unlike traditional engines that require exporting assets to an external tool, Armory integrates directly as a Blender add-on, allowing artists and developers to model, animate, rig, light, and code game logic—all within the same interface. Built with C++ for performance and Haxe for scripting, it supports both deferred and forward rendering paths out of the box. Its minimal footprint and focus on portability make it ideal for creating 2D/3D games targeting web (WebGL), desktop, mobile, and VR platforms without requiring external middleware or complex build pipelines.
What You Get
- Full Blender Integration - Armory installs as a native Blender add-on, enabling direct access to materials, animations, physics, and scene data without export steps. Users can edit scenes in Blender and run them live with F5.
- Scriptable Renderer - The engine’s renderer is fully scriptable in Haxe, supporting both deferred and forward rendering pipelines. Users can customize lighting, shadows, post-processing effects, and shaders via code.
- Cross-Platform Deployment - Projects can be compiled and exported to HTML5 (WebGL), Windows, macOS, Linux, iOS, Android, and VR headsets using the same project files.
- Built-in Physics & Animation - Leverages Blender’s rigid body, soft body, and armature systems directly in-game. Animations are automatically baked and optimized for runtime.
- Haxe-Based Game Logic - Write game scripts in Haxe, a statically-typed language with support for object-oriented and functional patterns. Integrate with external libraries via HaxeFlixel or OpenFL bindings.
Common Use Cases
- Building indie 3D games with artists and programmers on the same tool - A small team uses Armory to develop a narrative-driven 3D adventure game where artists create assets in Blender while programmers write logic in Haxe—all within one interface, eliminating file export/import friction.
- Creating WebGL-based interactive experiences - A developer builds an educational 3D visualization of molecular structures that runs in browsers, using Armory’s WebGL export and lightweight runtime to ensure fast loading on low-end devices.
- Prototyping game mechanics with real-time feedback - A designer modifies a character’s animation in Blender, presses F5 to instantly see it run with physics and lighting applied, then adjusts collision bounds without leaving the editor.
- DevOps teams deploying to multiple platforms from a single source - A studio maintains one Armory project and uses command-line builds to generate standalone executables for Windows/macOS/Linux and APK/IPA files for mobile—all from the same blend file.
Under The Hood
Armory3D is a cross-platform 3D game engine designed for real-time rendering and interactive development, with strong integration capabilities through Blender and Kha. It supports both 3D and 2D UI workflows, offering a modular architecture that enables extensibility and performance optimization across multiple platforms.
Architecture
This system adopts a layered architecture that separates core engine logic from UI tooling and asset handling. It emphasizes component-based design patterns and modular UI systems.
- Implements a component-based architecture for managing game elements and UI components
- Separates editor tools from runtime environments to support flexible development workflows
- Integrates Zui for UI composition and modular design patterns for extensibility
Tech Stack
Built with a multi-language ecosystem emphasizing Haxe and C++ for performance, alongside Python and JavaScript for scripting and automation.
- Uses Haxe as the primary language with C++ integration for low-level rendering and performance-critical tasks
- Relies on Kha for cross-platform rendering and V8 for JavaScript interoperability
- Leverages Python for build scripts, automation, and Blender integration through custom exporters
- Integrates with CI/CD pipelines and testing frameworks to ensure build consistency
Code Quality
While the codebase shows some structured organization and error handling, it exhibits inconsistencies in style and limited test coverage.
- Error handling is present across modules but lacks comprehensive testing strategies
- Code organization exists but varies in adherence to style and naming conventions
- Type annotations are present, contributing to improved code clarity and maintainability
- Limited automated test coverage affects overall reliability and confidence in changes
What Makes It Unique
Armory3D distinguishes itself through its hybrid architecture and deep integration with Blender, enabling a seamless 3D development pipeline.
- Combines Haxe and C++ to deliver high-performance UI and rendering capabilities with JavaScript support
- Offers canvas-based 2D UI composition that supports rotation, grid snapping, and hierarchical element management
- Includes built-in asset and theme support for runtime UI customization and cross-platform portability
- Provides a unified ecosystem that bridges 3D authoring in Blender with real-time UI prototyping and deployment