rad

The relational database, redesigned. With one cohesive toolchain. True OLTP backed by durable object storage.

$`curl -fsSL https://raw.githubusercontent.com/Southclaws/rad/main/install.sh | sh`

COPY

Read the docs Star on GitHub

radnooo don't close me!

rad \# radically simple!

serverun the database

validatecheck your schema

migratereconcile changes

generateemit typed clients

the loop

Everything starts with the schema.

Rad's declarative schema is the source of truth for your database, migrations and type-safe clients. Change it, and everything else follows.

define

schema.rad

Describe your data model.

migrate

automatic

The database itself handles it.

generate

rad generate

Generate type-safe clients.

build

your application

Write business logic, not database glue.

deploy

object store native

Backed by durable object storage.

repeat

stay in flow

Keep your momentum focused.

show, don't tell

Here's the whole thing.

You author a single declarative schema. Rad generates the exact clients for your database. No ORMs. No query builders. No string-gluing.

schema.radclient.goclient.ts

tables:

- name: boards

columns:

- { name: id, type: string, pk: true, default: uuid() }

- { name: team_id, type: string, ref: teams.id }

- { name: name, type: string }

- name: tasks

columns:

- { name: id, type: string, pk: true, default: uuid() }

- { name: board_id, type: string, ref: boards.id, index: true }

- { name: title, type: string }

- { name: status, type: string, default: todo }

- { name: priority, type: int64, default: 2 }

- { name: assignee_id, type: string, ref: users.id, nullable: true }

- { name: estimate, type: float64, nullable: true }

indexes:

- { columns: [board_id, status] }

what you get

Radically rethink your relationship with rows.

The whole stack, from code to columns. Built for today, not 1973.

clients

No need for an ORM

Generated directly from your schema. Typed queries, typed rows and typed relationships. More than just a layer on top, Rad defines and enforces a contract between your data and your code.

`db.Tasks.Query().StatusEq("todo").OrderByPriority().All(ctx)`

reads

Joins that make sense

Read data the way your application uses it. Parents, children and nested relationships without rebuilding from flattened results.

migrations

Migrations from a schema diff

Change the schema. Rad computes and runs the migration. Rename hints keep intent without unnecessary rewrites.

`rad migrate --url rad://localhost`

one binary

Server, devtool & codegen, all in one

Database, toolchain and code generation in a single executable. Runs anywhere you need it to.

storage

Durable, stateless storage

Built for object storage from day one. Stateless compute, durable data.

interface

Strings are not an API

Rad's lower level intermediary format is structured so you can build queries without gluing strings.

`"SELECT * FROM users " + whereClause + " ORDER BY " + ... 🙅`

protocol

The rad:// protocol

A simple JSON-over-HTTP protocol. Designed for generated clients, not hand-written requests.

one → many

Grab the binary for Windows, macOS or Linux. This includes the database server itself and the CLI developer tools.