PixiJS is a mature 2D rendering library for the web (npm package pixi.js). Its production purpose is to let developers build interactive scenes, games, visualizations, and creative applications using an object-oriented scene graph and render them through WebGL, WebGPU, or Canvas backends. The core runtime is a modular TypeScript library, not a monolith: users construct Containers, Sprites, Graphics, Text, Meshes, and ParticleContainers, then a renderer collects renderables into instruction sets, batches draw calls through backend-specific adaptors and pipes, and manages GPU resources such as textures, buffers, uniform groups, and render targets via pooling and garbage-collected caches. The repository also includes an asset subsystem with loader parsers, a resolver, a cache, and format detection, plus an extension registry that allows custom systems, loaders, pipes, filters, and backend adaptors to be registered cleanly. Primary entry points are src/index.ts, the Application class with initialization and plugins (ResizePlugin, TickerPlugin, CullerPlugin), autoDetectRenderer, and the Assets API. The library depends on browser platform capabilities (Canvas 2D, WebGL/WebGPU, OffscreenCanvas, Web Workers, fetch) and small npm packages; compressed-texture support shells out to Basis/KTX transcoders. Data flows are asset ingestion (fetch/parse/cache) and GPU command generation; there is no server-side pipeline or ETL component. The codebase shows strong engineering practice: typed extension points, backend abstraction layers, performance-conscious allocation management, dual GLSL/WGSL shader support, and an extensive test suite including snapshot-based visual regression tests across WebGL1, WebGL2, WebGPU, and Canvas. Some deprecation shims and experimental features exist, but the project is actively maintained with recent commits, release automation, and active issue triage.
Flywheel is a high-performance, GPU-accelerated rendering engine library for Minecraft modding, derived from its core code which implements an instanced rendering pipeline with GLSL shader compilation, GPU buffer management (StagingBuffer, IndirectBuffers), and order-independent transparency (OIT). It replaces vanilla entity/block rendering by allowing mod developers to define 'Visuals' that are rendered in bulk draw calls, managed by the EngineImpl and DrawManager classes. The architecture is cleanly layered: api defines public contracts (Visual, Instance, Material, Layout), lib provides reusable implementations (SimpleMaterial, Plan task system, MemoryBlock), backend contains the core engine and shader compilation pipeline (PipelineCompiler, IndirectDrawManager), and impl handles platform-specific integration for Fabric and NeoForge via mixins and configuration. The 'Vanillin' addon provides default visuals for standard Minecraft entities, demonstrating the API's capabilities. Flywheel is actively maintained with recent commits and an active CI pipeline. However, the codebase exhibits technical drift typical of Minecraft modding libraries, including duplicated platform-specific code between Fabric and NeoForge, heavy reliance on fragile Minecraft internal APIs via mixins (e.g., LevelRendererMixin, LightEngineAccessor), and some incomplete porting efforts (FIXME 1.21.11). Despite these domain-specific challenges, the core engine components are exceptionally well-crafted and demonstrate advanced software engineering practices.
cool-retro-term is a desktop terminal emulator that simulates the visual appearance of vintage cathode-ray tube (CRT) monitors. It renders a real terminal session (via QMLTermWidget) with a chain of GPU shader effects including scanline patterns, bloom, screen curvature, burn-in, chromatic aberration, and frame reflections. The application is built with Qt 6 (QML and C++) and runs on Linux and macOS. It provides a rich settings interface for customizing all visual parameters, and ships with 14 built-in retro profiles (e.g., Amber, Green, Commodore 64, Apple II) and a curated collection of bitmap fonts to match authentic terminal looks. Architecturally, the C++ layer handles font management (FontManager), font list models, file I/O, and the main entry point. The QML layer composes the terminal window, tabs, settings panels, and the shader pipeline. Shaders are pre-compiled into .qsb files for 48+ combinations of effect flags, enabling smooth runtime switching without compilation latency. Persistent settings are stored in SQLite via a thin QML wrapper (Storage.qml). The application uses two Git submodules: qmltermwidget for the actual terminal emulation and KDSingleApplication for single-instance enforcement. Key entry points include app/main.cpp (C++ startup), app/qml/main.qml (QML root), and the shader fragment files in app/shaders/. External dependencies are Qt 6, QMLTermWidget, and KDSingleApplication. The build system is qmake (with a planned but not yet executed migration to CMake). Packaging is provided for AppImage, DMG, Debian, RPM, and Snap.
Yasea is an Android live-streaming library and demo application that captures camera video and microphone audio, applies real-time GPU image filters, hardware-encodes to H.264/AAC via MediaCodec, muxes into FLV, and publishes over RTMP to servers such as SRS. The main entry point is SrsPublisher, which orchestrates SrsCameraView (an OpenGL ES preview surface), SrsEncoder (MediaCodec lifecycle and format negotiation), SrsFlvMuxer (FLV-over-RTMP publishing), and SrsMp4Muxer (simultaneous MP4 recording). The demo app (MainActivity) provides a working UI for URL entry, publish/pause, camera switching, recording, and filter selection. Architecturally, the repo is a Gradle project with two modules: a reusable Android library (library/) and a demo app (app/). The library is a monolith that bundles large vendored third-party codebases as source: Google's libyuv (native YUV/RGB conversion and scaling), mp4parser (ISO BMFF/MP4 parsing and authoring), simple-rtmp (RTMP client protocol), and MagicCamera (40+ GPU image filters with GLSL shaders). The repo's own code is the net.ossrs.yasea package, which integrates these pieces: camera frames flow through the GLSurfaceView filter chain as RGBA, are converted to I420/NV12 by the libenc JNI bridge (libenc.cc wrapping libyuv), encoded by MediaCodec, and muxed to FLV/MP4. Audio is captured via AudioRecord and encoded to AAC. Despite a recent commit, the codebase is frozen in the 2017-2020 Android era: compileSdk/targetSdk 26, Android support library 26.1.0, the deprecated Camera API, Gradle 6.5 with AGP 4.1.1, and a mips ABI that modern NDKs no longer support. The native build is commented out in library/build.gradle, and 285 open issues remain. Technical drift is high. This is purely an application/library repo - no data pipelines, notebooks, or research components.
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.