floooh/sokol
Sokol
Sokol is a C hardware abstraction layer and cross-platform graphics library designed for managing windowing, input, and audio across different operating systems. It functions as a GPU resource manager and multimedia application framework, providing a unified API for rendering 2D and 3D graphics across WebGL, Metal, Direct3D, and OpenGL.
The project is distinguished by its single-header implementation, which simplifies integration and portability. It utilizes a stateless render pass definition and a one-update-per-frame model to synchronize CPU data to GPU memory and manage resource lifecycles through descriptor structures.
Its broader capability surface includes GPU compute programming via compute shaders, asynchronous data fetching for files and network requests, and callback-driven audio streaming. The framework also covers system integration tasks such as user input processing, command line argument parsing, and the integration of immediate-mode user interfaces.
Additional tooling is provided for observability, including memory allocation tracking, frame statistics, and high-resolution execution time measurement.
Features
- Cross-Platform Graphics Tooling - Provides the core rendering backends and platform adapters to enable consistent 2D and 3D graphics across multiple operating systems.
- Graphics API Translators - Wraps multiple low-level graphics backends (Metal, Direct3D, OpenGL, WebGL) into a single unified C API.
- Cross-Platform Frameworks - Provides a unified C framework for managing windowing, 3D contexts, and input across multiple operating systems.
- Buffer Content Updaters - Copies data from system memory to GPU buffers and images using a controlled one-update-per-frame model.
- Resource Lifecycle Management - Manages vertex buffers, textures, and compute shaders using a one-update-per-frame model and descriptor structures.
- Frame-Synchronized GPU Updates - Synchronizes CPU data to GPU memory using a restricted one-update-per-frame window to prevent pipeline stalls.
- Resource Descriptor Definitions - Uses static descriptor structures to define GPU buffers and textures prior to hardware allocation.
- Stateless Render Pass Definitions - Defines rendering targets and attachment actions through configuration objects rather than sequential API calls.
- Backend-Agnostic Rendering Pipelines - Provides a backend-agnostic rendering pipeline that decouples C API logic from specific graphics APIs like Metal and OpenGL.
- 3D Graphics Pipelines - Provides a cross-platform architecture for geometric processing and 3D graphics pipeline execution.
- 3D Scene Renderers - Implements hardware-accelerated pipelines for real-time 3D scene visualization and geometry rendering.
- WebGL & GPU Rendering - Provides a unified API to execute WebGL commands and graphics state for 2D and 3D primitives.
- Multimedia Application Frameworks - Provides a comprehensive framework for integrating graphical windows, text rendering, and audio playback into interactive applications.
- Hardware Abstraction Layers - Provides a lightweight C hardware abstraction layer for managing windowing, input, and audio across platforms.
- Resource Lifecycle Management - Manages the creation and explicit destruction of immutable GPU objects using descriptor structures and resource IDs.
- User Input Processing - Handles system keyboard and mouse events to drive interactive graphical interfaces across platforms.
- Asynchronous Data Fetching - Implements non-blocking asynchronous data retrieval from local files and network requests.
- Storage Buffers - Provides mechanisms to pass large arrays of random-access data to the GPU for vertex pulling and instanced rendering.
- Real-Time Rendering Telemetry - Provides real-time telemetry, memory tracking, and frame statistics tools to monitor application performance.
- Single-Header Libraries - Distributes the entire library as a single-header C file to simplify cross-platform integration.
- Sample-Based Buffer Callbacks - Implements a callback-driven mechanism to feed PCM audio samples to platform backends for steady playback.
- Audio Playback Engines - Provides an engine for executing sound playback and managing audio streams within an application.
- Raw Audio Sample Streaming - Forwards mono or stereo 32-bit float samples to platform-specific audio backends using callback or push-based models.
- Pass State Management - Controls the rendering lifecycle through stateless render pass definitions and target action bindings.
- Instance Offsets - Supports rendering geometry from specific buffer sections using vertex and instance offsets without re-binding buffers.
- Compute Shader Dispatchers - Enables the dispatch and execution of general-purpose parallel processing tasks on the GPU using compute shaders.
- Text Rendering - Provides capabilities for rendering formatted text and custom fonts onto the screen.
- Texture Management Systems - Provides systems for loading and manipulating image formats, cubemaps, and 3D textures for surface mapping.
- Framebuffer Renderers - Supports rendering pixels directly to a memory buffer in direct-color or color-palette mode without a GPU.
- GPU Computations - Enables general-purpose data processing on the GPU using compute shaders and storage buffers.
- Cross-Platform Asynchronous I/O Abstractions - Offers unified, non-blocking interfaces for performing network and file I/O across different operating systems.
- Immediate Mode UI Frameworks - Integrates immediate-mode user interface libraries and custom overlays into the graphics pipeline for tools and debugging.
- Core Libraries and Runtimes - Cross-platform C/C++ libraries for graphics and compute.
- Graphics and Games - Cross-platform C/C++ graphics libraries.
