# Blend2D: 2D vector graphics with a JIT-compiled rendering pipeline

> Blend2D is a C++ library that generates machine code at runtime to accelerate 2D vector rendering. It ships with 4 built-in image codecs, TrueType and OpenType font support, and a SIMD abstraction layer, but depends on AsmJit, which must be cloned as a separate step.

**blend2d/blend2d** — 2D Vector Graphics Engine Powered by a JIT Compiler

- Repository: https://github.com/blend2d/blend2d
- Website: https://blend2d.com
- Stars: 1,997 · Forks: 162
- Language: C++
- License: Zlib
- Published: 2026-10-09 · Updated: 2026-10-09 · Language: en
- Canonical page: https://hysenlabs.com/projects/blend2d-blend2d

## JIT pipeline and reference pipeline: 2 implementations, 1 optional dependency

The pipeline directory in the Blend2D source tree carries 2 distinct implementations: a reference renderer and a JIT renderer that generates native machine code at runtime. AsmJit is required only when the JIT path is compiled in, so a project that does not need runtime code generation can omit that dependency entirely and build against the reference path alone.

When JIT is active, AsmJit emits native instructions for the target CPU at render time, replacing a fixed sequence of pre-compiled code with something tuned to the hardware present. AsmJit supplies the code generation mechanism, and Blend2D supplies the rendering logic that drives it. This separation keeps AsmJit as an optional guest: you bring it in when you need its output and leave it out otherwise.

The 3rdparty directory at the repository root is the designated landing spot for AsmJit. Its purpose in the layout is to hold that one clone, and the CMake build looks there when JIT compilation is enabled. A build without AsmJit present still produces a working library; the reference pipeline is available regardless of whether the JIT path is configured.

## AsmJit goes in 3rdparty as a manual clone, with no submodule coordination

Getting both projects onto disk takes 2 clone commands. First you clone Blend2D, then you clone AsmJit into a specific subdirectory inside it.

```bash
$ git clone https://github.com/blend2d/blend2d
$ git clone https://github.com/asmjit/asmjit blend2d/3rdparty/asmjit
```

The top-level directory entries include no .gitmodules file, so this is not a Git submodule arrangement. Each project's master branch advances on its own schedule, which means pulling one can break compatibility with the other if the corresponding update has not landed yet. No file in the repository documents which AsmJit commit is compatible with which Blend2D state, and since neither project publishes GitHub releases, there are no version tags to align the two against.

For a product you ship, that combination places the coordination burden entirely on you. You choose a Blend2D commit, identify an AsmJit commit that works with it, and maintain that pairing as both projects move forward. The blend2d-version.py script at the repository root suggests some versioning infrastructure exists, but its role is not described in any documentation present in the top-level directory.

## CMake flags separate the renderer build from the test and demo trees

Two CMake flags appear in the build documentation. BLEND2D_TEST=ON adds the test suite and sample programs. BLEND2D_DEMOS=ON adds interactive demos and benchmarks against other rendering libraries, but it also requires Qt installed on the build machine along with any rendering libraries you choose to compare against.

```bash
$ cmake -S blend2d -B blend2d/build/Release -DCMAKE_BUILD_TYPE=Release -DBLEND2D_TEST=ON
$ cmake --build blend2d/build/Release --config Release
```

A project that embeds Blend2D as a renderer should configure without BLEND2D_DEMOS to avoid pulling Qt in as a build requirement. The demos tree is a benchmarking facility for the project's own development, and its value to an embedding project is limited once you have chosen to adopt the library.

After building with BLEND2D_TEST=ON, sample programs appear under blend2d/build/Release/ with sequential names starting from bl_sample_1. These live in the blend2d-testing directory at the repository root, which carries an explicit note that it should not be embedded in your project. That boundary is intentional: it is a separate verification and demonstration tree, not a source of headers or utilities for your own code.

The root directory includes 5 configure helpers beyond CMakeLists.txt: configure.sh, configure_demos.sh, configure_sanitizers.sh, configure_vs2022_x64.bat and configure_vs2022_x86.bat. The 2 batch files target Visual Studio 2022 on Windows in x64 and x86 configurations respectively, and the sanitizers script enables builds instrumented for memory and thread checking.

## 4 bundled codecs and a separate DEFLATE implementation cover image and compression needs

Blend2D bundles 4 image codecs: BMP, JPEG, PNG and QOI. They live in the codec directory of the source tree and are included in any standard build, so image file I/O requires no external dependency. QOI appears alongside the 3 older formats, which means files in that container are handled without adding a separate decoder.

DEFLATE compression has its own directory, independent of the codec directory, described in the layout as an implementation of compression and decompression algorithms. PNG relies on DEFLATE, and this layout keeps 1 shared implementation of that algorithm rather than duplicating it inside the PNG codec. Whether the DEFLATE path is accessible through the public API is not covered by the source directory listing.

Font support is in the opentype directory, covering TrueType and OpenType. Those 2 formats account for the fonts distributed with every major operating system. How to load a font file and pass it to the rendering context is covered in the API documentation at blend2d.com/doc/index.html rather than in the repository source.

The unicode directory handles unicode support and conversion between encodings. Its position as a sibling of the font layer rather than a subdirectory of it suggests the encoding work is shared across more than just text rendering, though the source directory listing does not identify the other callers.

## SIMD and threading are internal abstractions with named targets, not external library wrappers

The source tree organises its infrastructure into named subdirectories below the main source directory. Among them, the simd directory holds a SIMD abstraction layer, and the tables directory holds the lookup tables and SIMD constants that layer uses. Keeping the constant tables separate from the abstraction code means the build can generate different constants for different instruction-set widths without changing the abstraction logic.

The threading directory provides an abstraction over POSIX threads and Windows threads, which are the 2 explicitly named targets. That covers Linux, macOS and Windows. Platforms that use a different threading model would need an additional implementation, since no other threading system appears in the source layout.

The support directory collects the allocator and shared utilities: an arena allocator, containers, bit operations and string operations. An arena allocator suits rendering work because it amortises allocation overhead across a full draw call rather than paying for each individual allocation; the rendering context, codecs and other internal modules all draw on this shared pool. None of these directories are wrappers around an external package, so any fix to them requires a change to the Blend2D source tree itself rather than a dependency version bump.

## Language bindings live outside the repository, with no co-development or release tags

Blend2D exposes a C++ API as its native interface. Language bindings for other environments are listed on the project's download page at blend2d.com/download.html#Bindings, outside this repository. Which languages have bindings and whether any are maintained by the core project are questions answered on that external page, not here.

For non-C++ consumers, binding stability is the practical concern. With no versioned releases from the upstream project, a binding author must pin to a specific Blend2D commit and communicate that choice to their users rather than pointing at a stable release tag. The top-level directory includes no .gitmodules file, confirming that no binding is co-developed alongside the main source tree.

For C++ projects, the more immediate friction is the absence of a package manager entry. No CMake FetchContent configuration, vcpkg port or Conan recipe appears in the repository, so integrating Blend2D into a build system that manages dependencies through 1 of those tools requires writing the integration from scratch.

Contact reaches the project through a public Matrix room at app.element.io/#/room/#blend2d:matrix.org or through the process described in CONTRIBUTING.md at the repository root.

## No GitHub releases and a roadmap that links to a different project's page

Blend2D has no GitHub releases. The top-level directory shows blend2d-version.py but no CHANGELOG file, and no tags exist in the repository history. The last push was on 2026-09-05. Adopting Blend2D means tracking a branch commit rather than installing a version, and there is no release history to consult when a behaviour changes between two points in the master branch.

The roadmap linked from the repository points to asmjit.com/roadmap.html, which belongs to the AsmJit project. Whether that page covers Blend2D's own feature plans, AsmJit's plans, or a shared roadmap between the 2 projects is not explained anywhere in the repository. It is the only forward-looking reference the repository links to.

API documentation is at blend2d.com/doc/index.html and build documentation at blend2d.com/doc/build-instructions.html. Both live on the project's website rather than in the repository. An engineer working offline with only the cloned source tree has the CMake build files and the source headers, but no prose documentation describing the API design or the rendering model.

The license is Zlib, identified in the repository metadata and confirmed in LICENSE.md at the root. That file holds the authoritative license text for any redistribution or modification decision.

## Conclusion

Blend2D suits C++ projects that need a self-contained 2D renderer with JIT acceleration and built-in font and codec support. Skip it if you want a versioned release to pin against or a runtime that carries no JIT dependency, since no GitHub releases exist and AsmJit must be cloned and kept in sync by hand. Before adopting, check the Bindings page at blend2d.com/download.html#Bindings if you are not working in C++, and read the build instructions at blend2d.com/doc/build-instructions.html before configuring your first CMake build.

## FAQ

### What is Blend2D?

Blend2D is a C++ 2D vector graphics library that uses a JIT compiler to generate native rendering code at runtime. It includes 4 built-in image codecs for BMP, JPEG, PNG and QOI, TrueType and OpenType font support, and threading abstractions for POSIX and Windows platforms.

### How do I build Blend2D?

Clone Blend2D and then clone AsmJit into blend2d/3rdparty/asmjit, configure with CMake using BLEND2D_TEST=ON, and run cmake --build. Full build instructions are at blend2d.com/doc/build-instructions.html.

### Does Blend2D require AsmJit?

AsmJit is only required when the JIT path is compiled in. The pipeline directory carries both a reference implementation and a JIT implementation, so a build without AsmJit still produces a working renderer using the reference path.

### What image formats does Blend2D support?

Blend2D bundles 4 image codecs: BMP, JPEG, PNG and QOI. DEFLATE compression is implemented in a separate directory in the source tree, distinct from the codec directory.

### Is Blend2D available for Python or other languages?

Blend2D's native interface is C++. A bindings list is at blend2d.com/download.html#Bindings, but no bindings are maintained inside the main repository, and no versioned release tags exist for binding authors to align against.

## Sources

- [blend2d/blend2d on GitHub](https://github.com/blend2d/blend2d)
- [Issues](https://github.com/blend2d/blend2d/issues)
- [License: Zlib](https://github.com/blend2d/blend2d/blob/master/LICENSE)
- [Project website](https://blend2d.com)
- [README](https://github.com/blend2d/blend2d/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/blend2d-blend2d
