Projects sharing features with Engine

Babylon.js is a JavaScript game engine and real-time graphics renderer designed for creating interactive three-dimensional visuals and applications. It functions as a web-based 3D framework and WebGL engine that enables the deployment of high-performance 3D content across various web platforms and devices. The project provides tools for web-based 3D game development, real-time graphics rendering, and the creation of browser-based interactive visualizations. It also supports the development of WebXR virtual and augmented reality experiences using standard web technologies. The framework cover

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

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

whs.js is a WebGL 3D game engine and extensible application framework used to create interactive 3D experiences and browser-based games. It provides a simplified abstraction layer over low-level WebGL rendering to manage cameras, lighting, and the overall 3D environment. The framework utilizes a modular 3D scene graph to organize objects into a hierarchical system of components. It integrates multithreaded physics simulation by using web workers to run calculations in parallel with the main render loop. The system includes a modular plugin architecture that allows for the extension of base a

Stride is a C# game engine and 3D rendering engine used for building three-dimensional games and virtual reality applications. It functions as a comprehensive framework and development kit for creating immersive experiences within a managed code environment. The project includes a developer GUI framework for building internal debugging tools and utility panels. It also serves as a 3D physics simulator for calculating rigid body dynamics and collision detection within a scene. The engine covers environmental scene rendering and project scaffolding workflows. It provides tooling for game devel

Flame is a 2D game engine for Flutter and Dart. It provides a component-based game framework for managing entities and their lifecycles through a hierarchical architecture, alongside a dedicated system for game asset management and input handling. The engine distinguishes itself through a specialized integration layer for external physics engines to handle rigid body dynamics and collision detection. It also features a high-performance task model that uses isolates to offload heavy computations and prevent main thread blocking. The framework covers a broad range of capabilities including vis

This project is an open-source 3D game engine designed for building high-fidelity games, simulations, and cinematic environments. It functions as a robotics simulation platform with native integration for ROS 2 to model robot controllers and sensors. The engine features a multi-threaded Forward+ physically based renderer that supports hardware-accelerated ray tracing and global illumination. The system is built on a modular extension architecture using Gems to add or replace features without modifying core binaries. It includes a native SDK for AWS cloud integration, enabling IAM authenticati

LumixEngine is a high-performance C++ 3D game engine designed for building interactive 3D applications. It is built on a data-oriented component system that organizes objects in contiguous memory blocks to maximize CPU cache performance. The engine features a dynamic binary plugin architecture for loading external modules at runtime and an embedded scripting virtual machine that exposes internal logic for external control without recompilation. Computational workloads are managed via a task-based parallel execution model that distributes jobs across multiple processor cores. The framework in

This project is a Python voxel game engine and real-time renderer designed for interacting with block-based 3D environments. It functions as a procedural terrain simulator and a first-person navigator, allowing users to explore and visualize worlds composed of individual cubes. The system enables direct procedural terrain manipulation, providing a mechanism to add or remove blocks in real time to create custom structures. It utilizes a first-person camera system to translate keyboard and mouse inputs into movement and perspective changes within the virtual space. The engine handles 3D space

Mario-Kart-3.js is a browser-based 3D racing simulation implemented in JavaScript. It utilizes a WebGL game engine to render three-dimensional race tracks and vehicle models directly within a web browser using graphics hardware. The simulation features a physics-based drifting and maneuver system for gaining speed boosts and a power item system for deploying competitive advantages during races. The project encompasses a vehicle control system that maps keyboard and mouse inputs to steering and acceleration, alongside a simulation engine that manages collision detection and scripted item logi

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

Pygame is a framework for building interactive 2D applications and games using the Python programming language. It functions as a 2D graphics rendering engine, a game input and event manager, and a multimedia audio toolkit. The project serves as a wrapper for the Simple DirectMedia Layer, providing a Python interface for low-level access to graphics, audio, keyboard, mouse, and joystick hardware. Its capabilities cover 2D graphics rendering and image manipulation, digital audio playback and streaming, and the management of game entities and physics simulations. It also includes tools for rea

s&box is a game development platform built on Valve's Source 2 engine, integrating the .NET runtime as a first-class scripting and gameplay logic layer. It provides a full-featured visual editor that combines asset management, level design, and code editing into a single workflow, enabling developers to create and edit games within a modern editor environment. The platform distinguishes itself through a managed-native interop bridge that allows C# code to interact directly with native Source 2 systems for high-performance communication, alongside a hot-reload scripting system that supports li

FXGL is a 2D game engine and development framework designed for Java and Kotlin. It provides a structured environment for building cross-platform desktop games, integrating a central game loop with an entity component system and a JavaFX-based scene graph for rendering. The toolkit distinguishes itself by providing a comprehensive suite of integrated libraries for game AI pathfinding, physics collision resolution, and multiplayer networking via TCP and UDP protocols. It includes specialized systems for adaptive user interface design using global stylesheets and a data-driven asset management

Cocos2d-x is a high-performance C++ game development framework designed for building and deploying interactive applications across mobile, desktop, and web platforms. It functions as a cross-platform game engine that utilizes an entity-component system to manage object lifecycles, behaviors, and spatial relationships within a unified codebase. The engine is distinguished by its specialized 2D graphics rendering pipeline, which is optimized for hardware-accelerated performance when displaying sprites, particle effects, and skeletal animations. It provides developers with low-level access to gr

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

PixiJS is a hardware-accelerated 2D rendering engine and HTML5 canvas library. It functions as a web-based graphics engine that utilizes WebGL to draw interactive digital content, shapes, text, and images in the browser. The engine provides a specialized pipeline for high-performance 2D graphics, featuring a scene-graph hierarchy for organizing visual objects and a system for dynamic texture management. It includes capabilities for applying visual effects through masks, filters, and blend modes. The project covers broad functional areas including digital asset loading, user input processing

melonJS is a lightweight HTML5 game engine for building 2D games in the browser using JavaScript. It provides a complete framework for sprite animation, tilemap loading, physics simulation, input handling, and audio playback, with a unified rendering system that automatically switches between WebGL and Canvas2D backends without code changes. The engine distinguishes itself through several integrated capabilities. It features a per-sprite shader pipeline for custom fragment shader effects, a SAT-based collision engine with swappable physics adapters (including built-in SAT, Matter.js, and Plan

cocos2d-iphone is a framework for 2D game development and the creation of two-dimensional graphical applications. It enables cross-platform development for iOS and macOS using Objective-C and high-performance graphics rendering. The project provides tools for building interactive environments, including the creation of orthogonal, isometric, or hexagonal tile-based maps. It supports the implementation of rigid body dynamics and collision detection through a 2D physics simulation system. The framework covers a broad range of capabilities, including sprite-based rendering, audio playback manag

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

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

Panda3D is a cross-platform game engine and 3D graphics rendering system developed for Python and C++. It functions as a comprehensive framework for building interactive 3D applications, providing a real-time physics simulator and a specialized 3D asset pipeline tool. The engine distinguishes itself by combining a high-performance C++ core with interoperable Python language bindings. It utilizes a scene graph architecture to organize 3D objects and provides a pipeline-based asset conversion system to optimize models and textures for runtime loading. Its capability surface includes low-level

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

model-viewer is a web-based 3D model viewer provided as a web component for rendering interactive three-dimensional assets and animations directly in a browser. It functions as a specialized GLTF web renderer designed to display GLTF and GLB files with settings optimized for performance and quality. The project includes a WebXR augmented reality player that projects 3D models into real-world environments using mobile device cameras and spatial tracking. It also features a visual regression testing tool capable of generating golden images and comparing renders to detect visual regressions in 3

The GoldSrc game engine is a 3D game framework and first-person shooter engine designed for building and running interactive software. It functions as a moddable game framework, providing a system for creating custom game rules and content through client-side code and shared libraries. The project includes a game engine SDK and development tools for compiling custom game logic into dynamic link libraries. This modular structure allows for the development and distribution of game modifications on Windows and Linux platforms.

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

Fyrox is a Rust-based game engine for building both 2D and 3D games, designed as a native engine with no runtime dependencies. It compiles directly to native code for Windows, macOS, Linux, and WebAssembly, providing direct hardware access through the Rust programming language. The engine is built around an entity-component-system architecture that organizes game objects as entities with attached components processed by modular systems. Its graph-based scene management represents game scenes as directed acyclic graphs of nodes with transform hierarchies and property inheritance, while a paral