Fyrox is a modern, open-source game engine designed for developers who need full control over performance and memory without sacrificing productivity. Built entirely in Rust, it provides a visual scene editor, real-time code hot reloading, and a comprehensive scripting API to streamline game development for both 2D and 3D projects. It’s ideal for indie developers, studios, and Rust enthusiasts seeking a stable, high-performance alternative to C++ engines.
Fyrox leverages Rust’s safety and concurrency features to deliver memory-safe rendering and physics, while its modular architecture allows deep customization. The engine supports GLTF, tile maps, advanced lighting, and GPU-based occlusion culling. It can be deployed as a standalone executable or embedded into larger Rust applications, with full tooling support via JetBrains IDEs and active community channels on Discord and GitHub Discussions.
What You Get
- Visual Scene Editor - A built-in GUI editor for arranging 3D/2D scenes with drag-and-drop entities, components, and properties, enabling non-code asset pipeline management.
- Real-time Code Hot Reloading - Modify Rust source code while the game is running and see changes applied instantly without restarting the engine.
- GLTF 2.0 Support - Native import and rendering of GLTF 2.0 models with PBR materials, animations, and skinning for modern asset pipelines.
- Tile-based Occlusion Culling - Optimized rendering system that culls off-screen tiles in 2D/3D scenes to improve performance on large maps.
- Scripting API with Rust - Write game logic directly in Rust using a well-documented API, avoiding the performance penalties of external scripting languages.
- Project Manager & Asset Preview - Built-in tool to create, open, and manage game projects with automatic preview generation for textures, models, and animations.
- GPU-Based Batching - Automatic draw call batching for 2D and 3D renderables to reduce CPU overhead and improve frame rates.
- UI Styling System - CSS-like styling for UI elements with support for custom fonts, colors, layouts, and animations in the editor and runtime.
Common Use Cases
- Building a 2D platformer with tile maps - A developer uses Fyrox’s tile map system and occlusion culling to create a performance-optimized 2D game with large levels.
- Developing a 3D indie game with Rust - A solo developer leverages Fyrox’s hot reloading and Rust scripting to rapidly prototype and ship a 3D game without C++ complexity.
- Creating a technical demo with PBR rendering - A graphics programmer uses Fyrox’s GLTF support and lighting system to showcase real-time physically based rendering techniques.
- Prototyping a VR experience with low-level control - A researcher uses Fyrox’s direct access to rendering and input systems to build a custom VR prototype in Rust.
Under The Hood
Architecture
- Clear modular separation via Cargo workspaces with distinct crates for core logic, graphics, animation, and UI, each enforcing bounded responsibilities
- Entity-Component-System architecture with explicit abstractions for components, entities, and systems, enabling data-oriented design and loose coupling
- Graph-based scene hierarchy with recursive transformation propagation, allowing declarative composition of complex scenes
- Plugin system supporting runtime extensibility for renderers, scripts, and editors without recompilation
- Clean separation between engine core and editor layers, with the editor acting as a composite orchestrator rather than a tightly coupled component
Tech Stack
- Rust 1.70+ codebase leveraging Cargo workspaces for unified build management across modular crates
- OpenGL-based rendering with custom GLSL shaders and a physically-based pipeline featuring real-time global illumination via voxel cone tracing
- Built-in native UI system with widget primitives, eliminating external GUI dependencies
- Optimized release profiles with LTO, panic abort, and z-level optimizations for high-performance game builds
- Custom binary/text serialization for assets and scenes, with no reliance on external databases or traditional deployment pipelines
Code Quality
- Extensive test suite using macro-based DSLs for expressive, fluent UI automation and integration testing
- Strong compile-time safety through custom derive macros (Reflect, Visit, TypeUuidProvider) that eliminate runtime errors in serialization and reflection
- Clean separation of test utilities and domain logic via extension traits and plugin-based runners
- Consistent, descriptive naming conventions across components and test assertions, improving maintainability
- Comprehensive use of Rust’s type system to reduce boilerplate while ensuring correctness without runtime error handling
What Makes It Unique
- Compile-time registered ECS with zero-cost abstractions, avoiding runtime reflection entirely
- Integrated physically-based rendering with real-time global illumination using voxel cone tracing, rare in open-source engines
- Declarative UI system where UI elements are first-class scene nodes with full transform and animation support
- Runtime hot-reloading of shaders, materials, and scenes enabling seamless iterative development
- Procedural terrain and vegetation systems powered by GPU-accelerated noise and instanced rendering for massive open worlds
- Native WebAssembly scripting with direct engine access, allowing browser-based prototyping without porting