Previewkernable is not released yet: these docs describe work in progress, and things may change before 1.0.Not released yet.Request early access →
Skip to content

Compared with other systems ​

kernable is an application kernel: storage, ordering, trust and delivery in one process, with business logic in yours. Other tools cover parts of that. This page places kernable among them; it describes their general approach, not every feature of every version.

kernableA database, an outbox and a message bus (built yourself)Event store databases (e.g. EventStoreDB/KurrentDB)Event sourcing frameworks (e.g. Axon)Logs and streams (e.g. Kafka)
What it iskernel and runtime for event-sourced applicationsthe usual setup: tables, plus events published from thema database for event streamsa library and server for one platforma distributed log for messages
Business logic runsin your processes, any language, driven by the kernelin your servicesin your application, which reads and appendsin your application, on the framework's platformin your consumers and producers
Languagesany with gRPC; SDKs for TypeScript, Python and Rust share one APIanyclients for several languagesmostly one platform (e.g. the JVM)clients for many languages
One decision per aggregate at a timeyes, the kernel queues commands per aggregaterow locks or optimistic versions, per table, yourswith optimistic concurrency on append; queuing is yoursyes, within the frameworkper partition key, if you design for it; concurrency control is yours
Read your own writesbuilt in: a submit settles after every listeneracross services, you build ityou build it, e.g. by waiting on subscriptionsdepends on the setupyou build it
Order across listenersfixed: lower orders firstper consumer, yourseach subscription on its owndepends on the setupeach consumer group on its own
History of every changethe log itself, with command and senderaudit tables, if you add themthe streamsthe event storeas long as the topic retains it
Signed requests and results, verifiable hash chainbuilt innot built innot the database's concernnot built innot built in
Authorization of every command and querymiddleware in the kernel, fails closedin each serviceaccess control on streamsin your applicationaccess control on topics
Personal data that must be erasablevault with erasing eventsdelete rows; copies in events and backups are yoursyou design it (e.g. crypto-shredding)you design ityou design it (e.g. compaction, encryption)
Changing an event's formatversions with upcasts; old readers stop instead of misreadingmigrations, and versioned messagesyoursupcastersschema registry, if you add one
Delivery to your processesthe kernel delivers to every connected process; no separate brokerthe message bus, a separate serversubscriptions from the databasean event bus, often a separate serverit is the broker
Files and shared cacheincluded: signed requests, governed by grantsseparate systemsseparate systemsseparate systemsseparate systems
What a service consists ofmemberships: the kernel waits for exactly what is listed (/ready)your deploy toolingyour deploy toolingyour deploy toolingyour deploy tooling
Seeing what runsa built-in UI: map, connections, any aggregate's history; metricsdashboards you assemblea database UIdepends on the setuptools around the cluster
Operating itone binary and a SQLite file (or a log file)a database and a message busa database server or clustera server or cluster, plus your applicationa cluster
Scaleone kernel per tenant's partition, with a standby; tenants spread over partitionsas far as you build itclustersclustersclusters, very large
LicenseMIT—open source and commercial editionsopen source and commercial editionsopen source, and commercial offerings

Choose kernable when the logic of one application is spread over teams or languages, when you need to prove what happened and who asked for it, and when "write, then read it back" must simply work.

Choose something else when you need a multi-node cluster today, or a message bus between many independent systems rather than one application's kernel. kernable can sit next to such systems: reactors can publish to them.

Where kernable is young ​

  • One kernel per store. A kernel restarts in seconds and loses nothing, and a pair with a witness fails over by itself; but every write goes through the one primary.
  • No compaction. The log only grows; that is what keeps it verifiable. Expiring data belongs in the cache.
  • SQLite sets the limits of one store: a single writer on one machine. Commands of different aggregates run in parallel on the workers, but every commit goes through that one writer.
  • Three SDKs. Other languages speak the gRPC protocol directly (Write an SDK).
  • A young project. The data format and the protocol stay at version 1 and change in place until the first release, without migrations, and the API may still change before 1.0.

Moving an existing application ​

You do not have to rewrite anything at once:

  1. Start with one aggregate where decisions matter: orders, bookings, payments. Its commands go through kernable; everything else stays.
  2. Keep your tables as read models. A read model, or a reactor, writes the events into the tables your existing code reads, so the rest of the application does not notice.
  3. Tell other systems through reactors. A reactor publishes events to your message bus, or calls the systems that need them.
  4. Move the next aggregate when the first one runs. The old and the new parts run side by side as long as needed.