GraphForge vs. SQLite

When is relational modeling enough for connected data?

SQLite is the reference embedded database: a public-domain, serverless, zero-configuration SQL engine stored in a single file, under 900 KiB with every feature enabled. Graphs can be modeled as node and edge tables and walked with recursive CTEs. GraphForge is also embedded, but it is a graph engine: Cypher patterns, 94 algorithms, and Arrow results instead of hand-written recursion.

Not a like-for-like swap. SQLite is not a graph database and does not claim to be. It is an alternative foundation for an application that might otherwise adopt a graph engine, and for many small graphs it is enough.

Products compared
GraphForgeSQLite
ModelEmbedded property graphRelational
Version0.5.2 stable · 0.6.0-rc.523.54.1 (2026-10-16)18
LicenseApache-2.0 (since 0.5.0)Public domain
StatusActively maintained2Actively maintained18

Researched 2026-10-19 · 28 primary sources · Head-to-head benchmarks not yet run

On this page

Should I choose SQLite or GraphForge?

SQLite for relational data with occasional graph walks; GraphForge when patterns and algorithms are the work.

Choose GraphForge when

  • Queries are naturally patterns and variable-length paths rather than recursive joins.
  • You need algorithms such as PageRank, Louvain, shortest paths, or embeddings without writing them yourself.
  • Results should arrive as Arrow tables for dataframe and notebook workflows.

Choose SQLite when

  • The data is mostly relational, and graph questions are occasional reachability or hierarchy walks.
  • Footprint matters more than anything else, down to under a megabyte, on embedded or mobile devices.
  • You need one portable file and a format that will be readable for decades.

What can each one do?

24 of 26 capabilities differ. For 11, SQLite's docs did not confirm support, so they are marked Not established rather than No.

Each capability has a status and a source. “Not established” means we could not confirm the feature from SQLite's primary documentation. It does not mean SQLite lacks it.

CapabilityGraphForgeSQLite
Property graph modelShippedNo
Embedded / in-processShippedYes
Graph algorithmsShippedNo
WebAssemblyNot plannedYes
ProvenanceShippedNot established
Capabilities of GraphForge and SQLite, with release status and sources
CapabilityGraphForgeSQLite
Storage
Property graph modelShipped

Labeled property graph with typed properties.

1
No

Relational only; graphs are modeled as node/edge tables, as in the docs' edge-table example.

1719
Document modelNot offered

No document-store model; properties accept nested, heterogeneous values.

1
Partial

JSON/JSONB functions built in by default over text/blob columns; no document collection model.

22
Relational tablesNot offered

Not a relational database; results arrive as Arrow tables.

1
Yes

Full-featured SQL with tables, indices, triggers and views in one file.

17
Key-value accessNot offered

No key-value API; data is a property graph.

1
Not established

No dedicated key-value API; key-value usage is via ordinary tables.

Columnar storageShipped

Durable projects store graph data as Arrow and Parquet.

4
Not established

File format stores table rows as records in B-trees; no columnar storage documented.

Vector searchShipped

Exact cosine retrieval over embeddings you supply; no ANN index.

5
Not established

No vector type or ANN index in core SQLite docs.

Full-text searchShipped

Tantivy-backed BM25; hybrid text and vector retrieval through find().

5
Extension

FTS5 virtual table module, part of the amalgamation since 3.9.0; enabled at compile time.

23
GeospatialNot offered

No spatial types or indexes are documented.

Extension

R*Tree module for range/bounding-box queries; Geopoly polygon functions built on it.

24
Execution
Transactional workloads (OLTP)Partial

Local analytical scope; durable atomic writes with queued and optimistic writer modes.

6
Yes

ACID transactional engine; one writer at a time per database file.

1721
Analytical workloads (OLAP)Shipped

Analytical verbs and Cypher over a local columnar project.

7
Partial

SQL aggregates/window functions work, but execution is row-at-a-time over B-trees, not vectorized.

26
Graph traversalShipped

Cypher MATCH patterns plus BFS, DFS, Dijkstra, A*, and reachability.

8
Partial

WITH RECURSIVE CTEs walk trees and graphs over edge tables; hand-written per query.

19
Variable-length pathsShipped

Bounded and unbounded patterns and shortestPath().

8
Partial

Expressible with recursive CTEs; cycle prevention (UNION vs UNION ALL) is the author's job.

19
Graph algorithmsShipped

94 native algorithms behind analysis verbs, not Cypher CALL procedures.

37
No

No graph algorithm library; algorithms must be written as SQL or application code.

19
Incremental computationNot offered

Algorithms recompute on request; no incremental mode is documented.

7
Not established

No incremental view maintenance documented.

Deployment
Embedded / in-processShipped

In-process library; no server, daemon, or connection string.

9
Yes

In-process library; no separate server process.

17
Server modePlanned

Optional remote peer extension planned after 0.6.0.

11
No

Serverless by design: reads and writes ordinary disk files directly, no server process.

17
WebAssemblyNot planned

A browser WebAssembly engine was declined in ADR 0027.

12
Yes

Official sqlite3 WASM build with JavaScript APIs for modern browsers.

25
Distributed clusterNot planned

Distributed clusters and HA replication are out of scope.

9
Not established

Single-file engine; docs recommend client/server engines for many concurrent writers.

Managed cloudNot planned

No hosted compute. The graphforge.sh Hub distributes repositories; execution stays local.

13
Not established

No official managed service from sqlite.org.

Investigation
BranchingExperimental

Research versions, branches, slices, proposals, and forks ship in 0.6.0 release candidates.

14
Not established

No branching feature in core docs.

Snapshots / time travelShipped

Named checkpoints you can diff and revert, plus transaction-time snapshots.

3
Not established

No point-in-time query feature in core docs.

Immutable historyShipped

Knowledge ledger records immutable assertions and evidence lineage.

16
Not established

Updates are in place; no built-in history retention.

ProvenanceShipped

Provenance and knowledge ledger with evidence lineage.

16
Not established

No provenance feature documented.

Competing hypothesesShipped

Immutable hypothesis groups with membership and selection events.

3
Not established
Operations
ACID transactionsPartial

Acknowledged-durable atomic publication; docs do not claim general ACID or serializable isolation.

6
Yes

ACID transactions, documented as holding even after power loss.

17
ReplicationNot planned

HA replication is out of scope.

9
Partial

No built-in replication; the session extension records and applies changesets between databases.

27

Showing 26 of 26 capabilities.

How is each one built?

SQLite: relational. GraphForge: an embedded property graph library in Rust, persisted as Parquet.

GraphForge

GraphForge is a Rust library that runs inside your process: no daemon, server, or connection string. Projects persist to a local directory as Arrow and Parquet data plus JSON metadata, and every query and analysis verb returns an Apache Arrow table. Algorithms run in the same native engine as Cypher and are called as API verbs (rank, cluster, paths, analyze, similar), not as Cypher procedures.

SQLite

SQLite is a C library that keeps tables, indexes, triggers, and views in one cross-platform file. WAL mode lets readers and the single writer avoid blocking each other. JSON and JSONB are built in; FTS5 and R*Tree add full-text and spatial indexing. Graph walks are WITH RECURSIVE queries over edge tables, with UNION to stop on cycles.

Both run inside your process. SQLite gives you a general row store and SQL; GraphForge gives you a graph store, a graph query language, and a graph algorithm library over columnar Parquet.

What the documentation says about SQLite

  • SQLite describes itself as an in-process library implementing a self-contained, serverless, zero-configuration, transactional SQL database engine.17
  • SQLite source code is in the public domain.17
  • A complete database with tables, indices, triggers and views lives in a single cross-platform disk file.17
  • With all features enabled, the SQLite library can be under 900 KiB, depending on platform and compiler settings.17
  • The WITH RECURSIVE documentation includes graph queries over an edge(aa, bb) table, using UNION to avoid infinite loops on cycles.19
  • In WAL mode, readers do not block writers and a writer does not block readers.21
  • JSON functions, including the binary JSONB format, are built into SQLite by default.22
  • FTS5 is a virtual table module that provides full-text search.23
  • The R*Tree module is an index for range queries, most commonly used in geospatial systems for bounding boxes.24
  • sqlite.org maintains an official WebAssembly build of sqlite3 with JavaScript APIs for modern browsers.25

Which one is faster?

Not measured yet. No head-to-head run has been published, so this page shows no performance chart.

Charts appear only after a reproducible run exists: pinned versions, disclosed hardware, generated data, raw results, and scripts.

No comparative results yet

The suites below apply to GraphForge and SQLite. Each will be reported separately per benchmark class, never merged into one leaderboard.

Ingestion and writes

SuiteWorkloadsMetricsStatus
INGESTCSV, JSONL, Parquet, graph edge listsRecords/s, MB/s, total elapsedNot run

Query, analytics, and system

SuiteWorkloadsMetricsStatus
LOOKUPID lookup, indexed property filterp50/p95/p99 latencyNot run
TRAVERSEBFS, k-hop, variable-length pathLatency, visited edges/sNot run
ALGOPageRank, WCC, SCC, Louvain, SSSPTime, memory, correctnessNot run
EMBEDStartup, load, reopen, binary sizems, MiB, disk footprintNot run
DURABLERestart, recovery, persistenceRecovery time, data integrityNot run
CONCURMixed readers and writersThroughput, tail latencyNot run

Which graph algorithms ship?

GraphForge: 94 native algorithms. SQLite: no named algorithm library in its docs.

Algorithms are listed by name, as documented. Counts of extension modules or third-party libraries are not presented as native coverage.

GraphForge

94 Rust algorithms run in the engine behind five analysis verbs (rank, cluster, paths, analyze, similar) and return Arrow tables.37

A selection of the catalog:

  • PageRank
  • ArticleRank
  • Betweenness (Brandes)
  • Closeness
  • Harmonic closeness
  • Eigenvector
  • HITS
  • CELF influence maximization
  • Triangle count
  • K-core decomposition
  • Louvain
  • Leiden
  • Label propagation
  • Infomap
  • Walktrap
  • Girvan-Newman
  • Weakly connected components
  • Strongly connected components
  • Dijkstra
  • A*
  • Bellman-Ford
  • Yen's k-shortest paths
  • Max flow / min cut
  • Steiner tree
  • Minimum spanning tree
  • Topological sort
  • Node2Vec
  • GraphSAGE
  • Fast random projection
  • Node similarity (Jaccard)

SQLite

SQLite has no graph algorithm library; graph walks are written by hand as WITH RECURSIVE common table expressions over edge tables.19

Delivered as: n/a

No named algorithm catalog was found in the primary documentation.

Where can each one run?

GraphForge runs in-process only. SQLite: embedded yes, server no, cluster not established.

ModeGraphForgeSQLite
Embedded / in-processShipped

In-process library; no server, daemon, or connection string.

9
Yes

In-process library; no separate server process.

17
Server modePlanned

Optional remote peer extension planned after 0.6.0.

11
No

Serverless by design: reads and writes ordinary disk files directly, no server process.

17
WebAssemblyNot planned

A browser WebAssembly engine was declined in ADR 0027.

12
Yes

Official sqlite3 WASM build with JavaScript APIs for modern browsers.

25
Distributed clusterNot planned

Distributed clusters and HA replication are out of scope.

9
Not established

Single-file engine; docs recommend client/server engines for many concurrent writers.

Managed cloudNot planned

No hosted compute. The graphforge.sh Hub distributes repositories; execution stays local.

13
Not established

No official managed service from sqlite.org.

ReplicationNot planned

HA replication is out of scope.

9
Partial

No built-in replication; the session extension records and applies changesets between databases.

27

What will my team write?

GraphForge: openCypher from Python, Node.js, Rust. SQLite: SQL (SQLite dialect).

SQLite is available nearly everywhere, through the C API, the official WebAssembly build, and bindings in every major language. GraphForge has three bindings (Python, Node.js, and Rust) and replaces recursive CTEs with Cypher patterns such as (a)-[:KNOWS*1..3]->(b).

Query languages
GraphForge openCypher
SQLite SQL (SQLite dialect)
SDKs and bindings
GraphForge Python, Node.js, Rust
SQLite C/C++ (official C API), JavaScript/WebAssembly (official sqlite3 WASM), Tcl (official)
Written in
GraphForge Rust
SQLite C
Surfaces
GraphForge Python, Node.js, Rust crates, CLI, VS Code extension, Notebooks, Agent skills

What are the trade-offs?

SQLite has no graph language or algorithms. GraphForge is far larger to install and has no SQL.

A fair assessment cuts both ways.

GraphForge

  • A much larger install footprint; the measured Python package is about 160 MB installed.
  • No SQL interface and no general relational tables.
  • No WebAssembly or browser build.

SQLite

  • SQLite supports unlimited simultaneous readers but only one writer at a time per database file.20
  • WAL mode does not work over a network filesystem, because all processes must share memory on the same host.21
  • SQLite is not a graph database: it has no graph query language, pattern matching or graph algorithms, so each traversal is a hand-written recursive CTE.19
  • The SQLite docs recommend a client/server engine for write-intensive or multi-server workloads.20

How would I migrate?

Load SQLite data through Arrow, pandas, or Polars. SQL queries are rewritten as Cypher.

Into GraphForge

  • GraphForge 0.5.x loads data through Arrow, pandas, and Polars bulk calls or Cypher scripts; it has no native CSV loader.15
  • Algorithms are API verbs (rank, cluster, paths, analyze, similar), not Cypher CALL procedures, so procedure calls become verb calls.7
  • GraphForge passes the full openCypher 2024.3 TCK, so standard openCypher queries are the portable part of a migration.10

Moving from SQLite

  • Node and edge tables can be exported from the sqlite3 shell with .mode csv and loaded with .import, which suits CSV-based graph bulk loading.28
  • Recursive-CTE graph walks do not translate mechanically to Cypher; each must be rewritten as a MATCH pattern, often a variable-length path.19
  • Schemas need an explicit decision on which tables become node labels and which foreign-key or join tables become relationship types, because SQLite has no graph schema.17

What else do people ask about SQLite?

Can SQLite be used as a graph database? SQLite can store graphs as tables and walk them with recursive SQL, but has no graph algorithms.

Can SQLite be used as a graph database?

You can store nodes and edges as tables and traverse them with WITH RECURSIVE queries, as SQLite's own documentation shows. It has no graph query language, pattern matching, or graph algorithms.

When should I move from SQLite to GraphForge?

When traversals become multi-hop patterns, when you need algorithms like PageRank or community detection, or when recursive SQL becomes the hardest part of the codebase.

Is GraphForge as small as SQLite?

No. SQLite can be under 900 KiB. GraphForge bundles a Cypher engine, 94 algorithms, and search, and its measured Python package is about 160 MB installed.

How was this researched?

From 28 primary sources, accessed 2026-10-19, each cited where it is used.

Capabilities were checked against primary documentation, repositories, and release notes, accessed 2026-10-19. Each cell records two things: the capability’s state and the evidence behind it. Every GraphForge cell carries a release status. Shipped means stable 0.5.2; experimental means 0.6.0 release candidates only. GraphForge is pre-1.0 and makes no backward-compatibility guarantee yet.

  • Yes documented natively
  • Partial limited or caveated
  • Extension official extension or module
  • Paid edition paid or enterprise edition only
  • Removed removed, with the version cited
  • Not established not confirmed by our research; not a “no”
  • Shipped in stable 0.5.2
  • Partial shipped with documented limits
  • Experimental in 0.6.0 release candidates only
  • Planned on the roadmap
  • Not offered outside the product's model
  • Not planned explicitly out of scope

Benchmark classes

  1. Equivalent workloads. The same logical operation with the same correctness requirement on every engine.
  2. Native optimized workloads. Each engine's best supported implementation, including projections, indexes, extensions, and native algorithms.
  3. End-to-end application workloads. Time from raw data to a usable result: import, indexing, projection, computation, and output retrieval.

Sources · accessed 2026-10-19

  1. GraphForge repository README — GitHub
  2. GraphForge releases — GitHub
  3. GraphForge 0.5.0 changelog — GitHub
  4. Storage architecture — GraphForge Book
  5. Analytics integration: search and retrieval — GraphForge Guide
  6. ADR 0018: acknowledged durability and isolation — GitHub
  7. Algorithm verbs — GraphForge Book
  8. Cypher guide — GraphForge Guide
  9. openCypher compatibility — GraphForge Reference
  10. openCypher TCK compliance — GraphForge Reference
  11. Remote authority peer extension (#215) — GitHub
  12. ADR 0027: native runtime boundary — GitHub
  13. Release scope and roadmap — GraphForge Docs
  14. Keep research history — GraphForge Guide
  15. Graph construction — GraphForge Guide
  16. Knowledge public API v1 — GraphForge Book
  17. About SQLite — sqlite.org
  18. Release History Of SQLite — sqlite.org
  19. The WITH Clause (recursive CTEs, Queries Against A Graph) — sqlite.org
  20. Appropriate Uses For SQLite — sqlite.org
  21. Write-Ahead Logging — sqlite.org
  22. JSON Functions And Operators — sqlite.org
  23. SQLite FTS5 Extension — sqlite.org
  24. The SQLite R*Tree Module — sqlite.org
  25. sqlite3 WebAssembly & JavaScript Documentation — sqlite.org
  26. Database File Format — sqlite.org
  27. The Session Extension — sqlite.org
  28. Command Line Shell For SQLite — sqlite.org

Try GraphForge on your own graph.

Install the package, open a project, and run the same notebook we measure with.