Term.jl is a Julia library for producing styled, beautiful terminal output. Inspired by Python's Rich library, it provides a markup language for inline color and style formatting (e.g., `{red}text{/red}`), a hierarchy of renderable objects (Panel, Table, Tree, Dendogram, ProgressBar), and interactive widgets (App, Menus, Pager, Buttons). The library also includes enhanced logging, stack trace rendering, progress bars, custom REPL display, and markdown rendering. Its architecture is modular: core types like `AbstractRenderable`, `Segment`, and `Measure` form the foundation, with composition via overloaded `*` (horizontal stack) and `/` (vertical stack) operators. A theme system centralizes styling. The codebase is well-tested with golden-file snapshots, but includes some platform-specific assumptions and absolute file paths in test fixtures that limit portability. Overall, it is a mature, feature-rich terminal UI toolkit with high craftsmanship.
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.
Cocos Creator engine runtime is a cross-platform 2D/3D game engine framework written in TypeScript and C++. It provides a component-entity architecture with scene graph, rendering pipelines (forward/deferred/custom), physics (PhysX, Bullet, Box2D, builtin), animation (marionette state machine, pose graph, Spine, DragonBones), audio, UI, particle systems, and asset management. The engine is designed to be used with the Cocos Creator editor but can run standalone. It abstracts platform-specific APIs (graphics, input, audio, system) behind a common interface, supporting Web, iOS, Android, Windows, macOS, Linux, and various mini-game platforms. Key entry points include the Director, Scene, Node, Component, and the rendering pipeline. External dependencies include graphics APIs (Vulkan, Metal, GLES, WebGPU), physics libraries (PhysX, Bullet, Box2D), and scripting engines (V8, SpiderMonkey, JavaScriptCore).
This repository is a comprehensive, step-by-step tutorial series for learning wgpu, the Rust implementation of WebGPU. It contains over 30 example crates organized into beginner, intermediate, compute, and showcase categories, each demonstrating a specific GPU concept (window creation, pipelines, buffers, textures, uniforms, instancing, depth, lighting, normal mapping, HDR, compute shaders, etc.). The code is production-quality Rust with extensive use of wgpu, winit, cgmath, and bytemuck. A reusable framework crate (`code/showcase/framework`) provides a `Demo` trait, camera, model/texture loading, and pipeline builders, which many showcases implement. The repository also includes a VuePress documentation site with embedded WebAssembly demos, build scripts for WASM deployment, and a demo server. While the tutorials are well-structured and educational, there is significant code duplication across crates (e.g., identical `build.rs` files, repeated initialization boilerplate), and some showcases are stale or excluded from builds. The codebase tracks wgpu API changes closely (news files document migrations from 0.12 to 30.0), but some patterns use deprecated APIs (e.g., `wgpu::Backends::PRIMARY`, `immediate_size` in pipeline layouts). Overall, it is a valuable learning resource with solid engineering practices, though not a production library.
SVGKit is a mature Objective-C library for rendering SVG files natively on Apple platforms (iOS, macOS, tvOS, watchOS, visionOS). It provides a full SVG 1.1 parser built on libxml2 SAX, an extensive DOM implementation (Core DOM + SVG-DOM) with CSS style support, and a CALayer-based rendering pipeline that converts SVG elements into Core Animation layers. The library offers two rendering modes: a fast bitmap-based view (SVGKFastImageView) and an interactive layered view (SVGKLayeredImageView). It also includes export utilities for rasterizing SVGs to NSData, UIImage, and NSImage. While functionally solid and widely used (over 4,500 stars), the codebase shows signs of age: many SVG features are stubbed with 'not implemented' assertions, the bundled CocoaLumberjack 2.2.0 is outdated, and there are code duplication and workarounds for Apple private class collisions. The architecture is modular with a plugin-based parser extension system, making specific components (like the path data parser, CSS value parser, and DOM node classes) potentially reusable in other contexts.
This repository hosts Google's official coding style guides for multiple programming languages (C++, Java, Python, Go, JavaScript, TypeScript, etc.) as well as supporting technologies (HTML/CSS, JSON, Lisp, Vimscript, etc.). It is a static documentation site with auxiliary tooling: JavaScript for dynamic table-of-contents generation and code block formatting, XSLT for transforming XML-based guides into interactive HTML pages, and editor configuration files (Emacs, Vim, Eclipse, IntelliJ). The repository contains no application runtime, API endpoints, or data processing pipelines. While the style guides themselves are the primary value, the code artifacts are simple, well-structured rendering helpers that can be adapted for other documentation projects. External contributions are not accepted, and some guides (e.g., the JavaScript guide) are explicitly deprecated, reflecting a maintenance model driven entirely by internal updates.
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.