writing

essays and notes on vector databases, simd, allocators, and tiny vms.

subscribe via rss →

read by career step

full career map →
2016-2019

ThePlatform: one runtime, one table

This step was years of proving an idea, not years of polishing a finished product. The bet was that vectors, reactions, and grammars could share one dispatch.

The initial design thesis, the K influence, and the first rules for data layout, parsing, and concurrency.

8 posts

2019-2025

ThePlatform: proving the shared runtime in production

The value of ThePlatform was not any one subsystem. It was that one runtime, one debugger, and one extension model survived production pressure.

Proofs, retrospectives, and the production lessons that made the unification claim credible.

7 posts

2021-2022

Hyperbridge: a public concurrency detour

This was not a side project for optics. It was a practical detour where fairness, wakeups, and panic safety had to be learned the hard way and in public.

The MPMC channel work that sharpened the concurrency discipline behind later systems work.

4 posts

2020-2024

Rayforce: restart in C for embeddability

Rayforce began as a deliberate restart in C because embeddability mattered more than implementation comfort. The constraint, not the language preference, drove the move.

The transition away from a server-shaped Rust system toward an embeddable C library and its language core.

6 posts

2024-2026

Rayforce: hardening toward real users

The hard part was not inventing kernels. It was making the system measurable, bindable, allocatable, documented, and honest enough for other people to use.

Allocator work, binding pressure, benchmarks, release work, and user-facing product decisions.

6 posts

2025

AxlDB: test whether there was another shape

AxlDB was an honest negative result. The experiment mattered because it showed Rayforce was not missing a secret cleaner core.

The side experiment that clarified where the engine ended and the database began, then got shelved.

2 posts

2026-

Rayforce2 / Teide: merge the surface with the engine

This step is about giving up the comfort of separate projects. The language users knew and the engine I wanted had to become one system.

The merge, the morsel pipeline, spec transcription, and the new query surfaces unlocked by the new engine.

4 posts

publication archive

2026

datalog on a columnar engine
a new query surface landed this week. eav triples, semi-naive evaluation, and a fixpoint that fits the morsel pipeline naturally.
Rayforce2 / Teidework: Apr 2026milestone
#rayforce2#datalog#query-language
writing down what i know
the experiment teidedb is built on. eighteen years of intuition into a spec dense enough that something else can deliver the implementation.
Rayforce2 / Teidework: 2026technical note
#teidedb#rayforce2#agents#methodology
morsel-driven, finally
rayforce2 with the teide pipeline underneath rayfall. morsels make cancellation, fusion, and profiling structurally simpler.
Rayforce2 / Teidework: Feb-Mar 2026technical note
#rayforce2#performance#execution
merging teide with rayforce
the parallel research project and the production system are now one repo. keeping the language. swapping the engine.
Rayforce2 / Teidework: Feb 2026milestone
#rayforce#rayforce2#teidedb#architecture
a week of ui frameworks
seven days, four desktop ui frameworks, and the decision to keep the database UI close to the engine.
RayforceDBwork: Jan 2026retrospective
#rayforce#ui#retrospective

2025

the day rayforce opened
five years of thinking, two and a half years of private commits. today rayforce is open source.
RayforceDBwork: 2022-2025milestone
#rayforce#milestone
looking back at o, ten years in
ten years of theplatform. what i think now that i did not think then.
ThePlatformwork: 2016-2025retrospective
#theplatform#o#retrospective
shelving axl
four months, one hundred and seventy-nine commits, then closed. what the experiment gave back and what it did not.
AxlDBwork: Jun-Oct 2025retrospective
#rayforce#axl#design
what simdbench taught me
a single c file, a makefile, and a csv. the rule that emerged after four months of measuring.
RayforceDBwork: May-Sep 2025technical note
#rayforce#performance#simd#benchmarking
axl is rayforce minus the database
axldb is the rayforce kernel with the database parts removed to test where the engine boundary actually sits.
AxlDBwork: Jun 2025milestone
#rayforce#axl#c#design
bindings before users
the repo is still private. i am writing the python orm anyway. it is the cheapest way to find out which parts of the c api are wrong.
RayforceDBwork: 2025technical note
#rayforce#python#api#design
per-thread heaps, no mutex on the hot path
every task carries its own allocator. cross-thread frees never touch a lock.
RayforceDBwork: 2024-2025technical note
#rayforce#c#performance#allocator#concurrency

2024

the buddy allocator that finally works
a u64 bitmap, a mask, a count-trailing-zeroes. the smallest fitting order in two instructions.
RayforceDBwork: 2024technical note
#rayforce#c#performance#allocator
ksimple is a tutorial in compression
a week reading kparc's annotated minimal k. two ideas i stole and one i did not.
RayforceDBwork: 2024technical note
#rayforce#rayfall#kdb
six grammars in under nine hundred lines
an audit of every peg grammar shipped under std/. the small line count is evidence for grammars-as-values.
ThePlatformwork: 2019-2024technical note
#theplatform#parsing#peg#dsl
what rayfall takes from k, and what it does not
a year in. writing down which of k's choices made it into rayfall and which i deliberately left behind.
RayforceDBwork: 2023-2024technical note
#rayforce#rayfall#kdb#design

2023

arity-sharded crates
tachyon's workspace is one crate per arity class. the cleanest split i have tried.
ThePlatformwork: 2023technical note
#theplatform#architecture#rust
the first monad
the kernel signature on day one is the kernel signature today, even though the discipline around it changed.
RayforceDBwork: Feb-Aug 2023technical note
#rayforce#rayfall#c#design
initial commit
the rayforce repo went on disk today. seven files, a hundred and three lines, no allocator, no test.
RayforceDBwork: Feb 2023milestone
#rayforce#c

2022

two atomics, one cursor
the head-tail rewrite. one flag bit makes the difference between "spin once and recover" and "lock to be safe". 0.2.5 ships tonight.
Hyperbridgework: 2022technical note
#hyperbridge#rust#concurrency#atomics
move, borrow, mixed
three laziness modes for join reactions. the runtime knows them. the surface still does not expose them.
ThePlatformwork: 2022technical note
#theplatform#concurrency#design
starting in c, again
a year and a half of thinking. the database i want to ship lives in someone else's binary, so it has to be in c.
RayforceDBwork: 2020-2022milestone
#rayforce#c#design
what happens when the last receiver drops
two months of using hyperbridge in theplatform. one bug class i had been ignoring is now closed.
Hyperbridgework: Nov 2021-Jan 2022post-mortem
#hyperbridge#rust#async

2021

wakers queue, briefly
two days trying to wake n receivers in order. one commit message that is more honest than i would normally write.
Hyperbridgework: Nov 2021post-mortem
#hyperbridge#rust#async#post-mortem
starting hyperbridge
i needed an mpmc channel with async support. hyperbridge separated that concurrency problem from theplatform.
Hyperbridgework: Nov 2021milestone
#hyperbridge#rust#concurrency
an http request handler in thirty-two lines
composing a socket, a parser, and a reaction across subsystem lines, with no boundary to pay for.
ThePlatformwork: 2021technical note
#theplatform#o#parsing#concurrency

2020

one judgment, three subsystems
the bet i made in 2016 that i am, finally, fairly sure was right.
ThePlatformwork: 2016-2020retrospective
#theplatform#o#architecture
after theplatform
four years in production. an embeddable, smaller, c-shaped sibling has been quietly forming.
RayforceDBwork: 2020milestone
#rayforce#theplatform#design
join patterns instead of mailboxes
the first reactor is in. join patterns provide atomic matching that actor mailboxes do not.
ThePlatformwork: 2019-2020in the moment
#theplatform#concurrency#join-calculus

2019

channels are not enough
channel selection works until a transaction needs values from two channels. the reaction has to be the unit.
ThePlatformwork: 2019technical note
#theplatform#concurrency#design
grammars are values, not strings
when grammars become first-class, the language stops being two languages.
ThePlatformwork: 2018-2019technical note
#theplatform#parsing#peg#design

2018

the day i gave up on a fix library
a notebook entry from work i cannot share publicly. why grammars-as-values landed for me on this protocol first.
ThePlatformwork: 2018technical note
#theplatform#parsing#fix

2017

no allocation in the inner loop
the only discipline that has stayed put after a year of writing the o kernel.
ThePlatformwork: 2016-2017technical note
#theplatform#performance#rust
vec<f64> over a row of structs
a layout note I keep having to reread. why columnar wins by 10x once two passes are involved.
ThePlatformwork: 2017technical note
#theplatform#performance#vectors

2016

first sketch of o
the language has a name. settling the dispatch rule before the syntax.
ThePlatformwork: 2016in the moment
#theplatform#o#design
what k got right
three months in. why arity-classed vector evaluation still gives modern systems a useful design challenge.
ThePlatformwork: 2016technical note
#theplatform#kdb#vectors#design
starting something
kicking off theplatform - a new system, a small language, and three ideas to fit into one runtime.
ThePlatformwork: Mar 2016in the moment
#theplatform#design