Dolt

Open source alternative to PlanetScale and Neon

24.7K stars
Apache-2.0
Active this week
Last commit 1 day ago

Last verified Oct 25, 2026

Query and version-control SQL data with Git-style branching, merging, and pull requests. Apache 2.0 licensed and MySQL-compatible.

Visit website GitHub24.7K Deploy on Hostinger

Read the full breakdownWho it is for, how it works, trade-offs, the quick start and the FAQ

who it's for

Who Dolt is for#

Data engineers managing schema evolution

A data engineer creates a feature branch, runs schema migrations against real data, and opens a pull request for review before merging to main. If the migration breaks something, the branch is discarded and the production database is untouched. The diff shows exactly which rows changed and which constraints failed.

Skip if:

Your team deploys schema changes directly to production and reviews them after the fact. Dolt's value is in the pre-merge review workflow; without that process, the branching adds coordination overhead without a matching payoff.

AI and agent memory workloads

Multi-agent pipelines that need each agent to operate on an isolated, versioned snapshot of shared state can use Dolt branches as agent memory. Each agent writes to its own branch, conflicts are resolved through the standard merge workflow, and the commit log provides a full audit trail of every agent's writes.

Skip if:

Your agents need sub-millisecond write latency or very high write throughput. Dolt's versioning overhead makes it a poor fit for high-frequency real-time writes.

Teams sharing and distributing datasets

DoltHub lets you publish a Dolt database as a public repository, clone it, fork it, and submit pull requests with new data. Research teams, data journalists, and open data maintainers can run a Git-like collaboration workflow over datasets rather than distributing CSV snapshots over email.

Skip if:

You need to distribute private datasets to paying customers under access control. DoltHub's model is hosting and collaboration, not commercial data product licensing.

Audit-trail applications

Applications that need row-level history for compliance or debugging can query Dolt's system tables to retrieve the full change history for any row, including who made the change and when, without building a separate audit-log table or trigger layer on top of a standard database.

Skip if:

Your audit requirements are already met by Postgres logical replication or a change-data-capture pipeline in your stack. Dolt adds value when the audit trail needs to be queryable as SQL, not just streamed to a log sink.

the problem

The problem it solves#

SQL databases store the current state of your data but discard the history. When a bad migration ships or a teammate's query overwrites records, the standard recovery path is restoring from a point-in-time backup, which loses everything that happened after it. Teams work around this with migration files, changelogs, and manual documentation, but none of those give you a commit hash to point at or a branch to roll back.

The problem gets worse at the data collaboration boundary. If two data engineers need to make incompatible schema changes simultaneously, they coordinate through messages and deployment windows rather than branches. There is no merge request for data, no diff to review before it goes to production, and no way to cherry-pick a single table change out of a combined deployment.

how Dolt solves it

How it solves it#

Git-style branching for SQL tables

Create named branches of your database the same way Git branches source code. Schema changes and data writes on a branch stay isolated until you merge. The `dolt_branch()` and `dolt_merge()` stored procedures expose the full workflow from a standard MySQL connection, with no CLI required.

Row-level diffs and commit history

Query `dolt_diff_<tablename>` or call `dolt_log` to see exactly what changed, who changed it, and when, at the row level. You can diff two branches, two commits, or the working set against HEAD, and the output is a SQL result set you can filter and join like any other table.

MySQL-compatible server on port 3306

Start a MySQL-compatible server with `dolt sql-server`. Any MySQL 8.4 client, ORM, or migration framework connects without modifying your connection string. Dolt supports foreign keys, secondary indexes, triggers, check constraints, and stored procedures, covering most standard SQL workloads.

Version control via SQL stored procedures

Every Git operation maps to a SQL stored procedure: `dolt_add()`, `dolt_commit()`, `dolt_push()`, `dolt_pull()`, `dolt_merge()`. Teams that cannot install the Dolt CLI can drive the full version control workflow from a standard SQL client connection, with no extra tooling.

Agent memory for AI workflows

Dolt's branching model fits multi-agent and multi-machine AI workflows where each agent needs an isolated, versioned view of shared state. An agent writes to its own branch, changes are reviewed as a pull request on DoltHub, and the merge creates a permanent, auditable record of what each agent changed and when.

strengths · trade-offs

Strengths and trade-offs#

Strengths

Apache 2.0 license with no usage restrictionsDolt is Apache 2.0 licensed. You can run it commercially, modify it, and embed it in proprietary products without restriction or licensing fees. Unlike managed database services that require a paid account to access, Dolt's source code is fully open and forkable.
Single binary, runs everywhere MySQL doesDolt ships as a ~103 MB standalone binary with no separate database engine or daemon to configure. It installs via Homebrew, Chocolatey, pacman, or a one-line curl script. The Docker image `dolthub/dolt-sql-server` runs the server in a container with no additional setup.
24,000+ stars and active developmentWith 24,724 GitHub stars and a last push on 2026-10-24, Dolt is actively maintained. The project has been public since 2019. The companion DoltHub platform lets teams publish, share, and discover Dolt databases the way GitHub hosts public code repositories.
No external dependencies for self-hostingRunning a Dolt SQL server requires only the binary and a directory for data storage. No Postgres, Redis, or object storage is needed to get started. This makes self-hosting accessible without DevOps overhead for teams that need version-controlled data but not a managed cloud service.

Trade-offs

-Write throughput lower than standard MySQLDolt's write throughput is lower than a standard MySQL or MariaDB instance because every write carries additional versioning overhead. The team publishes benchmarks on their blog. Read-heavy workloads with occasional versioned writes are fine; high-frequency transactional write workloads may find the performance gap significant enough to warrant evaluation before committing.
-606 open issues; some MySQL compatibility gapsWith 606 open issues, edge cases exist in compatibility with certain MySQL syntax patterns, MySQL 9.0 authentication modes (caching_sha2_password requires extra configuration), and some advanced stored procedure patterns. Most standard SQL workloads run without issues, but testing against your existing application before a production migration is recommended.
-Postgres-compatible variant still in betaDoltgres, the Postgres-compatible version, is in Beta. Teams that need Postgres wire compatibility rather than MySQL should treat it as experimental rather than a production-ready Neon alternative today.

versus alternatives

Dolt vs alternatives#

Dolt vs PlanetScale

PlanetScale is a managed MySQL-compatible database service offering schema branching as a deployment safety net. Both Dolt and PlanetScale use MySQL compatibility and both call their isolated environments "branches," but the overlap ends there.

PlanetScale's branching applies to schema changes only; you cannot branch, diff, or merge rows of data. Dolt versions the entire database state, schema and data together, at the row level. PlanetScale is a proprietary managed-only cloud service; Dolt is Apache 2.0 licensed and self-hostable. Teams choosing between them are usually deciding whether they need managed infrastructure or data portability.

Feature	Dolt	PlanetScale
License	Apache-2.0	Proprietary
Self-hosting	Yes	No
Data branching	Full rows and schema	Schema only
Wire protocol	MySQL	MySQL
Pricing	Free self-hosted	Managed service

Dolt wins when you need data-level branching, self-hosting, or a free development path. PlanetScale is worth considering when you need a fully managed MySQL service with no operational overhead and are comfortable with schema-only branching.

Dolt vs Neon

Neon is a serverless PostgreSQL service that offers database branching as a developer workflow. You spin up a branch for each pull request, run migrations, and delete the branch after merge. Neon's branching is at the storage layer, creating copy-on-write snapshots rather than a queryable commit history.

Dolt and Neon differ on every key dimension. They use different wire protocols (MySQL vs Postgres), different branching models (commit-based history vs copy-on-write snapshots), and different hosting models (self-hosted vs cloud-only). Neon is optimized for low-latency serverless Postgres workloads; Dolt prioritizes auditability and data collaboration.

Feature	Dolt	Neon
License	Apache-2.0	Proprietary
Self-hosting	Yes	No
Wire protocol	MySQL	PostgreSQL
Branching model	Commit-based history	Copy-on-write snapshots
Pricing	Free self-hosted	Managed service

Dolt is the better fit when you need queryable row-level history, self-hosting, or MySQL compatibility. Neon is worth choosing for Postgres teams who want instant branch creation and pay-per-use serverless scaling without managing infrastructure.

install · quick start

Quick start#

bash

Self-host Dolt as a MySQL-compatible SQL server on port 3306 - install the binary, then start the server.
```bash
brew install dolt
dolt sql-server
```

tech stack · detected from GitHub

What it's built on#

Languages: Go
Databases: MariaDBMySQL
Infrastructure: AWS

frequently asked

FAQ#

Is Dolt a drop-in replacement for MySQL?

Dolt is MySQL-compatible: any MySQL 8.4 client connects to a Dolt SQL server without changes to your connection string. It supports foreign keys, secondary indexes, triggers, check constraints, and stored procedures. MySQL 9.0's caching_sha2_password authentication requires extra configuration, and some MySQL-specific syntax patterns have open compatibility issues. For most standard SQL workloads Dolt works without modification, but testing your existing queries against a Dolt server before a production migration is worthwhile.

How does Dolt handle merge conflicts in data?

Dolt surfaces merge conflicts as a SQL result you resolve through queries, not a file you edit manually. When two branches modify the same row differently, dolt_merge() flags the conflict and the row appears in the dolt_conflicts_<tablename> system table. You resolve it by writing the correct value and calling dolt_conflicts_resolve(). The workflow mirrors Git's conflict resolution model but works entirely within a SQL client connection.

Can I self-host DoltHub?

Yes. DoltLab is the self-hosted version of DoltHub. It runs the DoltHub web interface on your own infrastructure, giving teams a private database sharing and collaboration platform without sending data to a third-party service. See doltlab.com for installation details.

What does the Apache 2.0 license mean for self-hosters?

Apache 2.0 lets you run Dolt commercially, modify the source, and embed it in proprietary products without paying licensing fees or releasing your application's source code. There are no restrictions on internal commercial or team use. You can fork the repo, ship your own distribution, and use it in any business context. The license is OSI-approved.

How does Dolt versioning differ from database backups?

Dolt commits capture the logical state of every table at commit time, not a binary snapshot. You can time-travel to any commit with dolt checkout <commit>, query historical data without a restore operation, and diff two points in time as a SQL result set. Backups are for disaster recovery; Dolt commits are for auditability, collaboration, and rollback of specific changes. The team recommends using Dolt's native backup feature alongside commits for full disaster recovery coverage.

also worth a look

Similar open-source tools#

Turso

Alternative toPlanetScale

Edge SQLite database with multi-tenancy for serverless apps

24,983 GitHub stars
Licence MIT

Chat2DB

Alternative toDataGrip

AI text-to-SQL client for 40+ databases; local-first, self-hosted

28,331 GitHub stars
Licence Apache-2.0 with additional commercial restrictions (LicenseRef-Chat2DB)

Duckle

Alternative toFivetran

Self-hosted ETL on DuckDB with 385 connectors and no per-row billing.

1,522 GitHub stars
Licence Apache-2.0

libredb-studio

Alternative toDataGrip

One browser tab for 18 database engines, deployed beside your data

1,254 GitHub stars
Licence MIT

DBeaver

Alternative toDataGrip

Free open-source database management tool for SQL databases.

52,181 GitHub stars
Licence Apache-2.0

ChartDB

Alternative toSqlDBM

Free open source database diagram editor and visualizer

23,011 GitHub stars
Licence AGPL-3.0

by category

Run Dolt on your own server

Self-host Dolt on a Hostinger VPS.

Deploy on Hostinger

Featured

Inbox Zero

Alternative toSuperhuman

AI email assistant that drafts replies and clears your inbox

12,787 GitHub stars
Licence AGPL-3.0
#Email

Omnara

Alternative toClaude Managed Agents

Open-source agent deployment API. Self-host or use Omnara Cloud.

3,235 GitHub stars
Licence Apache-2.0
#AI Agents

rakazo

Alternative toGrok Bot

AI teammates you own: your keys, your model, your machine.

5,406 GitHub stars
Licence Apache-2.0
#AI Agents

Feature your project

The projects we add and every new guide. Free, unsubscribe any time.

Find open source alternatives to paid software

Dolt vs PlanetScale

Feature	Dolt	PlanetScale
License	Apache-2.0	Proprietary
Self-hosting	Yes	No
Data branching	Full rows and schema	Schema only
Wire protocol	MySQL	MySQL
Pricing	Free self-hosted	Managed service

Dolt vs Neon

Feature	Dolt	Neon
License	Apache-2.0	Proprietary
Self-hosting	Yes	No
Wire protocol	MySQL	PostgreSQL
Branching model	Commit-based history	Copy-on-write snapshots
Pricing	Free self-hosted	Managed service