Armory is a Blender-integrated 3D game engine designed for developers who want to create high-performance games without leaving the Blender environment. It solves the fragmentation between 3D modeling and game development by embedding a full game engine inside Blender, allowing artists and programmers to work in a single, unified toolchain. Built with C++ and Haxe, it supports deferred and forward rendering, GPU skinning, and real-time physics, making it ideal for indie developers and studios seeking portability and performance.
The engine is deployed as a Blender add-on with no separate installation, leveraging Blender’s existing asset pipeline while adding game-specific features like logic nodes, Haxe scripting, and multi-target export. It uses Bullet and Oimo physics engines, GPU instancing for particles, and supports WebGL, native desktop, and mobile exports—all from within Blender’s interface.
What You Get
- Blender Integration - Armory runs as a native Blender add-on, allowing users to model, texture, animate, and game-design all within Blender without exporting assets or switching tools.
- Haxe Scripting - Write game logic in Haxe, a statically-typed language with cross-platform compilation, enabling full control over game behavior and performance optimization.
- Logic Nodes - Visual scripting system with customizable nodes to create interactive behaviors without writing code, ideal for designers and rapid prototyping.
- Multi-Target Export - Deploy games to Windows, Linux, macOS, iOS, Android, and Web (WebGL) from a single project with no code changes required.
- Advanced Rendering - Full support for deferred and forward rendering paths, lightmapping, area lights, reflection probes, IES textures, and voxel-based ambient occlusion.
- GPU-Optimized Particles - Support for emitter and hair particle systems using GPU instancing to render thousands of particles with minimal performance cost.
- Physics Engines - Built-in support for Bullet (rigid/soft body) and Oimo physics engines, configurable per project for realistic simulations.
- Navigation Meshes - Generate real-time pathfinding for NPCs by marking objects as actors and auto-generating navigational meshes from scene geometry.
Common Use Cases
- Indie game developers building cross-platform 2.5D games - Developers use Armory to create polished games in Blender, then export to web and mobile without learning a separate engine or asset pipeline.
- Game educators teaching 3D game dev - Instructors use Armory’s Blender integration to teach modeling, animation, and scripting in one environment, reducing tool complexity for students.
- Mobile game studios prototyping with real-time physics - Teams prototype mobile games with realistic physics and particle effects in Blender, then deploy to iOS/Android using Armory’s built-in SDK.
- Web-based interactive experiences - Artists and developers create WebGL games and interactive installations using Armory’s lightweight export and Haxe scripting for dynamic content.
Under The Hood
Architecture
- The system employs a layered, plugin-based architecture with clear boundaries between high-level game logic and low-level physics systems, leveraging embedded submodules for external libraries like Bullet and RecastNavigation.
- Dependency injection is implemented via factory patterns and abstract interfaces, enabling runtime polymorphism while maintaining loose coupling between rendering, physics, and navigation components.
- A multi-language design separates Haxe for configuration and orchestration from C++ for performance-critical subsystems, though the absence of a unified DI framework leads to direct instantiation and reduced testability.
- Component interactions are mediated through well-defined data structures and abstract interfaces, promoting modularity despite deep integration with native libraries.
Tech Stack
- The core is built around Blender via its Python API (bpy), with Armory3D serving as the real-time engine for rendering and game logic, forming a tightly integrated authoring-to-runtime pipeline.
- Haxe acts as a build-time orchestrator, generating C++ code for game logic, while JavaScript is used sparingly for tooling, with consistent formatting enforced via EditorConfig and checkstyle.json.
- No traditional databases or web frameworks are present; the stack is entirely centered on Blender’s ecosystem and Kha’s cross-platform asset pipeline.
- Build and deployment workflows are tightly coupled to Blender’s internal systems, with no visible CI/CD or external build tooling.
Code Quality
- Third-party libraries are integrated with minimal abstraction, prioritizing performance over modularity and increasing maintenance complexity.
- Error handling is sparse and relies on raw exceptions or silent failures, reducing debuggability and resilience.
- Type safety is absent in source files, with dynamic typing and C-style conventions prevalent across Haxe and C++ interop layers.
- Testing is largely undocumented and manual, with no visible unit or integration test infrastructure.
- Naming conventions and code style are inconsistent across languages, and linting, static analysis, or CI pipelines are missing.
What Makes It Unique
- Deep Haxe-to-C++ code generation enables high-level productivity with near-native performance for game logic, bridging scripting ease with execution speed.
- A custom Krom rendering pipeline embeds shader binaries directly, eliminating external toolchain dependencies for cross-platform shader deployment.
- Native multithreaded physics solvers with pluggable backends (OpenMP, TBB) provide automatic parallelism without developer configuration.
- Unified asset handling via Kha ensures seamless resource management across graphics, audio, and physics systems in a single pipeline.
- Lightweight spin mutexes with platform-specific atomics optimize real-time physics concurrency with minimal system call overhead.