Quick wins for a faster PC:
Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Clear out junk files and repair common Windows errorsFree Scan →Scan for outdated or missing drivers - takes under a minuteDriver Scan →For most Node.js projects starting now, SQLite recursive CTEs are the lower-risk way to traverse connected data, because they run on a relational engine you can keep maintaining. Kùzu offers a more graph-native model and the Cypher query language, but its GitHub repository describes the project as archived and its npm package is marked deprecated and no longer supported. That status should decide the question before feature fit does. Neither option has a sourced speed advantage for your workload, so measure with your own data before you choose on performance.
What you are actually choosing between
The two options differ in data model and query language, not just in how they are packaged. Kùzu is an embedded property graph database. You declare node tables and relationship tables with typed properties, and you query patterns with Cypher. SQLite is a relational database. Graph-shaped data lives in ordinary tables, usually an edge table with a source and a destination column, and you traverse it with SQL. SQLite’s documentation describes recursive common table expressions as a way to run “hierarchical or recursive queries of trees and graphs, a capability that is not otherwise available in the SQL language” (SQLite WITH clause documentation).
As an Amazon Associate I earn from qualifying purchases.
So this is a comparison of two modeling styles. It is not a like-for-like API comparison, and it does not tell you which engine executes a given traversal faster.
Windows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallOutdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchProject status comes first for Kùzu
Before you design around Kùzu, check two things. The Kùzu GitHub repository states that the project is archived, and it is distributed under the MIT license. The npm package listing for kuzu marks the package as deprecated and “no longer supported.”
#1 Best Overall
In practical terms, versions already published to npm may keep installing and running, but you should not expect new fixes or runtime compatibility work from the upstream project. Treat Kùzu as a dependency you would have to maintain yourself. If you are evaluating it for a long-lived service, that is the main decision factor, and it outweighs the modeling advantages described below. The Kùzu installation documentation still shows npm install kuzu, so the install path exists even though its support status has changed.
The same traversal in each model
Take a small social graph: people connected by a KNOWS relationship, and the question “who can Ann reach within three hops, following KNOWS in the outgoing direction?” The examples below are illustrative. They assume the schema shown and an outgoing-only traversal, and they do not represent a tested benchmark.
Kùzu with Cypher
In Kùzu, the schema is declared as node and relationship tables. A minimal schema for this example looks like this, though you should confirm the exact DDL against the Kùzu documentation for the version you install:
Free tools Windows power users keep installed
One-click scans. No signup required.
Rank #2
CREATE NODE TABLE Person(name STRING, PRIMARY KEY(name));
CREATE REL TABLE KNOWS(FROM Person TO Person);
The traversal then reads like the pattern it describes. A variable-length relationship with a bounded range covers one to three hops:
MATCH (a:Person {name: 'Ann'})-[:KNOWS*1..3]->(b:Person)
RETURN DISTINCT b.name;
The bounded range is what keeps this query finite on graphs with cycles. The pattern expresses intent directly, which is the main reason graph-centric teams find Cypher easier to read than recursive SQL.
SQLite with a recursive CTE
In SQLite, the same data is two tables. The edge table is the graph:
Rank #3
CREATE TABLE person(name TEXT PRIMARY KEY);
CREATE TABLE knows(
src TEXT NOT NULL,
dst TEXT NOT NULL,
PRIMARY KEY (src, dst)
);
The traversal is a recursive CTE. It starts from a seed row, joins the edge table at each step, and stops at a depth limit:
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →WITH RECURSIVE reach(name, depth) AS (
SELECT ?, 0
UNION
SELECT k.dst, r.depth + 1
FROM reach r
JOIN knows k ON k.src = r.name
WHERE r.depth < 3
)
SELECT DISTINCT name
FROM reach
WHERE depth >= 1;
Three details in this query are deliberate, and each one is your responsibility in SQL:
- Cycle handling.
UNIONrather thanUNION ALLdiscards repeated(name, depth)rows, so a cycle does not generate unbounded duplicate output. The depth cap is what guarantees termination. - Depth limit. The
WHERE r.depth < 3condition is the traversal boundary. Remove it and a cyclic graph can keep expanding. - Seed inclusion. Ann can reappear at depth 2 or 3 if the graph loops back to her. The outer
depth >= 1filter keeps her in the result only when she is reached through at least one edge.
For undirected traversal, you would add a second join condition or a union of both edge directions. For a path, rather than a set of reachable nodes, you would carry the path as a column, which makes the query more verbose.
Rank #4
Calling the SQLite version from Node.js
Node.js ships a built-in node:sqlite module, so the SQLite approach needs no third-party database driver. The Node.js v24.21.0 SQLite documentation lists its history as added in v22.5.0 and classifies its stability as 1.2, Release candidate, in that release’s docs.
Two constraints follow from that. First, the stability label belongs to a specific release line, so state the Node version in your project and check the docs for that exact version before you rely on the module in production. Second, a built-in module that is still a release candidate can change between releases. Pin your Node version and test on upgrade.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
import { DatabaseSync } from 'node:sqlite';
const db = new DatabaseSync('graph.db');
const reachable = db.prepare(`
WITH RECURSIVE reach(name, depth) AS (
SELECT ?, 0
UNION
SELECT k.dst, r.depth + 1
FROM reach r
JOIN knows k ON k.src = r.name
WHERE r.depth < 3
)
SELECT DISTINCT name FROM reach WHERE depth >= 1
`);
console.log(reachable.all('Ann'));
This uses a parameter placeholder for the starting node, so the seed value is bound rather than concatenated into the SQL string.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Performance: what is and is not established
No benchmark in the sources cited for this article compares Kùzu and SQLite recursive CTEs under Node.js for the same dataset, query semantics, and environment. Any claim that one is faster is therefore not supported by the evidence here. Graph size, traversal depth, branching factor, whether the query is a full reachability scan or a bounded lookup, and whether the database is read-heavy or write-heavy can each reverse the result.
If you need a speed answer, run your own measurement. Keep the following fixed across both engines:
- Use the same hardware, operating system, and Node.js version, and record them.
- Generate or load the same graph into both systems, and record how long loading takes separately from query time.
- Use identical query semantics: the same direction, the same maximum depth, the same cycle behavior, and the same result shape.
- Run warm-up queries first, then repeat the measured runs many times and report the spread, not a single number.
- Record the cache state, whether the database was freshly opened, and the exact database versions.
Choosing between them
The table summarizes the trade-offs. Cells marked “not stated” mean the cited sources do not establish that value.
Recommended Free Tools
| Decision axis | Kùzu | SQLite recursive CTEs |
|---|---|---|
| Data model | Property graph with typed node and relationship tables (Kùzu repository) | Relational tables; graph edges stored as rows (SQLite documentation) |
| Query language | Cypher pattern matching, including bounded variable-length relationships | SQL with a recursive CTE; you write the join, termination, and cycle handling |
| Node.js integration | Installed from npm with npm install kuzu (Kùzu installation documentation) |
Built in as node:sqlite; history lists v22.5.0 as added, stability 1.2 Release candidate in v24.21.0 docs (Node.js SQLite documentation) |
| Maintenance status | Repository archived; npm package deprecated and “no longer supported” (npm listing) | Depends on the Node.js release line you target; check its documentation |
| Performance on your workload | Not stated by the cited sources for this comparison | Not stated by the cited sources for this comparison |
When SQLite recursive CTEs fit
- Your data already lives in SQLite or another relational schema, and traversals are occasional rather than the core of every request.
- You need a dependency that is built into the runtime and not tied to a third-party project’s support status.
- Your team is comfortable writing recursive SQL and reasoning about termination, cycles, and depth limits.
When Kùzu’s model may fit, with caveats
- You are building a graph-centric workload where most queries are patterns over typed nodes and relationships, and Cypher would make them clearer.
- You accept that you will own the maintenance of the dependency, including any compatibility issues with future Node.js releases.
- Your evaluation shows, on your own data, a benefit large enough to justify that ownership.
If you are starting a new project and have no existing graph tooling, the archived status and deprecated package make Kùzu hard to recommend for production. Use it for prototyping or for a bounded experiment if you want to compare modeling styles directly.
The Bottom Line
Choose SQLite recursive CTEs for a Node.js project unless you are willing to maintain an archived, deprecated dependency. Kùzu’s graph-native modeling is a real advantage for graph-heavy domains, but it does not outweigh the upstream status for new production adoption. Whichever you choose, pin your Node.js version, because the node:sqlite stability label is release-specific, and measure your own workload before deciding on speed.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
