Kuzu: V0 120

Example: find 2-step neighbors of node with id 42 and count per label.

MATCH (n id: 42)-[:REL*1..2]->(m)
RETURN m.label AS label, COUNT(DISTINCT m) AS cnt
ORDER BY cnt DESC;

If you want, I can:

Kuzu v0.12.0 (released in late 2025/early 2026) represents a significant advancement for the Kùzu graph database, solidifying its position as a high-performance, embedded alternative to traditional server-based graph systems. Developed at the University of Waterloo, Kùzu is designed specifically for graph-heavy analytical workloads (OLAP) and GraphRAG applications. Core Innovations in Kuzu v0.12.0

The v0.12.0 release focuses on expanding the database's versatility and performance, particularly for AI and vector-based search.

Advanced Vector Search: Building on previous updates, v0.12.0 enhances its native HNSW vector index, allowing for lightning-fast similarity searches integrated directly with graph queries.

Full-Text Search (FTS) Optimization: The release includes performance improvements for the FTS extension, which is now pre-installed and pre-loaded, enabling seamless hybrid searches across structured graph data and unstructured text.

Single-File Databases: Users can now manage their entire graph database within a single file, mirroring the ease of use found in SQLite.

Expanded Extension Support: The official extension framework has matured, including pre-installed modules for:

Algo: Graph algorithms like PageRank and community detection. Vector: Support for high-dimensional embeddings. JSON: Native handling of semi-structured data. Architecture: Why Kùzu is Different

Unlike many graph databases that rely on "pointer-chasing" (which can be slow for large joins), Kùzu utilizes a columnar disk-based storage model and Columnar Sparse Row (CSR) adjacency lists. This allows it to:

"Kuzu v0 120" — a short, expressive discourse

Kuzu v0 120 arrives like the first clear breath after a long winter: promising, precise, and quietly ambitious. It’s a version number that feels like a hinge between experimentation and maturity — not raw alpha anymore, but not yet fully canonical. The name itself carries soft edges: "Kuzu" evokes something small and swift (a lamb, a sprout, a new tool taking shape), while "v0 120" reads like a roadmap waypoint — an iteration where ideas have been refined, catalogued, and prepared for wider use.

Tone and themes to weave through discourse

Suggested opening lines

Concise descriptive paragraph Kuzu v0 120 refines core behaviors into a cohesive whole. It prioritizes predictable defaults, clearer ergonomics, and a thinner, faster runtime for everyday tasks. Under the surface are carefully chosen trade-offs — simple APIs that favor clarity over verbosity, sensible fallbacks that reduce friction, and a tighter integration between modules that once felt loosely coupled. For users, this translates into fewer surprises and smoother flows; for contributors, a cleaner baseline to build upon.

Expressive feature highlights (with brief examples) kuzu v0 120

Short walkthrough (3 steps)

A compact code-style vignette (pseudocode)

// Pseudocode illustration for an intent-driven call
const kuzu = require('kuzu-v0-120').init(env: 'dev');
const result = await kuzu.query('summarize this article');
// result is concise, contextual, and ready to present
console.log(result.summary);

Design philosophy, in one paragraph Kuzu v0 120 favors human-centered defaults and measurable simplicity: cut complexity where it rarely helps, document the rest with care, and make extending the system as frictionless as possible. It treats early adopters as partners, inviting feedback while offering a stable platform for everyday use.

Closing invitation Kuzu v0 120 is both a tool and a promise: practical enough to use today, open enough to evolve tomorrow. Try a focused task, notice the small conveniences, and if something jars, consider that your feedback is part of the next, inevitable revision.

As of April 2026, (often stylized as Kuzu) is a high-performance, embedded graph database designed for complex analytical workloads on very large datasets. The project has recently transitioned toward its

milestone, representing a major step in its maturity as a disk-based, transactional GDBMS. Key Features of Kùzu v0.12.0

Version 0.12.0 introduces significant advancements in concurrency and analytical breadth: Concurrent Writes

: Support for concurrent write operations within the same process. Expanded Graph Algorithms : Implementation of new built-in algorithms, including Minimum Spanning Tree (Spanning Forest) and Betweenness Centrality Full-Text Search (FTS) Enhancements : Added support for wildcard patterns

in FTS queries and "IF NOT EXISTS" syntax for FTS and vector extensions. Macro Support

: New capabilities for viewing, altering, dropping, and exporting/importing , facilitating more modular query development. Performance Optimizations : Improvements to recursive query JSON scanning performance. Core Architectural Strengths

Kùzu distinguishes itself through an "embedded" architecture similar to DuckDB, but optimized for graph relationships: Vectorized Processing

: Uses a vectorized and factorized query processor to handle join-heavy analytical workloads efficiently. Interoperability

: Seamlessly integrates with the modern data stack, including , and tools like LlamaIndex for AI applications. Cypher Support : Implements a structured property graph model using the query language. Hybrid Search : Features built-in vector search

(HNSW indices) alongside native full-text search, making it a powerful backend for Retrieval-Augmented Generation (RAG). kuzudb/kuzu: Embedded property graph database ... - GitHub

| Parameter | Value | |-----------|-------| | ( V_DD ) | 0.12 V (nominal), 0.108 V – 0.15 V (range) | | Max frequency (ring oscillator) | 2.3 MHz at 0.12 V | | Static leakage per gate | 86 pW (average) | | Dynamic energy (FO4 inverter) | 0.83 fJ/µm | | Noise margin (high) | 32 mV | | Noise margin (low) | 28 mV | Body bias: Adaptive forward body bias (FBB) of

The internal catalog (how Kuzu stores schema metadata) has been refactored. This results in:

You can now define properties with fixed-size list types (vectors) and create vector indexes on them to perform approximate nearest neighbor (ANN) searches efficiently.

1. Defining a Vector Property You can define a property as a fixed-size list of floats (e.g., dimension 1536 for OpenAI embeddings).

CREATE NODE TABLE Document (
    id STRING, 
    content STRING, 
    embedding FLOAT[1536], 
    PRIMARY KEY (id)
);

2. Creating a Vector Index To speed up similarity searches, create an index on the embedding column.

CREATE VECTOR INDEX doc_embedding_index ON Document(embedding);

3. Querying with Similarity You can use the ~= operator (or specific vector functions) to find the closest matches to a query vector.

MATCH (d:Document)
CALL d.embedding =~ [0.1, 0.2, ..., 0.n]  // Your query vector
RETURN d.content
ORDER BY d._similarity_score DESC
LIMIT 5;

(Note: Syntax for vector search may vary slightly depending on the specific 0.12.0 patch version; always check the specific docs for the exact function name, often utilizing cosine or euclidean distance functions).

If you clarify what Kuzu V0.120 actually is (product link, photo, or datasheet snippet), I can tailor the feature even more precisely — including code or a decision tree you could implement.

Based on the available documentation and development community reports, Kùzu version 0.12.0 (released circa October 2025) represents a transitional phase for the embedded graph database. Recent developments indicate that the original Kùzu repository has been archived, with LadybugDB emerging as its primary maintained fork and successor. Key Features and Core Architecture

Kùzu is designed as an embedded, serverless graph database optimized for high-speed query execution and scalability. Its v0.12.0 core features include:

Vectorized and Factorized Execution: A novel query processor that handles data in blocks, allowing for faster joins and minimized intermediate results.

Flexible Data Model: Full support for the Cypher query language within a property graph data model.

Storage & Indexing: Uses columnar disk-based storage and Columnar Sparse Row (CSR) adjacency lists to optimize graph traversals.

Native Hybrid Search: Built-in support for full-text search (FTS) and vector indices, making it a popular choice for GraphRAG (Retrieval-Augmented Generation) pipelines. Notable Technical Changes (v0.12.0 & LadybugDB Transition)

In this version and its subsequent iterations under the LadybugDB name, several critical updates were introduced:

Extension Automation: Standard extensions like vector, fts, json, and algo are often pre-installed or easily managed via simple INSTALL commands from local servers. Example: find 2-step neighbors of node with id

Enhanced Connectivity: Support for WASM (WebAssembly) enables secure, high-performance execution directly in web browsers.

Developer Experience: Improvements to the Ladybug Explorer UI, including read-only/read-write modes and adjustable buffer pool sizes for memory management.

Bug Fixes: Key fixes addressed vector index "drop" bugs and issues with FTS index creation during multi-index imports. Context for Development Package extension-repo - GitHub

Kùzu v0.12.0 represents a significant evolutionary step for this embedded graph database, following its acquisition by Apple and subsequent transition to the community-led

project. This release solidifies Kùzu’s position as a high-performance, DuckDB-inspired

analytical engine optimized for complex, many-to-many joins and vectorized execution Core Enhancements in v0.12.0

The v0.12.0 update focused on expanding the flexibility of internal functions and improving data lifecycle management: Macro Management : Added comprehensive support for viewing, altering, dropping, and exporting/importing macros

. This allows developers to build more reusable and modular query logic directly within the database. Full-Text Search (FTS) Improvements : Introduced support for wildcard patterns in FTS queries and added IF NOT EXISTS

syntax to both FTS and vector extensions for smoother script execution. Resource Management : Implemented a free space management mechanism to efficiently reclaim disk space during database updates. Performance Optimization : Specifically improved speed for recursive queries JSON scanning

, further enhancing its capability for multi-hop graph traversals. The Kùzu Architecture

Built at the University of Waterloo, Kùzu distinguishes itself through several state-of-the-art database techniques: Kuzu — db interface for Rust // Lib.rs 10 Oct 2025 —

Kùzu v0.12.0 is an upcoming or recently targeted release version of the Kùzu graph database, an embeddable, high-performance property graph management system designed for analytical workloads.

While specific changelogs for v0.12.0 are often part of rapid development cycles, the platform generally focuses on several core pillars that define its recent updates: Core Architecture & Capabilities

Embeddable Design: Similar to SQLite or DuckDB, Kùzu runs in-process without requiring a standalone server, making it ideal for integration into Python AI and data science pipelines.

Performance Engines: It utilizes a vectorized and factorized query processor alongside columnar disk-based storage to handle complex joins at scale.

Query Language: Full support for openCypher, allowing users to query property graphs using a familiar, SQL-like syntax. Recent & Expected Features (v0.10.0–v0.12.0)

The development roadmap leading to v0.12.0 has emphasized expanding the system's analytical toolkit: