Bevy is a modular game engine built in Rust with an Entity Component System (ECS) at its core. It provides a complete 2D and 3D feature set including rendering, asset loading, audio, UI, animation, and physics systems. The engine uses a plugin-based architecture for extensibility and features a robust reflection system for runtime type inspection and serialization. Bevy emphasizes data-oriented design, productivity, and cross-platform support (desktop, web, mobile).
Flecs is a high-performance Entity Component System (ECS) framework for games and simulations, written in C99 with a C++17 wrapper. It provides a data-oriented storage model where entities are stored in archetype tables with component columns, enabling cache-efficient iteration. The framework includes a powerful query language with support for relationships, inheritance, traversal, grouping, and sorting. It features an extensive addon system covering systems (pipelines), observers, prefabs, reflection/meta, JSON serialization, an embedded scripting language (Flecs Script) with async/await, a REST API with an HTTP server, statistics/metrics, alerts, and more. Flecs has zero external dependencies and is designed for lockless multi-core scheduling. It is used in commercial games and has a large ecosystem of examples and community bindings. Architecture: The library is modular with a core C API and optional addons compiled via preprocessor flags. The C++ API provides a fluent builder pattern for constructing entities, systems, queries, and observers. Key entry points include ecs_init/flecs::world for world creation, ecs_progress for running the game loop, ecs_insert for entity creation, ecs_system for defining systems, ecs_query for cached queries, and ecs_script for running Flecs Script files. Data flows involve creating entities with components, which are stored in tables; systems iterate over matching entities each frame; observers react to component changes; and the script engine allows runtime entity manipulation. External dependencies: None. Flecs is self-contained and uses only standard C library functions.
The Open 3D Engine (O3DE) is a modular, open-source 3D game engine designed for developing AAA games, simulations, and interactive 3D content. It employs a component-based architecture with a core framework (AzCore, AzFramework, AzToolsFramework) and extensible gems for specialized functionality such as rendering (Atom), physics (PhysX), animation (EMotionFX), and UI (LyShine). The engine emphasizes data-driven design through reflection and serialization systems, and uses an event-driven communication pattern (EBus) for loose coupling between systems. Key architectural features include an entity-component-system (ECS) for game objects, a flexible asset processing pipeline that converts source assets into runtime-optimized formats, and a multi-platform rendering abstraction (RHI) supporting Vulkan, DirectX 12, and Metal. The engine provides extensive editor tools for content creation, including a scene editor, asset browser, and visual scripting system (ScriptCanvas). Cross-platform support is achieved through platform-specific trait files and abstraction layers, enabling deployment to Windows, Linux, macOS, Android, and iOS. The engine demonstrates strong engineering practices in its core systems: the EBus implementation offers a sophisticated, policy-based event bus; the reflection system enables serialization, behavior context binding, and editor integration; and the Interface pattern provides a flexible singleton mechanism. While the codebase shows signs of platform-specific duplication and some deprecated code, active maintenance and a clear modular structure help manage technical debt. O3DE is suitable for reuse in projects requiring a full-featured game engine or as a source of reusable patterns for engine development.
This repository is the `bevy_enhanced_input` library, a fully‑featured, observer‑based input management system for the Bevy game engine, inspired by Unreal Engine's Enhanced Input. It provides a component‑driven ECS architecture where actions, bindings, input conditions, and modifiers are all first‑class Bevy components or relationships. The system supports context layering (priorities, activity states), state synchronization, mocking for tests/cutscenes, and a built‑in preset system for common input patterns (e.g., WASD, gamepad sticks). At its core, the library defines the `InputAction` derive macro, the `InputCondition` and `InputModifier` traits, and an evaluation pipeline that runs during `PreUpdate`. Input reading is handled via a dedicated `InputReader` system parameter that also manages input consumption and ignoring. The library is `no_std` compatible and supports reflection and serialization via feature flags. The code is well‑structured with heavy use of Bevy's observer and relationship APIs, and includes extensive integration tests and a comprehensive set of examples ranging from basic action management to rebindable keybinding menus with persistence.
B3DFramework (namespace `b3d`, legacy `bsf` path prefixes) is a cross-platform C++17 game/application engine framework. Production code reveals a complete runtime: a scene/component model with ECS fragments, dirty-flag transform hierarchy propagation, prefab/scene serialization, async resource handles, and a plugin architecture with GPU backends (Vulkan, D3D12, Metal, Null), physics (PhysX), audio (FMOD, OpenAL), and a default renderer (RenderBeast). The engine implements its own shader language (BSL) with a compiling pipeline, a custom RTTI/reflection system with versioned binary serialization and delta compression, and a Mono-based C# scripting layer generated from C++ types via a codegen toolchain.
ecschedule is a production-grade CLI tool for managing AWS EventBridge scheduled tasks that trigger ECS tasks. Written in Go, it uses declarative YAML/JSON/Jsonnet configuration files with template functions for environment variables, tfstate lookups, and SSM parameters. The tool supports full lifecycle management: dumping existing rules, diffing local vs remote state, applying changes (create/update/delete), and manually triggering rules. It provides parallel execution for performance, unified diff output with color control, and a plugin system for tfstate and ssm integrations. The codebase demonstrates strong engineering practices: clean separation of concerns, comprehensive unit tests, CI/CD pipelines, and dependency management with dependabot. The architecture is a single-binary CLI with subcommands, leveraging AWS SDK v2 and a custom template engine that defers variable resolution for idempotent diffing. Notable design patterns include a generic parallel job executor with panic recovery and context cancellation, a 'localYAMLForDiff' normalization technique to avoid flapping diffs, and a Resource Groups search-based orphan rule detection using custom tags.
HashiCorp Consul is a distributed service mesh platform providing service discovery, health checking, dynamic configuration, and multi-datacenter federation. The codebase implements a full-stack system: a Go-based agent that runs as a server or client, a CLI tool for administration, a web UI built with Ember.js, and extensive gRPC/protobuf-based APIs for internal and external communication. The agent uses Raft consensus for state replication, maintains an in-memory database (memdb) for service and configuration state, and generates Envoy xDS configuration for service mesh gateways. Key entry points include the agent server (agent/consul/), CLI commands (command/), and the UI router (ui/packages/consul-ui/app/router.js). External dependencies include protobuf, gRPC, Envoy, and various cloud provider SDKs (AWS, Azure, GCP). The codebase is actively maintained with a large test suite covering unit, integration, and acceptance tests.
Yave is a C++20 Vulkan-based real-time graphics engine paired with a custom ImGui-driven editor and a self-contained core utility library named `y`. The repository is structured as three layers: `y` provides reusable containers, math, concurrency, IO, serialization, and a test framework; `yave` implements the engine itself (Vulkan device/window management, frame graph, render passes, ECS, asset pipeline, physics, animation, and scripting); and `editor` is a full 3D scene editor application with workspaces, widgets, gizmos, importers, thumbnails, and undo/redo. The renderer supports deferred PBR, cascaded shadow maps, TAA, bloom, SSAO/RTAO, RTGI, atmosphere scattering, and tone mapping, and it runs through a declarative frame graph with automatic resource pooling and barrier insertion. The editor is not a separate toy: it provides asset browsing, glTF/image import, material editing, scene outliner, inspector, file system views, performance metrics, GPU profiling, and RenderDoc integration. The engine uses a modern ECS with component groups, async asset pointers, and a serialization framework that supports schema evolution. The `y` library is particularly notable for its clean, high-performance primitives: SSO strings, flat hash maps with SIMD probing, sparse component sets, dependency-aware job system, and a forward/backward-compatible binary serialization layer. Externally, it depends on Vulkan, VMA, Volk, Dear ImGui, JoltPhysics, LuaJIT, tinygltf, stb, Tracy, and spirv_reflect, mostly vendored. While the project is described by its author as a learning/pet engine, the code is generally well-structured and professionally organized. However, it is a single-author codebase with many `Y_TODO` markers, some stubbed platform paths, global device singletons, and an explicit compiler-dependent serialization format. Tests exist mainly for the `y` core containers and math, not for the engine or editor. The repository is active and uses current C++/Vulkan practices, but should be treated as an evolving research-quality engine, not a stable library.
Convox Rack is a self-hosted platform-as-a-service that runs in an AWS account and manages the full lifecycle of containerized applications. The repository is a Go monolith with three coordinated surfaces: a CLI (cmd/convox), an HTTP/WebSocket API server (cmd/rack + pkg/api), and a generated Go SDK (sdk). All operations funnel through the Provider interface defined in pkg/structs/provider.go, and the main production implementation in provider/aws drives CloudFormation, ECS, ECR, DynamoDB, S3, KMS, SSM, CloudWatch Logs, SNS/SQS, and Lambda. In production, the rack creates per-app CloudFormation stacks, builds Docker images through ECS tasks, persists builds and releases in DynamoDB/S3, and promotes releases by updating stacks. Primary entry points are cmd/convox for the CLI, cmd/rack for the API server, cmd/monitor for background workers, and the Lambda functions under provider/aws/lambda for custom CloudFormation resources, autoscaling, instance lifecycle draining, and syslog forwarding. The CLI also supports local development mode via pkg/start and pkg/sync, which builds manifests in Docker and incrementally syncs files into running containers. The manifest layer has two generations: pkg/manifest1 handles legacy docker-compose-style definitions, while pkg/manifest implements the newer convox.yml format with flexible YAML parsing, NLB validation, timers, and internal/external port handling. The codebase contains substantial test infrastructure, including golden-output CLI tests, SDK contract tests, generated mock providers, and the awsutil request/response replay harness. However, it also has accumulated drift: two parallel manifest implementations, version-gated compatibility branches in the CLI/SDK, an embedded CA trust store from 2017, AWS SDK v1 dependencies, and some provider methods that remain unimplemented. Some tests are skipped or commented out. These factors keep the code from being exemplary, but the overall architecture is coherent, professional, and actively maintained. This is purely an application repository; there is no data-science or research component. The only data involved is operational state such as builds, releases, environment variables, and logs, stored in AWS services. Reusable pieces include generic TTL caching, order-preserving YAML unmarshalling, CloudFormation stack helpers, KMS envelope encryption, and a replay-based AWS test harness.
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.
Comedot is a Godot Engine 4.8+ framework for 2D game development that implements an Entity-Component-System architecture. It provides over 120 reusable components for gameplay mechanics including combat, movement, control, abilities, upgrades, inventory, turn-based systems, and UI elements. The framework emphasizes composition over inheritance, allowing developers to mix and match components to create entities for any 2D game genre. It includes template scenes for quick starts, editor plugins for component management, and extensive debugging tools. While actively maintained, the codebase shows signs of ongoing development with numerous experimental features and TODO comments indicating areas for improvement.
Container Tool Kit (CTK) is a web application that provides a visual editor for Docker Compose and Kubernetes manifest files. Users can create and manage projects by dragging and dropping services, volumes, and networks onto a canvas, editing node configurations through detailed forms, and viewing the resulting YAML/JSON in a synchronized code editor. The backend is built with FastAPI and PostgreSQL, handling project persistence, user authentication (JWT-based), manifest generation (including calling kompose for Kubernetes), and project import from remote YAML URLs. The frontend is a React/TypeScript single-page application using jsPlumb for the interactive canvas, Formik for form management, and Monaco Editor for code editing. The application supports both anonymous and authenticated usage, with features like autosave, visibility toggles, and pagination for project lists.
This repository provides a single, well-tested Bash script (`ecs-deploy`) that automates blue/green deployments on AWS ECS. It fetches the current task definition, creates a new revision with an updated Docker image tag, registers it, updates the ECS service (or directly runs a task), and waits for the deployment to complete. The script handles various edge cases: image name parsing (including domain, port, repository, tag, digest, and ECR-style URLs), role assumption, rollback, and cleaning up old task definition revisions. It is packaging-ready as a Docker image and includes a GitHub Action for CI/CD pipelines. The codebase is in maintenance-only mode but remains fully functional and widely used. Its primary reuse pattern is the standalone shell script itself—downloadable and integrable into any deployment pipeline. A hidden gem is the `parseImageName` function, which implements robust Docker image name parsing via regex and environment variable overrides, and the test suite (`test.bats`) demonstrates a clean pattern for unit-testing Bash functions while mocking external dependencies.