raylib is a cross-platform game development library written in C99, designed to provide a simple and easy-to-use API for creating games, prototypes, and multimedia applications. It abstracts away platform-specific details like window creation, input handling, and graphics rendering, offering a consistent interface across Windows, macOS, Linux, Android, and Web (via Emscripten). The library is modular, with core modules for shapes, textures, text, 3D models, audio, and shaders, all built on top of a low-level OpenGL abstraction layer (rlgl). It bundles its own windowing backend (a fork of GLFW) and includes numerous single-file external libraries for image loading (stb_image), audio decoding (dr_flac, dr_mp3, dr_wav, jar_mod, jar_xm), compression (sdefl, qoa, pep), and model loading (tinyobj_loader, cgltf, vox_loader). The repository contains over 200 example programs that serve as both documentation and test cases, covering everything from basic window creation to advanced shader effects and 3D rendering pipelines. The architecture follows a monolithic library pattern with a single public header (raylib.h) and several optional headers (raymath.h, rlgl.h, raygui.h). The core library is compiled from source files (rcore.c, rshapes.c, rtextures.c, rtext.c, rmodels.c, raudio.c) and platform-specific backends (rcore_desktop_glfw.c, rcore_android.c, rcore_web_emscripten.c, etc.). The library is designed to be self-contained, with no external runtime dependencies beyond the operating system's graphics drivers. Build system support includes CMake, Make, Zig, Meson, and IDE project files for Visual Studio, VSCode, CodeBlocks, and others. Key data flows involve initializing a window and graphics context, then entering a game loop where user input is polled, game state is updated, and rendering commands are issued. The library handles resource management (textures, fonts, models, audio streams) internally, with automatic cleanup on window close. The audio subsystem supports streaming, effects, and multi-channel playback. The shader system allows custom GLSL vertex and fragment shaders to be applied to 2D and 3D rendering. The library also includes utility modules for math (vectors, matrices, quaternions), easing functions, gesture recognition, and camera systems. External dependencies are minimal due to extensive bundling; the only required system libraries are OpenGL (or OpenGL ES on mobile/web) and the platform's native windowing/input APIs. The bundled GLFW fork provides a consistent windowing layer across platforms. The library is actively maintained with regular commits, CI builds for multiple platforms, and a large community of users and contributors.
Inspira UI is a curated collection of beautifully designed, copy-paste-ready Vue/Nuxt UI components, inspired by Aceternity UI and Magic UI. The repository serves both as a component library and a documentation/demo site built with Nuxt 4, Tailwind CSS v4, and a rich ecosystem of animation and WebGL libraries (motion-v, Three.js, OGL, GSAP). The architecture is a standard Nuxt application with i18n (English, French, Chinese), content management via @nuxt/content, and a custom registry system that generates component metadata for CLI installation. Key entry points include the Nuxt configuration (nuxt.config.ts), the app configuration (app.config.ts) for UI theming, and the registry build script (scripts/build-registry.mts) that crawls component files and produces Zod-validated schemas. The primary data flow is static: markdown documentation files in content/ are rendered alongside live interactive playgrounds that allow users to tweak component props via DialKit config panels. External dependencies are heavy but modern, including motion-v for spring animations, Three.js/OGL for WebGL effects, canvas-confetti for particle effects, and @vueuse/core for utilities. The codebase demonstrates consistent patterns (barrel exports, cn() class merging, shader-based backgrounds, context injection for compound components) and a strong emphasis on visual polish and developer experience.
butterchurn is a browser-based, real-time music visualizer that faithfully reimplements the classic MilkDrop visualizer using WebGL2. It consumes audio from the Web Audio API, runs FFT analysis to derive frequency/amplitude data, and drives a shader-based render pipeline from JSON presets that encode MilkDrop-style equations. The core library exposes a minimal `createVisualizer()` entry point, after which consumers load a preset and call `render()` with audio level data each animation frame. The library supports two equation execution paths: a JS-based expression runner and a WebAssembly/AssemblyScript-based EEL runner, with a custom Rollup plugin that compiles AssemblyScript to base64-encoded WASM at build time. It also includes deterministic seeded RNG for reproducible rendering, which is used by its visual regression test suite to compare JS and WASM paths pixel-for-pixel across a curated set of presets.
The Universal Transition Shader is a Godot shader that provides a wide variety of transition effects (wipes, fades, masks, shapes, and clock wipes) with extensive customization options. It uses a grid system to allow for complex patterns like staggering, mirroring, and cell-based animations. The shader is self-contained and can be applied to any CanvasItem in Godot, making it a reusable tool for game developers and creators.
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.
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 is the source code for the webgl2fundamentals.org educational website, a comprehensive, multi-language tutorial series for WebGL2. It is not a standalone application or library, but a static site built from markdown lessons and hundreds of interactive HTML/JavaScript example pages. The code includes reusable utility libraries for matrix math (m4.js, 3d-math.js), WebGL boilerplate (webgl-utils.js), lesson helpers, and a sophisticated interactive WebGL state diagram tool. The build system uses Grunt and custom lesson builders to generate the site. While the core educational content is well-maintained and pedagogically sound, the repository contains some legacy code (tdl library, old jQuery plugins) and many partially translated lessons, indicating ongoing maintenance but with some technical debt.
Animite is an unofficial Android client for AniList (with partial MyAnimeList support) for tracking anime and manga. The application is built with a modern Android stack: Kotlin, Jetpack Compose, Material3, Apollo Kotlin (GraphQL), Ktor (REST), DataStore, Hilt, and Coil. It features a multi-module architecture with clear separation of concerns: API layers, core UI components, navigation, and feature modules (explore, profile, media, settings, social, anime, manga, banner). The app supports browsing, searching, filtering, detailed media pages with dynamic theming (time-of-day based banner), user profile management, and list editing with drag-and-drop reordering. The codebase demonstrates strong modularity and reusable UI patterns, though it relies heavily on experimental Compose APIs and has a few code quality concerns (e.g., hardcoded credentials, large screen files, alpha version instability).
This repository is an extensive collection of over 500 standalone shader examples, compute shader implementations, and supporting C# scripts for Unity, authored by Przemysław Zaworski. It covers a wide breadth of real‑time graphics techniques including raymarching, procedural texture generation, vertex/tessellation/geometry shaders, compute‑based physics, image post‑processing (bloom, HDR, SSAO), fluid simulation, grid‑based simulations (Voronoi, Marching Cubes), and advanced rendering like DirectX Raytracing path tracing. The codebase is primarily educational and demonstrative; each file typically implements a single effect or technique in a self‑contained manner, often with references to original Shadertoy sources, ReShade conversions, or published papers. While many examples are functional and well‑structured, others include incomplete fixes or stale comments, and overall the repository serves as a large reference library rather than a production application. The quality is average—many components are boileplate‑heavy ports—but several pieces, such as the Marching Cubes compute shader with indirect draw, the multipass fluid simulation, and the volume rendering tools, exhibit solid craftsmanship and are extractable for reuse.
This repository is a curated list of open-source Unity projects and tools, organized by categories such as shaders, editor extensions, UI components, scripts, mobile plugins, and more. It contains no source code itself; it serves as a directory of links to external repositories. The list is comprehensive and well-organized, making it a valuable resource for Unity developers seeking reusable components, learning materials, and inspiration. However, as a list, it does not demonstrate any code craftsmanship, architecture, or reusability of its own.