thehardwarestore.ai

Pixelorama is a full-featured open-source pixel art editor built with the Godot Engine (GDScript). It provides a professional-grade environment for creating pixel art, sprites, tiles, and animations. The application includes a rich set of drawing tools (pencil, line, curve, shape tools, bucket, gradient, shading), selection tools (rectangle, ellipse, lasso, magic wand, color select), and a comprehensive layer system supporting pixel, group, tilemap, 3D, and audio layers. Animation is handled through a timeline with keyframe interpolation, onion skinning, and frame tags. The editor supports a variety of import and export formats including Aseprite, Krita, Photoshop, Piskel, PNG, GIF, APNG, MP4 (via FFmpeg), and its own .pxo project format. It features a dockable UI, customizable shortcuts, extension support, shader-based non-destructive layer effects, and a built-in noise generator and gradient editor. The codebase demonstrates a well-structured tool inheritance hierarchy, a robust undo/redo system, and several reusable custom UI widgets and addons.

GB Studio is a production-grade Electron desktop application for creating Game Boy and Game Boy Color games without writing code. It is a full visual IDE: scene and tilemap editors, sprite/metasprite editor, a music tracker with piano roll and instrument editing, a script event system (event definitions compile to GBVM bytecode), asset management for backgrounds/sprites/tilesets/fonts/sounds, and a debugger with ROM usage analysis. A separate web app (GBS Music) shares core music logic and offers a standalone browser-based tracker. The application is architecturally substantial: the Electron main process hosts multiple isolated renderer windows (splash, project, music, preferences, plugins), the renderer uses React 19 with Redux Toolkit for normalized entity state, Web Workers offload image processing and background scans, and a shared lib layer is reused across desktop and web builds.

FXGL is a mature, feature-rich game development framework for the Java Virtual Machine, built on JavaFX. It provides a comprehensive Entity-Component-System (ECS) architecture with integrated 2D physics (Box2D port), A* pathfinding, particle systems, animation DSL, input handling, networking (TCP/UDP), localization, mini-games, and a dialogue/cutscene system. The framework emphasizes rapid prototyping via a fluent DSL (Kotlin/Java) and includes extensive sample applications. It also offers developer tools like a dialogue editor, in-game profiler, and debug console. While primarily a 2D engine, it includes basic 3D support. The codebase is well-structured with modular Maven modules, extensive unit tests, and a service-oriented design.

Luban is a game configuration solution that transforms structured data (Excel, JSON, YAML, Lua, XML, etc.) into strongly-typed code and serialized data for multiple target languages (C#, Java, Go, C++, Rust, Python, TypeScript, Lua, etc.) and data formats (binary, JSON, protobuf, flatbuffers, msgpack, BSON, etc.). It is implemented as a .NET 8 console application with a plugin-based pipeline architecture: schema loading → data loading → validation → code generation → data export. The core engine (Luban.Core) provides extensible interfaces for custom loaders, validators, code targets, and data targets, all discovered via assembly attributes. Code generation uses Scriban templates with language-specific extensions, and data serialization employs a custom compact binary protocol (ByteBuf). The tool is widely used in game development for managing configuration data across engines like Unity, Unreal, Godot, and Cocos.

FishNet is a comprehensive Unity multiplayer networking framework providing a full client-server architecture with RPCs, sync types, prediction, scene management, observer conditions, and multiple transport backends (LiteNetLib, Synapse, Yak). It employs IL code generation via Mono.Cecil to auto-generate serializers and RPC stubs, achieving high performance and low bandwidth usage. The codebase is well-structured with extensive use of partial classes, pools, and utility patterns. It includes demos for authentication, prediction, collider rollback, and scene management. While the framework is tightly coupled to Unity, many utility components (e.g., object pooling, ring buffers, quaternion compression) are reusable in isolation and demonstrate strong engineering craftsmanship. The project is actively maintained with a large community and regular commits.

This is a Rust library implementing the Polyanya any-angle pathfinding algorithm on navigation meshes. It provides a core `Mesh` struct that supports 2D and 3D pathfinding with multiple overlapping layers, agent radius, and path simplification. The library includes several input formats: custom `.mesh` files (v2/v3), Recast JSON navigation meshes, triangulated meshes from outer edges and obstacles (via CDT), and trimesh files. It features an optimized A* search with chained expansions, geometric predicates for cone clipping and vertex snapping, and precomputed BVH for efficient point location. The repository contains extensive benchmarks, fuzz tests, and example binaries (including a scenario runner and traced profiling examples). It is structured as a reusable library with optional features like async, serde, stats, tracing, and Recast import. The code demonstrates strong engineering practices with careful handling of floating-point edge cases and performance-critical sections using `SmallVec` and `unsafe` indexing.

Dora SSR is a production-grade cross-platform game engine designed for rapid development directly on target devices (mobile, desktop, web). The engine is a monolithic C++ core that provides 2D/3D rendering (bgfx), physics (JoltPhysics, PlayRho, Box2D), audio (SoLoud, libopenmpt), animation (Spine, DragonBones), UI (Yoga layout), and a full scene graph. It exposes scripting via multiple languages: Lua (with a custom binding generator), TypeScript (compiled to Lua via a vendored tstl fork), WebAssembly (via wasm3), Rust (via FFI), and C# (via P/Invoke). A built-in Web IDE (React/Monaco-based) allows coding and debugging from a browser on the same network. The engine also includes an AI coding agent with memory, skill tools, and preview session management, integrated into the IDE workflow. Over 50 CI workflows build for Android, iOS, Windows, macOS, Linux, and Web (Emscripten).

MethaneKit is a cross-platform graphics rendering framework that provides abstractions over DirectX 12, Vulkan, and Metal APIs. It features a layered architecture with platform-independent interfaces (RHI), platform-specific implementations, an application framework, UI components, and mathematical utilities. The framework includes tutorial applications demonstrating various graphics techniques from basic triangle rendering to compute shaders and parallel rendering. Key systems include resource management, command submission, pipeline state handling, and synchronization primitives. The codebase demonstrates modern C++ practices with extensive use of templates, PIMPL idiom, and interface-based design.

ggez is a lightweight, cross-platform 2D game framework for Rust, inspired by LÖVE. It provides a comprehensive set of subsystems for graphics, audio, input, filesystem, and timer management, all accessible through a central `Context` object. The framework abstracts over `winit` for windowing and events, `wgpu` for GPU rendering, `rodio` for audio playback, and `gilrs` for gamepad support. The architecture is modular, using sub-contexts (e.g., `GraphicsContext`, `AudioContext`) that can be individually accessed via `Has`/`HasMut` traits, allowing for custom context composition. The graphics pipeline supports 2D and optional 3D rendering (behind a feature flag) with shaders, meshes, images, instanced drawing, and text rendering via `glyph_brush`. The filesystem uses a virtual filesystem (VFS) layer with physical directories and zip archives, and configuration is handled via TOML serialization. Key entry points include `ContextBuilder` for initialization, `EventHandler` trait for the game loop (with `update`, `draw`, and input callbacks), and the `event::run()` function to start the application. Data flows are event-driven: user input is collected by `winit` and forwarded to the event handler, while rendering commands are batched and submitted to the GPU each frame. The framework also includes built-in coroutines for asynchronous tasks without futures. The repository contains over 40 examples demonstrating all major features, from simple drawing to complex 3D scenes and shader effects. ggez is actively maintained with a stable API, though some parts (e.g., 3D support, coroutine implementation) are less mature. The codebase demonstrates good engineering practices: builder patterns, resource caching, buffer sub-allocation, and a clear separation of concerns. It is suitable for hobby game development, educational projects, and rapid prototyping. The heavy reliance on evolving crates like `wgpu` and `winit` introduces some technical drift, but the framework keeps pace with updates.

bevy_light_2d is a Rust library providing 2D lighting functionality for the Bevy game engine. It implements point lights, spot lights, light occlusion (shadows), and ambient lighting through a multi-pass rendering system using signed distance fields (SDF) and ray marching. The architecture follows Bevy's ECS pattern with a plugin that integrates into the render graph, separating extraction, preparation, and rendering phases. The library demonstrates solid software engineering practices with clear separation of concerns and implements non-obvious graphics techniques for efficient shadow calculation.

Alimer is a modern cross-platform .NET 10 game engine featuring a modular architecture with Entity-Component-System (ECS) design, multi-backend graphics rendering (Vulkan, Direct3D 12, Metal), physics integration, audio subsystem, and asset pipeline. The engine provides a complete framework for game development with systems for rendering, physics, audio, input, and scene management. It follows a layered architecture where platform-specific implementations are abstracted behind clean interfaces, allowing developers to build games that run on Windows, Linux, and macOS. The codebase demonstrates strong engineering practices with well-defined boundaries between systems, extensible asset importing, and backend-agnostic graphics abstractions.

TileMapLayer3D is a Godot Engine 4.5+ editor plugin for creating 3D tile-based levels from 2D tilesheets. It provides tools for manual placement, auto-tiling, sculpting, vertex editing, animated tiles, and mesh baking. The plugin integrates deeply with Godot's editor and runtime systems, using a modular architecture with separate managers for different functionalities (placement, selection, autotile, animation, sculpt, vertex edit). It stores tile data in columnar arrays for efficiency and uses region-based spatial partitioning for performance. The plugin includes demo scenes and is actively maintained with recent updates.

This repository is the official collection of Godot Engine demo projects, maintained by the Godot Foundation. It contains hundreds of self-contained, runnable demo projects that showcase specific engine features across 2D, 3D, audio, GUI, networking, XR, mobile, compute shaders, and editor plugins. Each demo is a standalone Godot project with its own project.godot, scenes, scripts, and assets. The repository serves as both a learning resource for developers and a testbed for engine capabilities. While not a single application, it demonstrates a wide range of game development patterns and engine APIs. Notable highlights include a generic state machine implementation, a 2.5D node system, a virtual joystick for touch input, a custom logger with UI integration, and a JSON-driven dialogue system. The codebase is actively maintained with recent commits, low technical drift, and consistent use of modern Godot 4.x APIs.

This repository contains the source code and assets for ActionRoguelike, a roguelike action game built with Unreal Engine 5. The game features procedural enemy spawning, a variety of player actions (such as dashing, magic projectiles, and parrying), and performance-optimized systems for managing actors and significance. The codebase is organized into modular subsystems, including AI, action systems, core game mechanics, player controls, and UI. The architecture follows Unreal Engine best practices, with clear separation of concerns. Notable reusable systems include a custom action system that allows developers to define and manage player abilities, and an actor pooling subsystem that optimizes performance by reusing instances of frequently spawned objects. The project also implements a save system for persisting game state and a significance system to prioritize updates for important actors. While the project is tailored to a specific roguelike game, several of its systems are designed with reusability in mind. The ActionSystem and Performance modules, in particular, could be extracted and adapted for use in other Unreal Engine projects with minimal modification. The recent commit activity indicates active maintenance, and the use of a recent Unreal Engine version suggests low technical drift. Overall, the codebase demonstrates solid engineering practices and provides a foundation for learning and building similar action-oriented games in Unreal Engine.

This repository is a desktop application for game content creation, specifically designed for a Genshin Impact-like game. It provides a node-based visual scripting system (Graph Code) where users create logic using interconnected nodes representing game functions (combat, skills, UI, etc.). The application features a PyQt6-based GUI for graph editing, resource management, and previewing, along with automation capabilities for OCR, screen capture, and input simulation to interact with the editor. It includes a robust validation engine to ensure graph correctness, a layout engine for auto-arranging nodes, and export pipelines to produce game-ready formats (.gil and .gia). The architecture is monolithic with distinct modules for the GUI (app/ui/), automation (app/automation/), core engine (engine/), and CLI tools (app/cli/ and private_extensions/ugc_file_tools/). Key entry points are the main GUI launcher (app.cli.run_app), validation CLI (app.cli.graph_tools), and the unified UGC tools CLI (private_extensions/ugc_file_tools). Data flows involve graph creation/editing, validation, layout, export/testing, and automation-driven interactions. External dependencies include PyQt6, RapidOCR (onnxruntime), OpenCV, Pillow, and keyboard/mouse libraries for automation.

Godot-Secure is a set of Python scripts that automatically modify the Godot Engine source code to integrate enhanced encryption (AES-256 or Camellia-256) with a unique security token system. The scripts generate random magic headers, a 32-byte security token embedded in the engine binary, and optionally apply advanced key derivation formulas or scramble the GDScript tokenizer buffer to prevent decompilation. The tool is designed to be run once before compiling a custom Godot engine build, making each build cryptographically unique and resistant to generic decryption tools. The codebase demonstrates solid engineering with declarative modification definitions, backup creation, and detailed logging, though it is tightly coupled to the Godot source structure.

Open Tournament is a first-person shooter game built on Unreal Engine, inspired by classic arena shooters like Unreal Tournament and Quake. The game implements comprehensive systems for player movement, combat, AI, user interface, audio, and networking. It features a modular architecture using Unreal Engine's plugin system, with extensive use of the Gameplay Ability System (GAS), Enhanced Input, and replication for multiplayer functionality. The codebase shows thoughtful architectural design in several reusable systems, particularly in settings management, UI composition, messaging, and loading screen handling.

Razix is a multi-platform 3D game engine built in C++ with a focus on modern graphics APIs (Vulkan, DirectX 12, OpenGL). It features a custom rendering hardware interface (RHI), a frame graph system for efficient render pass scheduling, an entity-component system (ECS) for scene management, and a built-in editor with ImGui integration. The engine includes a Lua scripting system, physics integration via Jolt Physics, and a comprehensive memory management layer with custom allocators. Despite its ambitious scope and active development, the codebase exhibits a mix of well-engineered subsystems and areas of legacy code (e.g., LIMBO_STATE). The project provides testing frameworks for both engine core and graphics pipelines, and maintains a dedicated game project ('Tanu') as a showcase.

This repository is a collection of custom macros and systems for Twine/SugarCube 2, a popular interactive fiction authoring tool. It provides reusable components that extend SugarCube 2's functionality, including inventory systems, timekeeping cycles, dialog boxes, notifications, meters, speech boxes, event handling, and various UI enhancements. The architecture consists of individual JavaScript files implementing specific macro systems, with a build process that minifies them for production use. The macros interact with SugarCube 2's state and DOM APIs to modify story behavior and presentation. Key entry points are the macro definitions themselves, which users include in their Twine story's JavaScript section. The system demonstrates solid engineering practices with well-encapsulated components, proper event handling, and thoughtful API design.