Projects sharing features with Gpu Io

This project provides a comprehensive toolset for WebGPU, serving as a graphics API wrapper, compute shader framework, resource manager, and shader toolchain. It enables browser-based GPU acceleration by offloading memory-intensive tasks and data processing from the CPU to the GPU. The framework manages the full lifecycle of GPU operations, from requesting physical hardware adapters and initializing logical devices to configuring programmable render and compute pipelines. It specifically supports the coordination of parallel workgroups and collective subgroup operations for general-purpose co

This library is a JavaScript framework for general-purpose computing on graphics processing units. It enables the execution of parallel mathematical operations directly within the browser by offloading data-heavy calculations to graphics hardware. The project functions as a web-based math accelerator that converts standard JavaScript functions into shader code for execution on the graphics processor. It provides a unified interface that detects available graphics APIs and manages data transfer between system and graphics memory. To ensure compatibility across diverse environments, the library

ogl is a WebGL graphics library and 3D scene graph engine designed for rendering three-dimensional scenes. It provides a lightweight framework for managing geometries and coordinating spatial transformations within a hierarchical system. The project includes a PBR shader system for creating realistic materials and a GPGPU computation framework for performing large-scale general-purpose calculations and particle simulations on the graphics processor. It also features a post-processing suite for applying visual filters to rendered scenes via frame buffers. The library covers broader capabiliti

Lenia is a scientific research tool and computational framework for modeling, visualizing, and analyzing artificial life. It functions as a continuous cellular automata engine that simulates emergent biological patterns using continuous space-time grids and kernel-based convolutional dynamics. The system leverages a GPU-accelerated simulation framework to perform parallel tensor computations and massive grid updates in real time. It includes hardware-accelerated 3D rendering to visualize high-dimensional cellular structures and their structural complexity. The platform provides capabilities

gpu.cpp is a lightweight C++ library for executing low-level general-purpose GPU computation across different hardware vendors and operating systems. It functions as a portable GPU wrapper, kernel orchestrator, and tensor management system using the WebGPU specification to abstract device initialization, buffer transfers, and compute shader dispatching. The library provides a framework for defining compute kernels from shader code and managing their asynchronous dispatch and synchronization. It enables the execution of cross-platform compute shaders and the orchestration of GPU tasks through

Cocos Engine is a cross-platform game engine designed for building high-performance 2D and 3D interactive experiences for web, mobile, and desktop platforms. It features a multi-backend rendering engine and a 2D and 3D physics simulator, utilizing a core architecture that combines a C++ runtime for performance with TypeScript for game logic scripting. The engine distinguishes itself through a multi-platform deployment system that packages projects for native operating systems and instant-play web ecosystems. Its graphics system supports multiple APIs, employing physically based rendering and

regl is a declarative WebGL library that manages graphics state and GPU resources through functional commands instead of manual binding and state tracking. It provides a command-based drawing abstraction where shaders, attributes, and render state are encapsulated into reusable, compiled functions that can be executed efficiently. What sets regl apart is its scoped state inheritance system, which allows nested drawing commands to inherit and override render state from parent scopes for organized rendering. The library automatically recovers from GPU context loss by restoring buffer and textur

The Book of Shaders is an interactive educational guide and curriculum for learning GLSL fragment shader programming to create procedural graphics and visual effects. It provides a structured learning path and a categorized reference guide for data types, built-in functions, and mathematical operations used in shader development. The project features a web-based shader sandbox and interactive editor that allows for real-time iteration and visualization of GLSL code. Users can experiment with procedural art and share their results via unique URLs. The curriculum covers a wide range of graphic

PhysX is a physics engine SDK designed for calculating real-time rigid body dynamics, fluid simulations, and environmental interactions in virtual applications. It includes a GPU-accelerated physics solver for computing complex particle fluids and combustion models, a voxel fluid simulator for real-time gas, fire, and smoke, and a destruction simulation framework for modeling the fracture of meshes. The SDK features a specialized machine learning physics tensor interface that enables the exchange of simulation data with machine learning frameworks using a common tensor format. It also impleme

VulkanTutorial is a comprehensive educational guide and instructional resource for implementing low-level rendering and compute pipelines using the Vulkan API. It serves as a GPU programming course and a step-by-step guide for building high-performance graphics applications from scratch. The project provides detailed instruction on the full graphics pipeline, including the compilation of shaders to SPIR-V bytecode, the configuration of rasterization states, and the implementation of 3D graphics pipelines. It also covers general-purpose GPU compute programming, focusing on the execution of par

This project is a high-level 3D graphics engine designed to render complex, hardware-accelerated environments within web browsers. It provides a comprehensive abstraction layer that manages scene graphs, cameras, and lighting, mapping high-level scene definitions onto low-level graphics APIs. By decoupling these definitions from specific hardware targets, the engine ensures consistent performance across diverse browsers and devices. The framework distinguishes itself through a robust architecture that includes a unified math library for high-frequency spatial calculations and a physically bas

ArrayFire is a hardware-agnostic compute framework and JIT-compiled tensor engine designed for high-performance numerical computing. It serves as a GPU numerical computing library and parallel signal processing toolkit that abstracts hardware backends, allowing the same codebase to execute across various GPU architectures and CPUs. The project distinguishes itself through a JIT engine that uses expression compilation to fuse operations and minimize memory overhead. It employs a deferred execution graph to optimize computation chains and provides interoperability primitives to share data and e

The compute runtime is a software layer that provides unified interfaces for parallel processing, kernel execution, and hardware-specific driver communication. It functions as a driver for OpenCL and OneAPI Level Zero, enabling the execution of data-intensive workloads across diverse graphics hardware architectures. The project distinguishes itself by maintaining consistent performance and compatibility across multiple generations of graphics hardware. It achieves this through a hardware abstraction layer that bridges high-level compute instructions with specific silicon capabilities, alongsi

This project provides Rust bindings for the TensorFlow C API, serving as a tensor computation interface and machine learning library. It enables the construction and execution of machine learning models and neural networks by bridging a systems language to high-performance backends. The framework supports GPU-accelerated computing to increase the speed of model training and inference by offloading mathematical operations to graphics processing units. It offers both graph-based computation for defining static network architectures and an eager execution mode for immediate operation calls durin

Hedgehog Lab is a browser-based scientific computing environment designed for executing numerical analysis, matrix operations, and symbolic computation directly within a web browser. It functions as a native engine for algebraic manipulation and equation solving, allowing users to perform complex mathematical tasks without requiring external server-side infrastructure or software installations. The platform distinguishes itself by leveraging hardware acceleration to process large-scale linear algebra and matrix calculations. It integrates a symbolic engine that parses mathematical expressions

Keras-js is a JavaScript inference engine and browser-based machine learning framework designed to execute pre-trained Keras neural networks. It allows for client-side model inference in web browsers or Node.js environments without the requirement of a backend server. The library utilizes a WebGL tensor accelerator to map mathematical operations to the graphics processor for hardware acceleration. To maintain user interface responsiveness during heavy computations, it incorporates a web worker inference runtime that executes neural network processing in background threads. The system support

Caffe is a high-performance deep learning framework and convolutional neural network library designed for training and deploying neural networks. It functions as a GPU-accelerated machine learning engine with a core implemented in C++ to enable high-throughput tensor operations. The project utilizes a declarative configuration system where model architectures and hyperparameters are defined in external text files, separating the network design from the execution code. It includes a model serialization system to export trained weights and topologies into binary files for efficient deployment a

Codon is an LLVM-based Python compiler and statically typed implementation that translates source code into optimized machine instructions. It functions as a high-performance numerical backend and a GPU computing framework designed to remove runtime overhead. The project implements a compiled alternative to NumPy, translating array logic directly into machine code. It differentiates itself by generating specialized hardware kernels for graphics processors and utilizing static type inference to enable aggressive machine-code optimization. The system provides capabilities for parallel workload

Gorgonia is a Go library that provides an automatic differentiation engine and a computation graph framework for building and training neural networks. It functions as a CUDA-accelerated tensor library and a SIMD-optimized math library, enabling machine learning workflows entirely within the Go ecosystem. The library distinguishes itself through a dual-backend architecture that dispatches neural network operations to either a GPU or CPU depending on CUDA availability at runtime. It constructs differentiable directed acyclic graphs of tensor operations, supports reverse-mode automatic gradient

Flux.jl is a deep learning framework and numerical computing toolkit written in Julia. It serves as a machine learning library for designing and training neural networks, providing a system for automatic differentiation to optimize model parameters. The framework enables deep learning development and machine learning research by representing layers as parameterized functions. It supports scientific machine learning, integrating neural networks into workflows for solving physical and mathematical problems. The toolkit provides native GPU acceleration for tensor computations and utilizes rever

Mistral Inference is a library for running Mistral large language models on a GPU, generating text from prompts with token streaming. It loads pretrained model weights from local disk or a remote registry into GPU memory, then produces output tokens one by one for real-time display in interactive applications. The library supports multimodal prompts that accept image URLs alongside text, enabling visual description and reasoning. It includes content safety guardrails that scan generated text against predefined policies to block or flag policy violations. For structured interactions, it provid

Chainer is an open-source deep learning framework built around define-by-run automatic differentiation, where computation graphs are constructed dynamically during forward execution. This imperative approach allows networks to be built using standard Python control flow, with gradients computed automatically through reverse-mode differentiation on the dynamically recorded graph. The framework supports GPU acceleration through a NumPy-compatible array backend with CUDA and cuDNN support, and provides a pluggable device abstraction that lets users switch between CPU and GPU computation without c

This project serves as a comprehensive educational resource for learning parallel programming and high-performance computing using graphics processing units. It provides technical guidance on the fundamental paradigms required to offload computationally intensive tasks from a host system to specialized hardware accelerators. The materials cover the core methodologies for managing data-parallel operations, including the orchestration of memory between host and device spaces and the organization of threads into structured grids and blocks. It details the execution models necessary to distribute

CUDA.jl provides a programming interface for executing custom kernels and performing parallel array computing directly on NVIDIA graphics hardware using the Julia language. It serves as a framework for compiling and scheduling user-defined functions across multiple processing cores, enabling high-performance data processing and task synchronization. The library distinguishes itself through a custom compiler backend that translates high-level language functions into hardware-specific machine code. It manages complex hardware interactions through asynchronous stream scheduling, unified memory m

GPU-Puzzles is an interactive learning environment and tutorial designed for mastering CUDA GPU kernel development. It serves as an educational tool and lab where users solve coding puzzles to understand how to map high-level logic to low-level GPU hardware instructions. The platform focuses on teaching parallel computing concepts and GPU architecture. Users practice developing parallel algorithms and managing GPU memory through a series of hands-on challenges. The environment utilizes a bridge between Python and CUDA to execute kernels and provide real-time feedback by validating outputs ag

This project is a PyTorch deep learning tutorial and educational resource. It provides a structured curriculum and step-by-step guides for designing, training, and validating neural networks from scratch. The resource includes specific guides on computer vision implementation, focusing on object detection and image classification using convolutional neural networks. It also provides instructions for optimizing model performance through hardware acceleration to reduce training time. The materials cover the full model development lifecycle, including tensor operations, image dataset preparatio