The database you commit with your code

Content and configuration shape your software as much as its code does, yet their tooling lags far behind. Saka keeps both in a relational database that lives in your git repo. Every change is validated, whether it comes from you or your agent.

How it works

  1. Define a schema

    Write your schema in SakaQL: your record types, their fields, and how they reference each other.

    Each field declares how many values it holds: ! means exactly one, and * means any number. exclusive means no two records share a value.

    game/main.saka

    role Character
    prop Character::name! str exclusive .
    
    role Item
    prop Item::code! str exclusive .
    prop Item::price! f64
    
    role Quest
    prop Quest::name! str
    prop Quest::level! f64
    prop Quest::giver! Character
    prop Quest::rewards* Item #[ref_integrity = Prune]
  2. Validate every change

    Every change is validated against the schema. Invalid changes are rejected with an error naming the broken rule.

    Changes commit atomically.

    Five edits in the REPL. A new item with the sword's code fails because item codes are exclusive, and one without a price fails because every item needs one; the bow with a price commits. A quest whose giver, Bram, doesn't exist fails, and adding Bram as a character commits.
  3. Query live data

    Query results stay current as data changes.

    Saka maintains them incrementally, so joins and aggregates stay fast.

    The quest board lists each quest with its giver, its reward total, and its rewards. Three edits run in the REPL below it: the coin is added to Lost Map's rewards, raising its total to 30; a new quest, Feast, appears; and the shield is deleted, so the Duel's rewards drop to the sword and its total to 40.
  4. Branch and merge

    A database is a folder of plain-text files in your repository.

    The format is built for code review and branching: diffs are readable, and merge conflicts are minimized and easy to resolve.

  5. Delegate to agents

    Tell your agent what you want instead of editing records by hand.

    The schema gives it meaning, queries give it precision, and validation catches its mistakes.

Use cases

Game content

Items, characters, quests, and drop tables, with the models, textures, and audio they use, kept consistent as the world grows.

Translations

Keys, locales, plurals, and review status, with every missing or stale translation one query away.

Configuration and feature rules

Typed settings, environments, and rollout rules, with references between them that can't dangle.

Fixtures and seed data

Related test data that stays valid when the schema changes, instead of a hundred JSON files that break together.

Catalogs and pricing

Products, plans, prices, regions, and entitlements in one model that your app and your billing both read.

Content metadata

Pages, authors, tags, and redirects for a site or its docs, where a broken link fails a check instead of a visitor.

Versus what you use today

Compare Saka with
How Saka compares with what you use today
FeatureSakaFilesJSON, YAML, CSVCodeTypeScript, CUE, PklSpreadsheetonline or desktopSQLitein the repoHeadless CMShosted content platforms
Versioned with your codeThe data lives in your repository and branches with the code that reads it.PlannedYesYesPartlyBinary workbook filesPartlyAs one binary filePartlyGit-based ones only
Readable diffs and mergesA change shows up as the lines that changed, and branches merge like code.PlannedYesYesPartlyEdit history, no mergesPartlyDiffs via dumps, no mergesPartlyVersion history, limited merges
Media assetsModels, textures, pictures, and audio live beside the data that uses them, and change with it.PlannedPartlyPaths, not checkedPartlyChecked if importedPartlyImages onlyPartlyAs BLOBsYes
Typed schemaA wrong value is rejected before it's saved or shipped, not when your code reads it.YesPartlyOpt-in schemaYesPartlyValidation rulesPartlyLoose unless STRICTPartlyContent types, checks vary
Real relationshipsRecords point at each other, and deleting one that's still in use fails instead of leaving a broken link.YesNoPartlyIf modeled in typesPartlyChecked on entry, not deletePartlyForeign keys off by defaultPartlySome allow broken links
Safe schema changesRename or reshape a field, and the existing data is converted with it.YesNoPartlyRenames by refactoringPartlyRenames onlyPartlyLimited ALTER TABLEPartlyThrough migration scripts
All-or-nothing changesAn edit that touches many records lands whole or not at all.YesPartlyPer git commitPartlyPer git commitNoYesPartlySome have transactions
Spreadsheet-style editingBrowse records in a grid and change them a cell at a time.PlannedPartlyCSV in a spreadsheetNoYesPartlyThrough a GUI toolPartlyMostly forms, one entry at a time
Relational queriesJoin, filter, group, and total across all of your data.YesPartlyWith jq or DuckDBPartlyLoops in codePartlyLookups and pivot tablesYesPartlyFilters, limited aggregation
Mature ecosystemYears of production use, with tools, integrations, and answers online.NoEarly alphaYesYesYesYesYes

Each column describes a kind of tool in typical use. Individual products vary.

What works today

What works today and what is planned, in each area of Saka
StepTodayPlanned
SakaQLToday
  • Records with typed properties, keys, and references
  • Every edit checked against the model before it lands
  • All-or-nothing edits
  • Queries and views that stay current as the data changes
Planned
  • Rules that every edit must keep, such as “a won deal has an owner”
  • Media assets: models, textures, pictures, and audio
Browser appToday
  • No account, and your databases stay in your browser
  • A grid for browsing results
  • A REPL for queries and changes
  • Undo and redo
  • Import and export of whole databases
Planned
  • Editing records in the grid, like a spreadsheet
In your repositoryToday
  • A database as one file you can export and import
Planned
  • Databases as folders of plain-text files
  • Readable diffs, history, branches, and merges
  • A CI check that every key, reference, and rule still holds
Terminal and editorToday

Nothing yet

Planned
  • The saka command line
  • Opening a database from your repository
  • A VS Code extension for writing SakaQL
Coding agentsToday

Nothing yet

Planned
  • One command to read, check, and change a database, with docs that match the installed version
  • An MCP server
  • A person's approval for any change that loses data
  • A history of which changes an agent made

Frequently asked questions

The basics

What is Saka?

A relational database that lives in your git repo, and a set of tools for you and your agents to work with it.

Saka isn't a server for your app's users, their live traffic, or analytics.

What kind of data is it for?

Data that your team writes and your code reads, and that has to stay valid: game content, translations, settings, catalogs, and test data. You describe the schema, and Saka enforces its types, keys, relationships, and any rules you add.

What are Saka's limits?

Saka keeps each database in memory, so it's built for data that people and agents edit, not for millions of rows. Each operation also has limits on how long it runs and how much work it does.

Why not keep the data in JSON or YAML files?

For simple data, they're great. As data grows complex, mistakes slip through and questions need scripts.

That's when to turn to Saka: it's plain text in your repo too, but it checks every change and answers queries.

Why not SQLite or another database?

A database checks your data, but it sits outside your workflow: its data doesn't branch with your code or show up in reviews.

A Saka database does both. Its data model and language are also more expressive than SQL, so you can model your data more faithfully.

Language and tools

Do I need to learn SakaQL?

It helps, but you shouldn't have to. The goal is for your agent to write the SakaQL.

Does Saka support SQL?

No. Saka uses its own language, SakaQL, and doesn't connect to SQL databases.

Will it work with my coding agent?

Yes, any agent that can run a command. Saka catches an agent's mistakes before they land, so you can trust its changes.

Status

What can I use today?

The browser app at app.saka.io. It needs no account, and your databases stay in your browser.

Is Saka ready for production?

No. Saka is an early alpha. It works, but bugs and missing features mean you shouldn't rely on it for production work yet.

Data loss is a real risk, so export a copy of any database you'd miss.

Pricing and company

Is Saka free?

Saka's core will always be free, and premium features like hosted databases and multiplayer will pay for its development. Their pricing hasn't been decided.

Is Saka open source?

No. Saka is a commercial product. Your data is still yours: it's stored in human-readable text files that any editor can open.

Who builds Saka?

Sufyan Dawoodjee, a software engineer in Mountain View, California.

Still have a question? Get in touch.

Try Saka in your browser

The browser alpha lets you model data, query it, and watch the results update.

Not ready to try it? Get new posts and product updates by email.