Kuzu V0 136 Fixed |work| -

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:

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. kuzu v0 136 fixed

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 Kùzu is an in-process, embedded property graph database

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

6) Backups and maintenance

For Docker: stop container and copy database dir from host mount. For binary: shut down server cleanly, then tar the database_path.
Regularly export data to CSV or use built-in snapshot/backup tools if provided in v0.136.
Vacuum/compact commands: run database compaction utilities included with the release to reclaim space.

Kuzu v0.136 Fixed: A Comprehensive Breakdown of the Patch, Performance Gains, and Community Impact

In the fast-paced world of software development, few phrases bring as much relief to a user base as the words “fixed in the latest build.” For the community surrounding the Kuzu project—whether it be a lightweight embedded database, an emulation frontend, or a niche game engine—the rollout of Kuzu v0.136 fixed has been nothing short of a turning point.

After weeks of instability, memory leaks, and critical logic errors in the v0.135 branch, the development team has delivered a robust patch that addresses over forty known issues. This article will dissect exactly what “v0.136 fixed” entails, the major bugs eliminated, performance benchmarks, and how this update changes the roadmap for the Kuzu ecosystem.

Creating a Graph

Start Kuzu: Begin by starting the Kuzu server. The exact command may vary depending on your operating system and how you installed Kuzu.
Connect: Use a client or a driver compatible with Kuzu to connect to your database. The official Kuzu documentation should provide examples or a list of supported drivers.
Create Nodes and Edges: Use Cypher queries to create nodes and edges. A simple example to create a node might look like: 6) Backups and maintenance
```
CREATE (n:Person name: 'John', age: 30);
```
Querying: Once you have data, you can query it using Cypher. For instance, to find all persons:
```
MATCH (n:Person) RETURN n;
```

What is Kuzu? A Quick Recap

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:

Recursive relationship traversal.
Memory efficiency during bulk inserts.
JSON data type coercion.

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

What’s Fixed

Crash / regression in [common scenario, e.g., “executing recursive joins” or “scanning large lists”].
Memory leak when handling [relevant operation].
Incorrect results for edge cases involving [e.g., “NULL values in indexed columns”].

Conclusion

Working with Kuzu or any graph database involves understanding the nature of your data, how it relates to graph structures, and leveraging query languages like Cypher to manage and query your data. The guide provided here is introductory; for detailed information on "kuzu v0.136 fixed," consult the official Kuzu documentation or community channels.

The Critical Bugs Addressed in Kuzu v0.136 Fixed

The “fixed” tag in this release is not merely cosmetic. It represents a fundamental overhaul of three major subsystems. Below is a detailed look at the most impactful corrections.

1. The Memory Leak in the Buffer Pool (Issue #892)

In v0.135, users reported linear memory growth during long-running operations. After 48 hours of continuous use, the Kuzu process would consume upwards of 12GB of RAM, eventually crashing the host system. The root cause was traced to a dangling pointer in the buffer pool’s eviction policy. Kuzu v0.136 fixed this by rewriting the LRU (Least Recently Used) cache eviction logic, introducing RAII (Resource Acquisition Is Initialization) guards. Early testing shows memory stabilization at under 2GB even after seven days of runtime.