# Surrealist: the SurrealDB desktop app that became Studio

> Surrealist was the visual companion application for SurrealDB, letting you connect to any instance, run SurrealQL queries, explore tables, design schemas and manage SurrealDB Cloud, as both a Tauri desktop app and a web app. It has now been superseded by SurrealDB Studio, and the repository remains for historical reference and maintenance.

**surrealdb/surrealist** — Surrealist is the ultimate way to visually manage your SurrealDB database

- Repository: https://github.com/surrealdb/surrealist
- Website: https://app.surrealdb.com
- Stars: 1,309 · Forks: 122
- Language: TypeScript
- License: MIT
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/surrealdb-surrealist

## A companion app that has been formally succeeded

Surrealist was the original user interface for interacting with SurrealDB visually, and the readme is direct about its current status.

It let you connect to any SurrealDB instance, run queries, explore tables, design schemas, and manage SurrealDB Cloud, and it served as the primary companion app for SurrealDB for years.

It has been superseded by SurrealDB Studio, described as the successor to Surrealist and the recommended way to work with your data. Studio builds on what Surrealist started, with improved performance, easier navigation, and new ways to present your data. The pointers are to download SurrealDB Studio and to open Studio in the browser at studio.surrealdb.com.

The final line is the one that matters for an evaluation: this repository remains available for historical reference and maintenance of the Surrealist codebase.

That is an unusual thing for a project to state plainly about itself, and it is useful. A reader is not being walked into a dead project. The functional features are still described, the licence is still stated, and the last push was on 2026-10-03 with the release tag `surrealist-v3.9.13`, so the code is still receiving work even though the product line has moved.

The project is MIT licensed with the copyright held by SurrealDB Ltd for 2026, and the hosted version of the app is at app.surrealdb.com, with the website at surrealist.app appearing in the deployment configuration.

The topics give the shape of the thing: authentication, database, desktop, linux, macos, react, rust, schema, sql, surql, surrealdb, surrealql, tauri, webapp, windows. A Tauri shell, a React front end, and a Rust core, with both SurrealQL and SQL in the picture.

## A Tauri desktop app and a web app from the same front end

The repository layout is the clearest description of the architecture, and it shows a single front end shipping in two forms.

There is a `src/` directory for the web application, a `src-tauri/` directory for the Tauri shell, and an `index.html` and `vite.config.ts` at the root, so the front end is a Vite application. The `Makefile` has both a `serve` target that runs `bun tauri:dev` for the desktop app and a `deploy` target that syncs the built web assets to S3, which is the web deployment. The same React code, two delivery mechanisms.

The package manifest confirms the pieces. The scripts include `dev` for `vite`, `build` for `tsc && vite build`, `tauri` for `tauri`, `tauri:dev` and `tauri:build`. The `type` is `module` and the package manager is Bun, with a `bun.lock` and a `bunfig.toml` at the root, and `start` is `bun run dev`.

The quality tooling is worth noting because it is modern and specific. `qc` is `biome check .`, with `qa` and `qau` variants that write fixes, the latter with the unsafe flag, and `biome.json` at the root configuring it. There is a `qts` script that runs `tsc --noEmit` and a `qtsw` watch variant. A `license-report` script generates `src/assets/data/license-report.json` from the installed dependency tree, recording name, licence type, link, installed version and author for each package, which is a licence compliance artefact committed into the application's own assets.

There is also a `patches/` directory and a `shims/` directory, plus a `skills-lock.json` and an `AGENTS.md`, a `REVIEW.md` and a `CLAUDE.md`, and a `.claude/` and `.cursor/` directory. The agent-facing configuration is now a standard part of how this repository is worked on.

## The query editor is a full CodeMirror with a Lezer grammar per language

The dependency list for the query editor is the most detailed part of the manifest and the most telling.

CodeMirror is there in full, with `@codemirror/view`, `state`, `commands`, `language`, `autocomplete`, `search` and `lint`, and the `@codemirror/legacy-modes` package. The lint package in particular means the editor reports diagnostics inside the buffer rather than only in a panel, which is what makes a query editor feel like a development tool rather than a text area.

The Lezer parsers are where the language support comes from. There is one per language the application cares about: `@lezer/common`, `@lezer/highlight`, and then `@lezer/bash`, `@lezer/go`, `@lezer/html`, `@lezer/javascript`, `@lezer/json`, `@lezer/php`, `@lezer/python`, `@lezer/rust` and `@lezer/yaml`. Each of those is a grammar for a language the app can highlight, which suggests the editor is not limited to SurrealQL and that the schema and configuration editors are syntax-aware in their own languages.

The `surreal` dependency at 2.0.0 is the SurrealDB client library itself, so the application talks to the database through the official client rather than by hand-rolling HTTP calls.

The UI layer is Mantine, with `@mantine/core`, `@mantine/hooks`, `@mantine/modals`, `@mantine/notifications`, `@mantine/dates` and `@mantine/charts` all pinned at 9.0.2, which is the chart library for the data exploration features. Drag and drop is `@dnd-kit` with `core`, `modifiers`, `sortable` and `utilities`, and icons are `@mdi/js` with `lucide-react` as the other icon set.

The authentication picture is also here, and it is a detail worth noticing. `@auth0/auth0-react` is the Auth0 React SDK and `@intercom/messenger-js-sdk` is the Intercom widget, which points at a hosted sign-in for the Cloud management features and a support chat, rather than credentials being handled only inside the app.

## A Rust core compiled to WebAssembly, and a deployment with a CDN wrinkle

The `setup` target in the Makefile is the clearest statement of the build, and it involves three tools.

```bash
rustup target add wasm32-unknown-unknown
cargo install wasm-bindgen-cli
bun install
```

So there is a Rust component compiled to WebAssembly and bound to JavaScript with wasm-bindgen. That is a deliberate choice, and the repository explains its motivation in a comment: the `build` script has `COPY ./src/ ./` and the note that the environment should be cached from the previous step if the toml and lock files have not changed. The Rust core is part of the shipped web application, not just the desktop shell, and the build cache is arranged so a front-end change does not rebuild the WebAssembly.

That is an interesting design for a database GUI. A query planner, a formatter, or a schema parser written in Rust and shipped as WebAssembly gives the same performance in the browser and in the desktop app, and it means the web deployment is not a degraded version.

The `deploy` target shows how the artefacts are published, and there is a wrinkle in it worth reading carefully. The assets are synced to S3 with a long cache lifetime, and the WebAssembly files are synced separately with gzip content encoding. The service worker is uploaded with a five second cache, and the HTML with a thirty second cache and exact timestamps and a delete flag, so that a new deployment replaces the entry point immediately while the hashed assets stay cached for a year.

The `netlify.sh` and `netlify.toml` files at the root show a Netlify path as well, alongside the S3 one, and a `docker/` directory for a containerised deployment.

## Where Surrealist is the wrong thing to reach for

The first and simplest case is a new project. The product has been succeeded, and the successor is SurrealDB Studio, available as a download or in the browser. Starting a new evaluation of SurrealDB against this repository rather than Studio means evaluating a codebase the vendor has moved past, and any bug you file will be triaged against a product that is no longer the one people are pointed at.

The second case is a team that only needs a query client. A database client is a solved problem and the browser-based Studio covers it, whereas this application is a full desktop application with a Tauri shell, a Rust WebAssembly core, a bundled CodeMirror with ten language grammars, an Auth0 integration, an Intercom widget and a chart library. That is a lot of surface for someone who wants to run a query and look at a table.

The third case is a deployment where the S3 and Netlify assumptions do not hold. The build output is designed to be published to a bucket with immutable hashed assets, a short-lived service worker and a thirty second HTML cache, and the `deploy` target writes to a bucket in a specific region. Adapting that to a different hosting model is work, and the web build is the harder one to relocate because of the WebAssembly and the caching scheme.

The fourth is a project that wants to extend the application. The `patches/` and `shims/` directories, the `tools/` directory and the `AGENTS.md` file suggest an active development setup, but the fact that the product line has moved to a separate successor means a fork of Surrealist starts from a codebase the vendor is no longer building features into.

One positive note. The `license-report` script generating a committed JSON of every dependency's licence is a practice worth copying whatever you build, because it turns licence compliance into a build artefact rather than a document someone maintains by hand.

## Conclusion

Surrealist is worth reading if you want to understand how a database GUI is put together, since it is a complete Tauri, CodeMirror and Mantine application with a real query editor, but it is not the tool to start a new project with. Before doing anything with it, note that the successor is SurrealDB Studio, available as a download or in the browser at studio.surrealdb.com, and that this repository is described as available for historical reference and maintenance of the Surrealist codebase.

## FAQ

### What is Surrealist and what does it do?

It was the original visual user interface for SurrealDB, letting you connect to any instance, run queries, explore tables, design schemas and manage SurrealDB Cloud. It served as the primary companion app for SurrealDB for years and ran as both a Tauri desktop app and a web app.

### Has Surrealist been replaced?

Yes. It has been superseded by SurrealDB Studio, the successor and the recommended way to work with your data, with improved performance, easier navigation and new ways to present your data. The repository remains available for historical reference and maintenance of the Surrealist codebase.

### How is Surrealist built?

The front end is a Vite and React application in TypeScript with a Rust core compiled to WebAssembly through wasm-bindgen, wrapped as a Tauri desktop app. The setup target adds the `wasm32-unknown-unknown` Rust target, installs `wasm-bindgen-cli` and runs `bun install`.

### What editor and UI libraries does Surrealist use?

CodeMirror with the lint, autocomplete and search packages for the query editor, Lezer grammars for bash, go, html, javascript, json, php, python, rust and yaml, Mantine for the interface with its charts package, dnd-kit for drag and drop, and the official `surreal` client at version 2.0.0 to talk to the database.

## Sources

- [License: MIT](https://github.com/surrealdb/surrealist/blob/main/LICENSE)
- [Project website](https://app.surrealdb.com)
- [README](https://github.com/surrealdb/surrealist/blob/main/README.md)
- [Releases](https://github.com/surrealdb/surrealist/releases)
- [surrealdb/surrealist on GitHub](https://github.com/surrealdb/surrealist)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/surrealdb-surrealist