Open-source alternatives to Kbengine

BrowserQuest is a WebSocket multiplayer game engine and real-time state synchronization tool. It functions as a web-based game server designed to manage concurrent connections and broadcast updates to maintain a consistent shared world state between a central server and distributed web clients. The project enables real-time multiplayer gaming and browser-based game development by implementing low-latency data exchange. It focuses on game state synchronization to ensure that multiple players interacting within the same environment see the same actions and world states simultaneously. The syst

Warzone 2100 is an open-source real-time strategy game engine focused on tactical combat and base building. It operates as a real-time strategy game engine utilizing a data-driven asset pipeline and providing cross-platform support. The project features a modular unit design system that uses a technology tree to construct combat entities by combining chassis, propulsion, and weapon components. It includes a lockstep multiplayer network engine to synchronize game state across distributed clients for competitive matches, as well as a JavaScript game scripting framework for implementing custom l

FiveM is a multiplayer modification framework and game engine modding tool. It serves as a platform for creating and hosting community-driven modifications for open-world game engines, functioning specifically as a framework for Grand Theft Auto V to enable custom servers and multiplayer game modes. The project provides a dedicated game server host for managing network traffic and synchronized game states in modified environments. Its capabilities extend to modding Red Dead Redemption 2, allowing for the extension of game mechanics and the addition of custom content. The framework supports c

tModLoader is a modding framework and toolset designed for expanding game content and extending core game logic. It provides a polymorphic content API that allows for the creation of new items, NPCs, projectiles, and world assets through object-oriented inheritance. The project is distinguished by its advanced code modification capabilities, utilizing intermediate language bytecode patching and reflection-based private access to alter internal game behavior. It features a hot-reloading assembly runtime that enables developers to recompile and apply source code changes in real-time without res

Cuberite is a high-performance multiplayer game server for Java Edition clients, designed to provide a low-memory and low-CPU environment for hosting shared virtual spaces. The server is built for cross-platform deployment across various operating systems and hardware types. It allows for the extension of game mechanics and server logic through a Lua scripting interface, enabling functionality changes without recompiling the core engine. The project includes tools for server administration via a remote console and world data management for analyzing statistics and optimizing save file storag

Nakama is a distributed server framework designed for real-time multiplayer games and social applications. It provides an authoritative runtime environment for executing game logic, ensuring consistent state and cheat-resistant gameplay across diverse client platforms. The system acts as a centralized backend, managing persistent player identities, social graphs, and real-time communication channels to support complex multiplayer interactions. The platform distinguishes itself through an integrated suite of LiveOps tools that allow developers to manage game economies, schedule time-bound even

This project is a browser-based, real-time multiplayer action game where players control a character on a 2D canvas to absorb objects and grow in size. It utilizes a Node.js game server and WebSockets to synchronize game state, player movement, and chat across all connected participants. The application is delivered as a dockerized game application, ensuring consistent hosting and deployment across different cloud environments through containerized server environments. The system implements an authoritative server model that processes all game logic and physics to prevent cheating and mainta

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

Fabric API is a modular framework designed for Minecraft mod development, providing a standardized set of hooks and libraries that enable the integration of custom content into the game. It serves as a foundational toolkit for injecting custom logic, assets, and networked data into the game environment during both startup and runtime phases. The framework distinguishes itself by facilitating interoperability between independent modifications through shared events and interface-based contracts, which allow different mods to interact without requiring direct dependencies. It manages the complex

This project is a first-person shooter template for Unity that implements networked gameplay, weapon systems, and player traversal. It functions as a multiplayer system designed to synchronize movements and actions between a server and clients via a network transport layer. The project serves as an example of high-fidelity game rendering using the High Definition Render Pipeline to deliver authored content and advanced visual quality. It also demonstrates the use of an entity component system to organize game data and logic for optimized processing and execution performance. The implementati

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

Turbulenz Engine is a cross-platform game engine and HTML5 framework designed for rendering graphics and simulating physics across desktop, mobile, and web environments. It functions as a WebGL graphics engine and a web-based physics engine, providing the necessary tools to build 2D and 3D games that run within browsers. The project includes a real-time multiplayer framework that synchronizes game states and player interactions between multiple users via server-side communication. This allows for the coordination of both real-time and asynchronous turn-based actions to maintain a consistent s

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

Craft is a multiplayer voxel sandbox written in C. It utilizes an OpenGL voxel engine to render a block-based world and implements an infinite terrain generator that uses noise functions to create deterministic, procedural landscapes. The project features a networked environment where players can build and modify a shared world using socket-based state synchronization. To maintain consistency across sessions, it employs a voxel world database to store and retrieve modified block coordinates. The system covers a range of capabilities including 3D collision detection for character movement, to

This project is a first-person shooter game engine and a pseudo-3D rendering engine written in C. It serves as a software framework for rendering three-dimensional environments and managing entity physics. The engine includes a networked multiplayer system designed to synchronize game state and player actions across a client-server network. It utilizes a portable codebase that allows game logic to be adapted across different operating systems and hardware architectures. Core capabilities cover 3D game engine architecture, including spatial partitioning and depth-based rendering. The system a

PartyKit is a serverless WebSocket backend platform for building real-time multiplayer applications. It provides a globally distributed edge computing runtime that runs stateful server code close to users, with automatic scaling and hibernation for idle rooms. The platform handles WebSocket connections, HTTP requests, and durable storage without requiring infrastructure management, and includes a client and server SDK with hooks, storage, and Yjs integration for building collaborative features. The platform distinguishes itself through per-room isolation using Durable Objects, where each uniq

Pomelo is a distributed Node.js game server framework designed for building scalable multiplayer game backends and real-time web applications. It employs a multi-process architecture to distribute application logic horizontally across a cluster of machines, enabling high concurrency and balanced network traffic. The framework utilizes a WebSocket communication layer to manage bidirectional data exchange between diverse web clients and server clusters. It incorporates a remote procedure call system for triggering functions across remote server processes and uses Protocol Buffers for binary ser

vcmi is an open-source game engine for Heroes of Might and Magic III that recreates the gameplay, logic, and rendering of the original strategy game. It serves as a cross-platform game runtime supporting Windows, Linux, macOS, Android, and iOS, providing a turn-based strategy simulator for strategic world map navigation and tactical combat. The project is built as a moddable game framework, featuring a data-driven modding system and a sandboxed Lua scripting integration. These allow for the definition of custom gameplay logic, spell effects, and the addition of new factions, characters, and a

jynew is a 3D RPG game engine and development framework designed for building three-dimensional role playing games. It provides a comprehensive suite of tools for scene editing, game logic scripting, and the creation of 3D environments. The project features a specialized 3D asset management pipeline for importing and aligning models and animations, including specific tools for weapon attachment and rendering. It includes a dedicated combat system editor for defining battle encounters, skill effects, and combat grids with real-time synchronization. Additionally, it provides a game modding fram

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

This repository is a comprehensive collection of functional 2D and 3D demo projects and implementation samples for the Godot Game Engine. It serves as an interactive tutorial and reference library, providing a working codebase to demonstrate how to apply engine features in real-world scenarios. The collection focuses on practical implementation guides, covering a wide array of technical capabilities from basic engine fundamentals to advanced rendering and scripting techniques. It allows users to study the application of node-based composition, asset pipelines, and game logic through direct ex

Serious Engine is an open-source framework designed for the development and execution of first-person shooter titles. It provides an integrated environment for rendering complex three-dimensional combat spaces and managing the core gameplay logic required for high-speed action sequences. The engine utilizes an entity-component-system architecture to manage game objects, supported by script-driven logic that allows for gameplay modifications without requiring engine recompilation. It distinguishes itself through a specialized rendering pipeline that separates geometry calculations from lightin

Romm is a self-hosted game library manager and ROM management web interface. It serves as a central server for storing and categorizing game files and emulator firmware, providing a web-based browser to organize collections through automated library scanning and metadata retrieval. The project distinguishes itself by integrating a web-based emulator frontend that uses WebAssembly to play games directly in the browser. It further provides a game save synchronization server that uses SSH-based synchronization to transfer save states and progress between the server and registered handheld device

This project is a real-time multiplayer chess platform designed to host competitive matches between users. It functions as a backend service that synchronizes board states and move data across connected client devices using bidirectional network communication. The platform distinguishes itself through an integrated competitive scoring engine that tracks player performance and updates skill rankings dynamically after each match. By combining this rating system with persistent user profiles, the platform maintains a record of individual game history and performance statistics across multiple se

This project is a World of Warcraft server emulator that simulates a multiplayer online game world, managing player data and game logic. It functions as a modular game server framework and an NPC AI and scripting engine, providing the necessary infrastructure to host a persistent virtual environment. The system is distinguished by a modular framework that allows for the extension of core engine behavior through isolated modules and function hooks without modifying the source code. It includes a structured SQL data layer for managing authentication, character states, and world environment sett

Scalable game server framework with clustering support and client libraries for iOS, Android, Unity and others through the C SDK.

TrinityCore is an open-source game backend and MMORPG game server emulator. It is implemented as a C++ game engine designed to handle real-time network traffic and game state synchronization, utilizing a MySQL database schema to store player profiles, inventories, and world state. The project provides the infrastructure necessary for MMORPG server hosting and private game server administration. It includes tools for game world customization, allowing for the modification of game mechanics, item statistics, and quest scripts. The system manages virtual world infrastructure through multi-threa