Open-source alternatives to Kaiju

Hilo is an HTML5 game engine for building 2D games that run across browsers and devices. It renders graphics through Canvas, DOM, or WebGL backends, automatically selecting the best option for the target environment. The engine provides a complete game development solution with sprite, skeletal, and particle animation, along with a texture atlas system for efficient image loading and rendering. The framework distinguishes itself through its integration of the DragonBones skeletal animation engine, which drives bone-based character movement without frame-by-frame sprites, and its Chipmunk phys

Ogre is a high-level 3D rendering engine designed for creating games, simulations, and visualizations without requiring low-level graphics API code. It functions as a framework for real-time 3D graphics processing, providing a physically based renderer to simulate lifelike surfaces and lighting. The engine includes specialized systems for skeletal animation to control character movement and a terrain generation system for producing large textured landscapes. These features are supported by automatic levels of detail and distance-based mesh management to maintain performance. The project cove

Space Station 14 is a C# multiplayer game and roleplay simulation framework. It is built upon an Entity-Component-System (ECS) game engine that separates logic into systems and data into components to manage complex entity interactions. The project functions as a grid-based physics simulator with a YAML data-driven prototype system for defining game objects. The project features a specialized 2D sprite rendering engine that maps server-side appearance data to client-side shaders. It implements a networking model with client-side prediction and dirty-flagged state synchronization to reduce inp

cocos2d-objc is an Objective-C 2D game engine designed for developing interactive games and applications. It serves as a cross-platform game framework that enables the deployment of a shared codebase across iOS, tvOS, and macOS. The project features a hardware-accelerated 2D renderer utilizing OpenGL and Metal to display sprites, tile maps, and particle effects. It includes a dedicated OpenAL audio engine for managing music and spatialized sound effects, alongside a cross-platform input handler for processing touch, mouse, keyboard, and accelerometer events. The framework provides capabiliti

Echo is a cross-platform game engine designed for the development of two-dimensional and three-dimensional interactive projects. It provides a unified environment that integrates scene management, visual scripting, and graphics rendering into a single workflow, allowing developers to build and deploy applications across desktop, mobile, and web platforms. The engine distinguishes itself through a node-based architecture that governs both scene organization and game logic. By utilizing a visual scripting tool and a data-flow shader graph, users can define complex behaviors and custom materials

This project is a WebGL 3D game engine and comprehensive suite of tools for rendering high-performance 3D graphics and interactive scenes in the browser using WebGL and WebGPU. It provides a dedicated WebXR framework for building augmented and virtual reality experiences that run directly in a web browser. The engine includes a specialized Gaussian splatting renderer for displaying 3D point-cloud data to create photorealistic environmental captures. It utilizes a glTF asset pipeline to load and stream compressed 3D models and textures for efficient asset delivery. The system covers real-time

Magnum is a C++ middleware suite for cross-platform graphics development and real-time data visualization. It provides a hardware-agnostic rendering layer that translates graphics commands into platform-specific calls, ensuring consistent behavior across different GPU drivers and APIs such as Vulkan. The project focuses on decoupling application logic from underlying hardware through abstract graphics and system utilities. It features a plugin-based resource importer for 3D assets and audio, a hierarchical scene graph for spatial transformations, and a high-performance signal-based event syst

Gameplay is a high-performance C++ game engine and cross-platform framework designed for developing 2D and 3D interactive games. It functions as both a 3D graphics engine for rendering environments and a 2D game development kit for creating sprite-based mechanics. The framework provides a cross-platform abstraction layer to ensure that game logic and graphics run across various hardware and software platforms using a shared codebase. The engine implements a hardware-accelerated rendering pipeline and component-based game logic to separate data from behavior. It utilizes a native C++ impleme

Redot Engine is a multi-platform 2D and 3D game engine that provides a unified editor interface for creating and publishing games across desktop, mobile, web, and console platforms. At its core, the engine uses a scene tree node architecture where game objects are organized hierarchically, with each node inheriting transforms and properties from its parent, and a scriptable node system that allows attaching GDScript, C#, or VisualScript code directly to nodes for custom behavior without recompiling. The engine distinguishes itself through an editor-embedded runtime that runs the game inside t

Tiled is a multifunctional visual workspace for designing tile-based game levels, managing assets, and exporting structured world data. It functions as a 2D tile map editor and game level design tool used to create orthogonal, isometric, and hexagonal game environments. The software features a scriptable interface and plugin system for automating map creation tasks. It includes a dedicated tile set manager for importing and editing image-based collections of reusable tiles and animations, as well as a system for saving map layouts and custom properties into JSON or CSV formats. The platform

Urho3D is a cross-platform 3D game engine written in C++. It uses a component-based scene graph to compose game objects from nodes and attached components, separating transforms from behaviors for modular design. The engine integrates AngelScript and Lua scripting for game logic, uses the Bullet library for physics simulation, and renders scenes with OpenGL or Direct3D through forward, deferred, or light pre-pass pipelines with customizable render passes and shadow mapping. The engine distinguishes itself with a built-in visual scene and UI editor for composing 3D worlds and interface layouts

ShaderForge is a web-based GPU tool and visual GLSL shader editor. It serves as a node-based shader designer that allows users to construct programs for the graphics processor by connecting logic blocks in a directed acyclic graph rather than writing manual code. The tool functions as a technical art workflow bridge for creating game assets and surface materials. It provides a browser-based environment for real-time authoring, featuring instant GLSL compilation and live hot-reloading of GPU programs. The system converts visual graph connections into GLSL source code using abstract syntax tre

LibGDX is a Java-based framework designed for cross-platform game development, enabling the creation and deployment of 2D and 3D games across desktop, mobile, and web environments from a single codebase. It functions as a comprehensive library that abstracts hardware-accelerated graphics, audio, input, and file system access, providing a unified interface for developers to manage game logic and application lifecycles. The framework distinguishes itself through a high-performance architecture that prioritizes efficiency and native interoperability. It utilizes a batch-oriented graphics pipelin

Defold is a cross-platform game engine and integrated development environment used to create 2D and 3D games for desktop, mobile, and web targets. It combines a game development IDE for asset and scene management with a multi-platform build system and a scripting environment based on Lua. The engine includes a specialized headless runtime for hosting game servers and performing automated testing without a graphical interface. It supports native engine extensions, allowing custom low-level code to be integrated into the core to expand functionality beyond the standard scripting interface. The

Funkin is a rhythm game engine and scriptable gameplay framework designed for creating musical battle games with synchronized note charts and audio. It functions as a comprehensive toolset for rhythm game modding, allowing for the addition of custom songs, characters, and stages through external assets and metadata. The project distinguishes itself through a dedicated modding system that supports priority-based asset overriding and a data patching utility for modifying JSON and XML configuration files via targeted merge operations. It utilizes a scriptable environment that executes external s

This project is a cross-platform game engine and development toolkit designed for creating high-performance 2D and 3D games. It serves as a 3D graphics rendering engine and a web-based game framework that allows applications to be deployed across mobile, desktop, and web environments from a single codebase. The engine features a configurable render pipeline that supports both forward and deferred rendering paths. It utilizes a cross-platform graphics abstraction layer and universal shader translation to ensure consistent visual output across different hardware and platforms. The toolkit incl

This project is a comprehensive educational resource for building a high-performance game engine from the ground up using C++. It serves as a technical guide for developers seeking to understand the low-level architecture of engine systems, providing a structured approach to implementing core components like rendering pipelines, entity-component-system patterns, and multi-threaded task scheduling. The resource distinguishes itself by focusing on the practical implementation of complex engine subsystems, including graphics API abstraction layers for cross-platform compatibility and data-driven

Vulkan-Hpp is a header-only C++ binding library for the Vulkan graphics and compute API. It provides a type-safe wrapper around the Vulkan C API, allowing developers to interface with GPU hardware through a C++ interface that introduces no runtime CPU overhead. The library utilizes Resource Acquisition Is Initialization patterns to manage the lifecycle of Vulkan handles and objects, automating the release of GPU resources. It replaces C-style enumerations and bit-fields with strong typing and static type checking to catch invalid API parameter assignments during compilation. The project cove

cannon.js is a JavaScript 3D physics engine designed for calculating rigid body dynamics and collisions in three-dimensional space. It functions as a rigid body dynamics engine that models mass, friction, and velocity to determine object movement, while providing a mathematical framework for applying physical constraints and joints. The engine supports a variety of collision volumes, including spheres, boxes, convex polyhedrons, heightfields for terrain simulation, and complex triangle meshes. It provides tools for identifying intersections between these shapes and calculating the exact areas

Spring is a cross-platform game engine and framework designed specifically for the development and execution of multiplayer real-time strategy games. It provides a high-performance simulation environment for managing large-scale battles and unit movements across different operating systems using a shared codebase. The engine functions as a multiplayer game server and networking layer, coordinating real-time game state and match synchronization between remote players. It includes a dedicated lobby client system for multiplayer match coordination as well as the capability to execute single-play

egret-core is a cross-platform game engine and mobile application framework used to develop 2D and 3D software for Android, iOS, and Windows. It serves as a multi-platform graphics engine and input handler designed to maintain consistent visual output and interaction behavior across different hardware. The project provides a game physics and animation suite that integrates external libraries for skeletal animations, particle systems, and complex physics simulations. It utilizes a hardware-abstraction layer to standardize touch, keyboard, and mouse interactions across multiple operating system

This project is a browser-based game engine and implementation of a racing game built using a declarative component architecture. It provides a framework for constructing interactive three-dimensional environments and game objects by mapping hierarchical data structures to a persistent scene graph. The engine distinguishes itself by synchronizing game logic with high-performance rendering through a centralized data store. This approach ensures that physics calculations, player progress, and environmental variables remain consistent with the visual output of the scene. Developers can compose c

MoltenVK is a Vulkan implementation for macOS that acts as a cross-API graphics wrapper. It serves as a translation layer that maps Vulkan graphics and compute API calls to corresponding Metal commands for execution on Apple hardware. The project enables the translation of Vulkan rendering pipelines to the native Metal framework, allowing cross-platform graphics and compute applications to run on Apple operating systems. This facilitates the porting of games and applications developed for other platforms to macOS. The implementation includes capabilities for advanced graphics feature impleme

waifu2x-ncnn-vulkan is an AI super-resolution tool and image processor that uses deep learning to increase image resolution and remove visual noise. It is an NCNN-based implementation designed for efficient neural network inference on local hardware. The project utilizes the Vulkan API to provide GPU-accelerated image scaling and noise reduction across diverse graphics hardware. It employs tiled image processing to prevent GPU memory overflow and multi-threaded model loading to reduce initial startup latency. The software covers functional domains including AI image upscaling for maintaining

FlaxEngine is a cross-platform game engine and development kit designed for creating high-fidelity 2D and 3D games. It functions as a programmable framework that supports the use of C# and C++ for building interactive experiences. The project includes a high-speed graphics rendering engine capable of producing professional visual assets and detailed three-dimensional scenes. It provides a pipeline for compiling and exporting project files across various operating systems using native software development kits and toolchains.

ammo.js is a JavaScript port of the Bullet physics engine, compiled via Emscripten to provide a high-performance physics library for the browser. It functions as a 3D rigid body engine and an Emscripten compiled library that enables complex physical computations using WebAssembly and JavaScript. The project provides specialized simulation capabilities for soft body physics, modeling the deformation of flexible materials like cloth and rubber, and a vehicle dynamics engine for calculating the mechanics of wheeled vehicles. The simulation surface also covers rigid body dynamics for non-deforma

VulkanTutorial is a comprehensive educational guide and instructional resource for implementing low-level rendering and compute pipelines using the Vulkan API. It serves as a GPU programming course and a step-by-step guide for building high-performance graphics applications from scratch. The project provides detailed instruction on the full graphics pipeline, including the compilation of shaders to SPIR-V bytecode, the configuration of rasterization states, and the implementation of 3D graphics pipelines. It also covers general-purpose GPU compute programming, focusing on the execution of par