Prismaliser draws your Prisma schema without a server

Parsing in the browser, not on a server

Prismaliser is a visualisation web application for Prisma schemas, and it allows you to visually explore your schema and the relations between your models by showing links between the different types of relations, in the manner of an entity relationship model. The implementation detail that shapes everything else is stated in the next sentence. It is a fully open-source, fully client-side web application, where parsing and rendering all happen in your browser via Prisma's schema WASM module. That single choice removes a whole class of concern. A schema is a description of your database, complete with connection strings in the datasource block and occasionally a field that should not be in a URL, and a tool that uploads it to a server to draw a picture is a tool you have to think about. Here there is nothing to think about, because the browser does the work, and the build output is static files. A hosted version is available at prismaliser.app for anyone who does not want to run it themselves.

The graph shows three kinds of relation

The value of the diagram is in the relation types rather than in the boxes. The application shows links between the different types of relations in the schema, many to many, one to many and one to one, which is exactly the vocabulary an entity relationship diagram uses. That matters because a Prisma schema expresses the same distinctions in different syntax depending on whether the relation is enforced and which side owns it, and reading the schema file to work out which is which is tedious. A diagram makes the asymmetry visible, since a one to many relation and its reverse look the same in the schema text but not on the canvas. The canvas itself is built on reactflow, which is the standard React library for node and edge diagrams, and the layout is computed with elkjs, the Eclipse Layout Kernel compiled to JavaScript, which is what turns a set of models and relations into a readable arrangement instead of a hairball.

Building it is a Vite project with three commands

Prismaliser is a Vite single page application, so it needs Node.js installed to build it, and the README specifies version 24 or newer, with Yarn recommended because of its nicer command line interface. With Node installed and the repository cloned, three commands get it running:

yarn install  # or `npm install`
yarn build    # or `npm run build`
yarn start    # or `npm start`

The build outputs plain static files to dist/, so you can serve that directory with any static file server instead of using yarn start, which runs vite preview. That is the detail that makes the self-hosting story work, since a dist/ directory is the easiest thing in the world to put behind a CDN or a plain file host. For development there is a separate pair of commands, an install and then yarn dev, which runs the Vite dev server with hot reloading. The production build script runs the TypeScript compiler with no emit before Vite builds, so a type error fails the build rather than shipping.

The container and the origin variable

A Docker image is published, and it is a two stage build: a Node 24 Alpine builder that installs with yarn using the immutable flag and builds the app, and then a Caddy image that serves the built dist/ directory and exposes port 80. The run command needs one environment variable:

$ docker run -p 3000:80 \
    -e PRISMALISER_ORIGIN=https://your-public-origin.example \
    ghcr.io/ovyerus/prismaliser

The value has to be the exact public HTTPS origin without a trailing slash, and the reason is the OAuth metadata that the application serves to the AT Protocol provider, which has to point back at your own domain. The consequence of getting it wrong is spelled out, since if the variable is omitted or invalid, account connection is disabled while local editing, schema-only links and legacy links remain available. That is a deliberate graceful degradation, but it is worth setting correctly on the first run rather than discovering later that sharing does not work.

Sharing writes to your own AT Protocol repository

The sharing model is the most distinctive part of the project and the part to read carefully. When you publish a diagram, Prismaliser creates a public immutable record in your own AT Protocol repository and uploads the Prisma schema as a public text/plain blob, and the shared record contains the blob reference and the node positions, so anyone with the link can view the same diagram. The warning in the documentation is direct, that both the record and the schema blob are public, and that you should check for passwords, connection strings and other secrets first. That is an important caveat, because a schema is usually treated as internal information, and this feature turns it into a public document with one click. Schema-only links require no account and remain supported for old links. For self-hosting on plain static hosting you replace oauth-client-metadata.json with the same metadata values using your exact HTTPS origin for the client id, client uri and redirect uris, and the Docker image uses the origin variable shown above. The project also states that it never asks for a password or an app password, and that account connection uses the AT Protocol browser OAuth flow and the provider's own authorisation page.

What the dependencies reveal about the interface

The dependency list is a description of the application. The graph canvas is reactflow, the layout is elkjs, the schema text is edited in Monaco through the React wrapper, and html-to-image handles the export of the diagram as an image. The AT Protocol side is the atcute family, with the client, the identity resolver, the lexicons and the OAuth browser client, and the Prisma schema parser is Prisma's own schema WASM package, applied as a patch through Yarn, which tells you the upstream package needed a change for this use. Tailwind 4 provides the styling through its Vite plugin, and the SVG handling is the standard svgr toolchain. The project also uses a lexicon generation step, with a lex config file and a lexicons/ directory in the tree, and the scripts check that the generated lexicons match what is committed. The tests run under vitest and the linting is eslint with a config named for clarity.

A quiet release history and an open roadmap item

The release history looks dormant but the repository is not, and the two facts need to be read together. The tagged releases are v1.0.0 from 2021-07-25 and v1.0.1 from 2021-07-28, while the last push to the repository was on 2026-07-28, five years later. The project is developed and maintained, but the published versions have not been cut since 2021, so anyone installing from the registry is getting code that predates the current toolchain, and the sensible path for a new user is to build from the repository. The roadmap is maintained in the README with three items already ticked, multi-history support through the shares manager, sharing schema-only links and immutable public snapshots, and saving and restoring node positions in shared snapshots. The one open item is editor autocomplete, described as very big, with Monaco fiddly to work with and a note that the author would probably need to look at the VSCode plugin for Prisma for ideas. The repository also keeps a Caddyfile for the container, a Nix flake, renovate for dependency updates and a set of agent instructions, and the licence is MIT.

Editorial conclusion

Prismaliser fits a team that wants to look at a schema without shipping it anywhere, since the parsing runs in the browser and the build output is static files you can drop on any host, which is also why it suits an air-gapped or self-hosted setup. It does not fit a team whose schema contains secrets and who expects the tool to be private by default, because sharing a diagram publishes the schema as a public blob, and the documentation says so plainly. It does not fit a team that wants a maintained editor, since the one open roadmap item is autocomplete and the author describes Monaco as fiddly to work with. Before you share a diagram, read the section on AT Protocol sharing and check the schema for passwords and connection strings, and if you self host, set the origin variable to the exact HTTPS origin, since an invalid value silently disables account connection.

Frequently asked questions

Official sources

1. License: MIT
2. Ovyerus/prismaliser on GitHub
3. Project website
4. README
5. Releases