meshoptimizer: Mesh Optimization Library for GPUs
zeux/meshoptimizermeshoptimizer is a C/C++ mesh optimization library from zeux that makes triangle meshes smaller and faster for a GPU to render. Instead of one magic 'optimize' button, it hands you the individual algorithms — reindexing, vertex cache reordering, overdraw and fetch ordering, simplification, and quantization — that you run in a specific order over your own vertex and index buffers.
Reach for meshoptimizer if you're building a renderer or an asset pipeline and want to shrink and reorder meshes yourself with a small, dependency-free library you compile into your project. Skip it if you just want to optimize glTF files without writing code — use its companion gltfpack tool or a higher-level exporter — or if you don't have a GPU mesh pipeline to feed the output into.
The problem it solves
When a GPU draws a triangle mesh, several pipeline stages — running the vertex shader, rasterizing, fetching attributes from memory — get slower when the index and vertex data is laid out badly or carries redundant vertices. Fixing that by hand means reindexing, reordering triangles for vertex reuse, cutting overdraw, and packing attributes into smaller types, each of which is fiddly and easy to get subtly wrong. meshoptimizer exists to give you tested implementations of those steps so you don't hand-roll them per engine.
What is it?
meshoptimizer is an open-source (MIT) mesh optimization library written in C++ with a C-compatible header, so you can call it from C/C++ or from other languages over FFI. The README points to a meshopt crate for Rust and a meshoptimizer.js package on npm for JavaScript. It ships a documented pipeline of functions you apply in order — generate a vertex remap, optimize for the vertex cache, optionally reduce overdraw, optimize vertex fetch, quantize attributes, filter degenerate indices — plus meshlet generation for mesh shaders. A companion command-line tool, gltfpack, wraps these algorithms to optimize glTF files directly.
Why it's getting attention
meshoptimizer sits at around 8,075 stars, and it has become a common building block wherever meshes get processed. The evidence is in its reach: the README lists a Rust crate, an npm package, distro packages for Arch, Debian, FreeBSD, Nix and Ubuntu, plus vcpkg and Conan ports. The rise of mesh shaders and cluster-based rendering (its meshlet and clusterlod support) keeps it relevant for modern GPU pipelines rather than just legacy vertex-cache tuning.
Key features
- ✓Indexing and reindexing that removes redundant vertices via a generated remap table
- ✓Vertex cache optimization that reorders triangles to improve vertex reuse across GPU architectures
- ✓Overdraw and vertex fetch optimization to cut pixel work and improve memory locality
- ✓Mesh simplification for building LODs, including clustered simplification via the clusterlod.h header
- ✓Vertex quantization helpers (SNORM/UNORM integers, half floats) to shrink attribute storage
- ✓Meshlet generation (meshopt_buildMeshlets) for mesh-shader rendering on Turing/RDNA2-class GPUs
- ✓gltfpack companion tool that applies the library to glTF files from the command line
Best use cases
- •Optimizing meshes inside a game engine or renderer's asset-import pipeline
- •Compressing and optimizing glTF models for the web via the gltfpack tool
- •Generating meshlets so geometry can be drawn through a mesh-shader path
- •Building level-of-detail chains through mesh simplification
- •Reducing vertex-fetch bandwidth and storage by quantizing positions, normals, and UVs
How to install / try
meshoptimizer is a C/C++ library distributed as a header (src/meshoptimizer.h) plus source files (src/*.cpp). Clone a release with git: ``` git clone -b v1.2 https://github.com/zeux/meshoptimizer.git ``` You can build it with CMake or just add the source files for the algorithms you use to your own build. It's also packaged for several Linux distros and available as a vcpkg port and a Conan package. The gltfpack tool ships as a pre-built binary on the Releases page or via npm.
How to use
Include the header and call the algorithms in the recommended order (indexing, vertex cache, optional overdraw, vertex fetch, quantization, index filtering, optional shadow indexing). A single step looks like this: ```c++ meshopt_optimizeVertexCache(indices, indices, index_count, vertex_count); ``` The header is C-compatible even though the implementation is C++, and C++ template overloads let you use index types other than 32-bit unsigned int. For a no-code path, run the gltfpack CLI against a .gltf/.glb file instead.
Strengths
- ✓Small and dependency-free — you compile only the source files for the algorithms you actually use
- ✓MIT licensed, so it's safe to vendor into commercial engines and tools
- ✓C-compatible header means you can drive it from Rust, JavaScript, C#, and other languages over FFI
- ✓The recommended pipeline order is documented, so you're not guessing how the steps compose
- ✓gltfpack gives non-programmers and web workflows a ready-made way to use the same algorithms
Limitations & risks
- △It's a low-level library you integrate yourself: you call the right functions in the right order and need to understand vertex/index buffers and GPU pipeline stages
- △The core library is geometry-only — it does not handle textures or materials; that work lives in gltfpack or other tools
- △You add C++ source to your build system; there's no all-in-one 'optimize my model' function in the core API
- △Quantization only produces the packed data — you still have to configure the GPU vertex input (or dequantize on the CPU) to consume it correctly
- △Some steps are hardware-dependent (for example, overdraw optimization gives little benefit on tiled mobile GPUs), so you have to measure rather than apply everything blindly
Alternatives
Who should try it — and who should skip
Graphics, engine, and tools programmers building renderers or asset pipelines who want tested mesh-optimization algorithms they control, rather than a black-box exporter. If you don't write code against a GPU mesh pipeline, or you only need to optimize glTF files, the gltfpack tool (or a higher-level 3D toolchain) is the better entry point than the raw library.
Frequently asked questions
meshoptimizer is an open-source C/C++ mesh optimization library that reindexes, reorders, simplifies, and quantizes triangle meshes so a GPU can render them faster and store them in less memory. You call its algorithms in a documented order over your own vertex and index buffers.
Yes. It's released under the MIT license, which allows use in commercial and closed-source projects as long as you keep the license notice.
The header is C-compatible, so it works over FFI. The README points to a meshopt crate for Rust and a meshoptimizer.js package on npm for JavaScript.
meshoptimizer is the underlying C/C++ library of algorithms you integrate into your own code. gltfpack is a companion command-line tool that applies those algorithms to glTF files directly, with no code required, and also supports texture compression.
It reduces mesh size through simplification and vertex quantization, and provides vertex/index codecs and building blocks for compact storage. For full glTF file compression, gltfpack builds on top of it.