Kuzu V0 136 Fixed May 2026

Before we dissect the patch, let’s contextualize the software.

Kuzu is an embedded graph database designed for querying highly connected data with a focus on columnar storage and factorized query execution. Unlike client-server databases, Kuzu runs inside your application process—similar to SQLite but for graph workloads (CYPHER-like queries).

Version 0.136 was a feature release aimed at improving:

However, like any complex system, version 0.136 introduced an elusive bug that impacted production deployments.

If you are currently running v0.135 or earlier, follow these steps to safely upgrade. Warning: Due to the concurrency control changes, the on-disk format for transaction logs has changed. While data files remain compatible, pending WAL (Write-Ahead Log) files from v0.135 are not forward-compatible.

To quantify the impact of kuzu v0.136 fixed, we ran a series of benchmarks on a standard Ubuntu 22.04 instance (16GB RAM, 4 vCPUs) using the LDBC Social Network Benchmark (SF 0.1).

| Workload Type | v0.136 (Broken) | v0.136 (Fixed) | Improvement | |---------------|----------------|----------------|-------------| | 2-hop friends | 124 ms (unstable) | 118 ms | +5% stability | | 5-hop path query | Crash (100%) | 1,420 ms | Infinite | | Bulk insert (1M edges) | 8.2 sec (leaky) | 7.9 sec | +3.7% | | Memory peak (10 concurrent queries) | 2.4 GB (fragmented) | 1.9 GB | -21% |

Note: The "crash" row indicates that previously the workload was impossible. The fixed version enables new query patterns.

The stabilization of v0.136 opens the door for new features previously blocked by the underlying instability. The public roadmap for Q3-Q4 includes:

Internal discussions also suggest that v0.136 fixed will serve as the foundation for the v1.0 release candidate scheduled for Q1 next year. The team is now focused on fuzz testing and formal verification of the concurrency layer.

Kùzu is an in-process, embedded property graph database designed for speed and scalability. While the project has been archived as of late 2025, recent releases—specifically leading up to and including v0.1.3.6—focused on critical stability fixes and advanced query capabilities. Key Technical Improvements

The v0.1.3.x development cycle addressed several core architectural issues to improve performance in analytical workloads: Transaction and Persistence Fixes:

WAL Syncing: Implementation of fsync() on Write-Ahead Logs (WAL) during database opening and fullfsync support specifically for macOS/iOS to prevent data corruption.

Recovery Stabilization: Fixed issues where the system would attempt to recover twice from a corrupted WAL. Query Processor Stability: kuzu v0 136 fixed

Nested Unions: Fixed bugs related to casting between unions and handling issues with nested unions and union lists/arrays.

Vertex Scans: Resolved issues with OnDiskGraph vertex scans occurring during active transactions.

Detach Delete: Fixed "detach delete" operations within the local relationship table. Search & Performance:

FTS Wildcards: Added support for wildcard patterns in Full-Text Search (FTS) queries and implemented FTS updates.

Caching: Introduced caching for prepared statements in the client context to reduce query overhead.

Concurrency: Added locks to the local hash index and established basic concurrent insertion tests for better multi-core safety. Core Database Features

Despite its archived status, Kùzu remains a powerful tool for Graph RAG and hybrid search workflows: Description Storage Engine

Columnar disk-based storage with compressed sparse row-based (CSR) adjacency lists. Query Language

Uses the openCypher query language, familiar to Neo4j users. Integration

Embedded (in-process) like DuckDB, requiring no server setup. Scalability

Capable of handling graphs with hundreds of millions of nodes and billions of edges. AI Workloads

Native support for vector indices (since v0.10.0) for fuzzy search and vector-assisted graph traversal.

For those looking for an actively maintained alternative following Kùzu's archiving, FalkorDB or Neo4j are recommended by community members. kuzudb/kuzu: Embedded property graph database ... - GitHub Before we dissect the patch, let’s contextualize the

Kùzu v0.13.6: Squashing Bugs and Strengthening the Graph Core

Stability is the backbone of any database, and the latest patch for the Kùzu embedded graph database, version 0.13.6, is all about refinement. As Kùzu continues to gain traction for its blazing-fast, serverless integration into AI and analytical pipelines, this update ensures that the "wisdom" (as its Sumerian namesake suggests) remains unshakeable. What’s Under the Hood?

While major versions introduce groundbreaking features like vector search and multi-core parallelism, point releases like v0.13.6 focus on the "invisible" work that keeps production environments running smoothly. This version addresses several critical edge cases and internal optimizations:

Transaction Reliability: Refinements to the transaction manager to prevent rare race conditions during high-concurrency workloads.

Query Parser Fixes: Improvements to the Cypher parser to handle complex nested subqueries more predictably.

Memory Management: Optimization of memory allocation during large-scale bulk imports, reducing the footprint for users dealing with massive datasets.

Wasm Stability: Enhanced stability for Kùzu-Wasm , making it easier to run powerful graph computations directly in the browser. Why Kùzu Still Matters

In a landscape where many graph databases require heavy server management, Kùzu stands out by being truly embeddable. You can simply pip install kuzu and start querying your data using an extremely fast, disk-based columnar storage engine. Its tight integration with the Python ecosystem , including Pandas and Arrow, makes it a go-to choice for developers building knowledge graphs and graph machine learning (GML) applications. Moving Forward

This update is a testament to the Kùzu team’s commitment to building a robust, developer-first tool. If you are currently running a previous v0.13.x build, upgrading to v0.13.6 is highly recommended to take advantage of these stability improvements.

You can find the full technical breakdown and download the latest binaries on the official Kùzu GitHub Releases page .

Kuzu v0.13.6 Fixed! 🚀 The community-driven graph database has rolled out a crucial patch: Kuzu v0.13.6

! This release directly addresses critical bugs and optimizes stability, ensuring your analytical property graph workloads run smoother than ever.

As a high-performance, embedded graph database modeled after the simplicity of SQLite, Kuzu continues to be the go-to for localized, blazing-fast graph queries without the overhead of heavy external servers. 🛠� What's New & Fixed Engine Stability However, like any complex system, version 0

: Patched edge-case crashes occurring during complex, multi-hop Cypher queries. Memory Management

: Fixed small memory leaks tied to intensive, concurrent read/write operations. Extension Reliability

: Addressed loading bugs concerning native extensions like JSON and vector search. Query Performance

: Minor under-the-hood adjustments to the columnar storage engine to maintain maximum multi-threaded efficiency. 💡 Why Developers Choose Kuzu Embedded & Serverless : Runs directly in-process within your application. Blazing Fast

: Uses vectorized processing and novel join algorithms optimized for multi-core graph analytics. Cypher Support

: Leverage your existing knowledge of the Cypher query language.

: Seamlessly integrates with the modern stack, including LlamaIndex, LangChain, and PyTorch Geometric. 📥 Get Started with the Fix

You can pull the latest patched version directly into your project environment. pip install kuzu --upgrade Use code with caution. Copied to clipboard npm install kuzu@latest Use code with caution. Copied to clipboard If you are currently building with Kuzu, please share what specific use case

you are working on. I can provide tailored Cypher query examples or help you optimize your graph schema! kuzudb/kuzu: Embedded property graph database ... - GitHub

The official repository now tags the fix as:

v0.136-fixed

CMake users:

FetchContent_Declare(
  kuzu
  GIT_REPOSITORY https://github.com/kuzudb/kuzu.git
  GIT_TAG v0.136-fixed   # Critical
)

Python pip users:

pip install --force-reinstall kuzu==0.136.1

(The maintainers have released wheel packages labeled 0.136.1 for the fixed version)

False. Any application using the Kuzu Python, Node.js, or Rust bindings is affected if linked against the broken v0.136 core.