Open-source alternatives to Basic Computer Games

Battle for Wesnoth is an open-source turn-based strategy game set in a high fantasy world, built around hex-grid tactical combat. At its core, it is both a complete game and a game engine, offering single-player campaigns and multiplayer battles where players command faction-specific units across terrain that provides tactical advantages. The project is fundamentally a turn-based strategy game with a dedicated multiplayer platform, supporting online and local matches with replay recording and playback. What distinguishes Wesnoth is its deep commitment to custom content creation and modding. T

This project is a library of source code implementations designed to solve algorithmic challenges and mathematical problems. It serves as a collection of solved LeetCode problems, providing a reference for data structure usage and efficient logic. The repository is a polyglot code collection, implementing the same algorithmic logic across various programming environments, including general-purpose languages, SQL for database queries, and Bash for shell scripting. The content covers a broad range of computational tasks, including data querying, text processing, and the implementation of compl

LeetCode-Book is a curated study resource and markdown algorithm guide designed for technical interview preparation. It serves as a multi-language code library that provides solutions and explanations for coding challenges to help users study data structures and algorithmic principles. The project is delivered as a Docusaurus documentation website, which transforms a directory of version-controlled markdown files into a structured and searchable online technical resource. The repository covers an algorithm study workflow that includes tracking LeetCode problems and following curated study pl

NetHack is a roguelike dungeon crawler and ASCII-based role playing game. It is a turn-based adventure game featuring permanent character death and the exploration of randomly generated dungeons. The project serves as a cross-platform game engine designed to be compiled and run across diverse operating systems and hardware architectures. It focuses on retro game preservation by maintaining classic game logic for modern computing environments. The codebase implements procedural content generation for maps and encounters and utilizes a grid-based coordinate system for spatial tracking. Renderi

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

This project is an interactive programming education resource and tutorial designed for learning the Rust programming language and systems programming concepts. It provides a collection of runnable and editable code examples that serve as a practical reference for language syntax and implementation. The resource features an interactive code sandbox that allows users to execute and test code snippets in real time. It emphasizes the verification of technical accuracy by executing embedded code blocks during the build process to ensure all examples remain functional. The content covers a compre

WaveFunctionCollapse is a procedural generation engine that creates complex, non-repeating patterns by treating spatial arrangement as a constraint satisfaction problem. It functions as a stochastic solver that derives output structures from a single input example, ensuring that every element placed within a grid satisfies specific adjacency requirements relative to its neighbors. The system distinguishes itself by using an entropy-driven approach to grid collapse, where it iteratively selects the cell with the fewest remaining possibilities to trigger a cascade of logical updates. By decompo

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

This project is a library and educational resource providing implementations of foundational computer science data structures and algorithms written in JavaScript and TypeScript. It serves as a reference for executing standard sorting, searching, and recursive patterns using modern web technologies. The collection includes typed implementations for both basic containers, such as stacks, queues, and linked lists, and advanced organizational patterns, including trees, heaps, tries, and graphs. The material covers algorithmic analysis and problem solving through the use of Big O notation to eva

This project is a comprehensive educational repository providing study guides, a competitive programming curriculum, and technical interview resources. It serves as a reference for learning fundamental programming methods, algorithmic logic, and data structure implementations. The repository features multi-language implementation references that allow for the comparison of algorithmic solutions across different programming languages. This approach enables the analysis of performance and implementation details through cross-language code comparisons. The educational content covers computer sc

This project is a Lisp interpreter implementation guide and framework designed to teach the core principles of programming language design. It provides a structured, step-by-step technical framework for building a functional Lisp language from scratch, featuring a specialized interpreter engine and an S-expression parser that converts syntax into abstract syntax trees. The project emphasizes a code-as-data metaprogramming framework, enabling the implementation of macros, quoting, and quasiquoting to transform expressions during evaluation. It is designed with host language agnosticism, allowi

LogicStack-LeetCode is a curated repository of solved algorithm problems and data structure implementations, primarily drawn from the LeetCode platform. Its core identity is a structured collection of solutions designed to support technical interview preparation and competitive programming practice, with each solution accompanied by complexity analyses to help engineers understand performance trade-offs. The repository distinguishes itself through its breadth of coverage across fundamental algorithmic patterns and data structures. It includes implementations for array manipulation, string pro

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

xtensor is a C++ multidimensional array library for numerical computing that provides N-dimensional containers with an interface mirroring the NumPy API. It utilizes a lazy evaluation expression engine to defer numerical computations until assignment, which minimizes memory allocations and intermediate copies. The library features a foreign memory array adaptor that allows it to wrap external buffers, such as NumPy arrays, to perform numerical operations in-place without duplicating data. It further optimizes performance through lazy broadcasting and a system that manages the lifetime of temp

Graphite is a node-based visual design environment that integrates vector illustration, raster image processing, and motion graphics generation into a single platform. It utilizes a functional reactive pipeline and a data-flow execution model to propagate state changes through a graph of interconnected nodes, allowing users to construct complex, automated design workflows. The platform distinguishes itself through a context-aware evaluation engine that injects runtime metadata—such as coordinate data and loop indices—directly into the node graph. This enables the creation of procedural geomet

30-seconds-of-code is a comprehensive knowledge base and programming snippet library designed to support software engineering education and professional development. It provides a curated collection of reusable code units and technical guides that help developers master core language mechanics, design patterns, and architectural philosophies. The project distinguishes itself by offering a wide-ranging library of algorithmic solutions and web development patterns that are organized into modular, independently testable units. It emphasizes functional programming paradigms and declarative logic,

This project is a comprehensive, community-maintained knowledge base and toolkit designed for competitive programming. It serves as a centralized repository for algorithmic theory, data structures, and mathematical techniques, providing a structured reference for informatics and collegiate programming competitions. The project distinguishes itself by integrating educational content with a robust suite of automation utilities. It provides a complete workflow for competitive programming, including tools for automated test case generation, solution verification, and direct interaction with onlin

Carp is a statically typed Lisp compiler that compiles Lisp-like syntax directly to C source code, enabling seamless integration with existing C libraries and low-level system programming. It manages memory deterministically at compile time using ownership tracking and linear types, eliminating garbage collection pauses and runtime overhead while ensuring type safety through an inferred static type system. The language distinguishes itself through compile-time macro expansion and metaprogramming capabilities, allowing code generation and transformation before final binary output. It enforces

This project is a browser-based arcade game engine implemented in JavaScript. It provides a foundational framework for developing grid-based maze games, utilizing HTML5 canvas for immediate-mode rendering and structured data objects to define level layouts and item placements. The engine manages core interactive mechanics, including player navigation, collision detection, and real-time pathfinding for computer-controlled entities. It incorporates a state-machine game loop to handle transitions between active gameplay, paused states, and level progression, while tracking scores and item collec

FlappySwift is a side-scrolling arcade game implementation built for Apple platforms. Developed using the Swift programming language, this 2D game project features a physics-based environment where a player controls a character to avoid obstacles. The project utilizes the SpriteKit framework to handle rigid body dynamics, gravitational forces, and sprite-based rendering. Game flow is managed through a state machine that controls transitions between the start menu, active gameplay, and game over screens. The implementation covers 2D physics simulation, including bounding-box collision detecti

OpenSC2K is an open-source JavaScript city builder engine designed as a recreation of SimCity 2000. It functions as a web-based simulation that uses the Phaser 3 framework to implement game loops and entity management. The project utilizes WebGL and Canvas rendering to visualize large-scale urban environments. It includes a coordinate-based camera system that enables panning and zooming across the reconstructed game world. The engine incorporates a data pipeline to parse legacy city files and graphics assets, allowing it to reconstruct and display urban layouts within a modern web browser.

This project is a comprehensive knowledge base and study resource designed for mastering technical interviews. It provides structured guides, roadmaps, and curricula focused on data structures, algorithms, system design, and frontend engineering to help candidates prepare for software engineering screenings. The repository distinguishes itself by offering a holistic approach to professional advancement. Beyond technical drills, it includes a career development handbook covering resume optimization, salary benchmarking, and strategic negotiation coaching. It also provides detailed methodologie

This project is a JavaScript algorithm library and computer science reference. It provides a collection of standard computational logic patterns and data structure implementations, including linked lists, trees, and graphs, for both educational and practical use. The codebase serves as a technical interview study guide, offering a practical resource for practicing common coding challenges and data structure manipulations. It is designed for computer science education, allowing users to study how classic algorithms work by reviewing and running implementations of established logic patterns. T

This repository is a collection of common computer science algorithms and data structures implemented across multiple programming languages. It serves as an educational resource for students and developers to study fundamental computational logic and software engineering patterns through practical, version-controlled code examples. The project distinguishes itself by decoupling abstract problem definitions from their specific language implementations. This structure allows for direct cross-language comparison, enabling users to analyze how different syntax and programming paradigms handle ide

This project is an educational blog and learning resource dedicated to the Rust programming language. It provides a collection of curated guides, technical articles, and structured learning paths designed to teach language fundamentals, concurrency, and systems programming. The repository distinguishes itself by offering practical implementation tutorials for complex systems. This includes detailed guides on compiler development—specifically translating source code into targets such as ARM64, x86_64, LLVM IR, and WebAssembly—as well as networking examples for building multithreaded chat serve

This project is a technical interview study guide and computer science knowledge base. It provides a curated collection of technical interview questions and expert explanations focused on preparing for assessments at global IT companies. The repository serves as a coding interview roadmap for mastering algorithmic challenges and complexity analysis, alongside a software architecture reference for design principles and system design strategies. It also includes a web security curriculum covering authentication methods, cryptographic concepts, and common vulnerabilities. Content covers compute

Shipwright is a native execution engine designed to run decompiled legacy game code on modern hardware. It functions as a game engine execution layer that provides a high-performance environment for legacy logic while ensuring compatibility with current systems. The project features a pluggable graphics API wrapper that allows for switching between different rendering backends to ensure visual stability across various operating systems. It also includes a custom asset loader that imports external archive files to modify game content and add custom assets. Additional capabilities include an i