https://smollergraph.nenuadrian.com/2026-10-24 https://smollergraph.nenuadrian.com/about/ https://smollergraph.nenuadrian.com/ep001-graph-databases/2026-10-21https://i.ytimg.com/vi/DFNrCJRnUac/maxresdefault.jpghttps://i.ytimg.com/vi/DFNrCJRnUac/maxresdefault.jpgHow graph databases work: Neo4j and Kùzu | Building smollerGraph #1We start a series that builds smollerGraph, a small graph database, from scratch in C++, heading towards a knowledge graph that mvGPT can ask for facts. Before writing any code, we look at the property graph model, why following relationships beats joining tables for queries that walk many hops, and Cypher, on a small graph about animals. Then we run a food chain query on Neo4j and Kùzu, compare how each of them keeps its graph, and write a first graph in C++, kept in memory, with a walk down the food chain and GoogleTest tests.https://www.youtube.com/embed/DFNrCJRnUac19712026-10-21graph databaseknowledge graphneo4jkuzukùzucyphergqlproperty graphdatabase internalsindex-free adjacencycsrembedded databasebloodhoundcybersecurityldbcc++from scratchsmollergraphmvgpt https://smollergraph.nenuadrian.com/ep002-pages-on-disk/2026-10-21https://i.ytimg.com/vi/oi8U7nDbq1U/maxresdefault.jpghttps://i.ytimg.com/vi/oi8U7nDbq1U/maxresdefault.jpgGraph database in C++: pages on disk | Building smollerGraph #2We move smollerGraph's graph out of memory and onto disk, in pages of 4 KiB that a pager reads and writes, the way SQLite's file format does. Nodes and relationships become 32-byte records in those pages, with each node at the head of a chain of its relationships, as in Neo4j's record format, and the tests from episode one pass without a change. Along the way the code gets a Docker build and GitHub Actions, and sg load and sg walk keep the graph in a folder between runs.https://www.youtube.com/embed/oi8U7nDbq1U17422026-10-21graph databasec++storage enginepagesfixed-size recordsrecord storeindex-free adjacencypreadpwritedockergithub actionsgoogletestdatabase internalsfrom scratchsmollergraph https://smollergraph.nenuadrian.com/ep003-how-slow-is-it/2026-10-21https://i.ytimg.com/vi/8yGPJej4jGQ/maxresdefault.jpghttps://i.ytimg.com/vi/8yGPJej4jGQ/maxresdefault.jpgGraph database benchmark: Neo4j vs Kùzu | Building smollerGraph #3We measure smollerGraph against Neo4j and Kùzu on a made-up social graph of a hundred thousand people and a million relationships, generated with a fixed seed so each machine gets an identical one. sg load reports how long loading takes, a new sg bench command times a two-hop walk from a thousand people, and a Python script loads the graph into Kùzu and Neo4j, in Docker, to ask them for those people too. We chart the results and go through why smollerGraph is slow where it's slow, and quick where it's quick, for now.https://www.youtube.com/embed/8yGPJej4jGQ12202026-10-21graph databasebenchmarkneo4jkuzukùzuc++cypherdatabase performancetwo-hop querystorage enginesocial graphfrom scratchsmollergraph https://smollergraph.nenuadrian.com/ep004-drawing-the-graph/2026-10-22https://i.ytimg.com/vi/n5onlxgmHaY/maxresdefault.jpghttps://i.ytimg.com/vi/n5onlxgmHaY/maxresdefault.jpgGraph visualization in the browser with D3.js | Building smollerGraph #4We give smollerGraph a UI of its own, after its code gets checked on each push by cpplint, against Google's style guide, and by clang-tidy, and its errors move to Abseil's absl::Status. A new sg serve command answers HTTP requests with the graph as JSON, through cpp-httplib, and a page in the browser draws it with D3's force simulation. A walk lights up the nodes each hop reaches, and clicking a node opens an inspector that shows its record as it's kept on disk, with its page, its offset, its bytes and its chain of relationships.https://www.youtube.com/embed/n5onlxgmHaY29612026-10-22graph visualizationd3d3.jsabseilabsl statuscpplintclang-tidyforce directed graphgraph databasec++cpp-httplibhttp serverjson apisvgjavascriptneo4j browsersmollergraph https://smollergraph.nenuadrian.com/ep005-buffer-pool/2026-10-22https://i.ytimg.com/vi/CVeog8Y-Y8A/maxresdefault.jpghttps://i.ytimg.com/vi/CVeog8Y-Y8A/maxresdefault.jpgDatabase buffer pool in C++: keeping pages in memory | Building smollerGraph #5We give smollerGraph a buffer pool, the part of a database that keeps pages in memory, after counting the pages it reads and writes. Loading a million relationships read and wrote over six million of them, a system call each. The pool has frames, a page table, pins and dirty pages, and a clock that picks the page to evict. A latch keeps sg serve's threads out of each other's way, and we measure it all again against Neo4j and Kùzu, and look at why databases keep a pool of their own instead of using mmap.https://www.youtube.com/embed/CVeog8Y-Y8A12902026-10-22buffer pooldatabase internalspage cacheclock algorithmcache evictionc++graph databasemmapstorage engineneo4jkuzudatabase performancesmollergraph https://smollergraph.nenuadrian.com/ep006-name-index/2026-10-22https://i.ytimg.com/vi/enZnr29PbZQ/maxresdefault.jpghttps://i.ytimg.com/vi/enZnr29PbZQ/maxresdefault.jpgB+ tree index in C++: finding a node by name | Building smollerGraph #6We give smollerGraph an index on names, a B+ tree in a file of its own, read through the buffer pool, so opening a graph no longer reads each node to build a map of names in memory. Its leaves hold the names in order, the pages above them say which page holds which names, and splits grow it a level at a time. The graph finds nodes through it, the UI suggests names as they're typed, and we measure what the index gives and what it costs.https://www.youtube.com/embed/enZnr29PbZQ12842026-10-22b+ treebtreedatabase indexdatabase internalsc++graph databasebuffer poolstorage engineautocompleteprefix searchneo4jkuzusmollergraph https://smollergraph.nenuadrian.com/ep007-cypher-subset/2026-10-22https://i.ytimg.com/vi/-Q3X6d6g7Gk/maxresdefault.jpghttps://i.ytimg.com/vi/-Q3X6d6g7Gk/maxresdefault.jpgWriting a Cypher query parser and planner in C++ | Building smollerGraph #7We teach smollerGraph a subset of Cypher, the query language Neo4j and Kùzu speak, starting from a lexer and a recursive descent parser for MATCH patterns and what they RETURN. A planner turns a pattern into steps named after Neo4j's operators, a NodeIndexSeek through our B+ tree when the start has a name, an AllNodesScan when it doesn't, and an Expand for each hop, and EXPLAIN shows them. An executor runs the plan, sg query prints the answers, and the UI gets a query box for the questions we asked Neo4j in episode one.https://www.youtube.com/embed/-Q3X6d6g7Gk17032026-10-22cypherquery parserquery plannerrecursive descent parserlexerquery executiongraph databasec++neo4jkuzuexplain plandatabase internalssmollergraph https://smollergraph.nenuadrian.com/ep008-deploy/2026-10-22https://i.ytimg.com/vi/IciL4H_Vne8/maxresdefault.jpghttps://i.ytimg.com/vi/IciL4H_Vne8/maxresdefault.jpgDeploying a graph database to a VPS with Docker | Building smollerGraph #8We put smollerGraph on a VPS with a small script, deploy.sh, which sends the committed code over SSH, and Docker Compose builds it there and runs it in two containers. Caddy serves the page and passes the API's requests on to sg serve, which nothing outside can reach. Then we open the UI from anywhere, walk the food chain, inspect a record and ask a question in Cypher, all on the server.https://www.youtube.com/embed/IciL4H_Vne85322026-10-22deploymentvpsdockerdocker composesshcaddyreverse proxygraph databasec++dreamhostself hostingdevopssmollergraph https://smollergraph.nenuadrian.com/ep009-properties/2026-10-24https://i.ytimg.com/vi/_mgZeulSdyg/maxresdefault.jpghttps://i.ytimg.com/vi/_mgZeulSdyg/maxresdefault.jpgProperty graph storage and WHERE in C++ | Building smollerGraph #9We give smollerGraph's nodes and relationships properties, kept as in Neo4j's record format: a third file of 32-byte records, each with a key, a value and the next property's id, so a node's properties form a chain, like its relationships. The facts we load get properties in braces, read by our Cypher parser, and Cypher gets WHERE, with each filter planned as early as it can run, and RETURN of any property. The UI's inspector shows a node's properties as they're kept on disk, and we check what they cost a walk.https://www.youtube.com/embed/_mgZeulSdyg22692026-10-24graph databaseproperty graphpropertiescypherwhere clausequery plannerpredicate pushdownstorage enginerecord formatc++neo4jkuzudatabase internalssmollergraph https://smollergraph.nenuadrian.com/ep010-a-real-graph/2026-10-24https://i.ytimg.com/vi/Y0RBey5eKms/maxresdefault.jpghttps://i.ytimg.com/vi/Y0RBey5eKms/maxresdefault.jpgCanvas vs SVG: drawing a Wikidata graph | Building smollerGraph #10We load a real graph into smollerGraph: the mammals and birds on Wikidata, 21,834 species, genera, families, orders and classes. Their names don't fit, so nodes and properties get records of 64 bytes, and nodes get a label, which our facts and our Cypher learn to read. The page we built would draw every node with SVG, so we redo it: it draws what a query returns on a canvas, with a table, a plan, a history, a search and an inspector, and the server says what each query cost. Then we measure SVG against a canvas in Chromium, from 500 nodes to 20,000.https://www.youtube.com/embed/Y0RBey5eKms25462026-10-24graph visualizationcanvassvgd3d3-forceforce directed graphwikidataknowledge graphsparqltaxonomygraph databasec++neo4j browsercyphersmollergraph