Skip to main content

Try LoraDB in the Playground

The fastest way to try LoraDB is play.loradb.com. It runs LoraDB through WebAssembly in your browser tab, stores playground state locally, and needs no account or server.

Use it for learning the query surface, reducing a bug report, drafting examples, or checking a small graph shape before moving the query into Node, Python, WASM, Go, Ruby, Rust, or the HTTP server.

What you get​

SurfaceWhat it does
EditorQuery tabs, LoraDB-aware highlighting, completion, diagnostics, formatting, parameter detection, and Cmd/Ctrl+Enter to run
ParamsPer-query JSON params panel for $name placeholders, with missing-param checks before execution
ResultsGraph, table, JSON, and parser/analyzer views over the active query
SidebarSaved queries, schema browser, snapshots, history, and settings
Local persistenceIndexedDB and localStorage keep saved queries, snapshots, settings, history, and the auto-restored graph on the browser origin
Share linksCopy a URL with the active query encoded in the #q= hash

Run a first query​

Open play.loradb.com, paste this seed query, and run it:

CREATE (:Person {name: 'Ada', city: 'London'});
CREATE (:Person {name: 'Grace', city: 'New York'});
CREATE (:Person {name: 'Linus', city: 'Helsinki'});
MATCH (a:Person {name: 'Ada'}), (g:Person {name: 'Grace'}), (l:Person {name: 'Linus'})
CREATE (a)-[:KNOWS {since: 1843}]->(g);
MATCH (g:Person {name: 'Grace'}), (l:Person {name: 'Linus'})
CREATE (g)-[:KNOWS {since: 1991}]->(l);

Then run:

MATCH (p:Person)-[r:KNOWS]->(friend:Person)
RETURN p, r, friend

The graph result tab shows the people and relationships. The table and JSON result tabs show the same rows in more compact forms.

Share a query​

The Share action copies a URL that carries the active query body and, when present, the active params JSON. It does not include your database, saved queries, snapshots, history, or settings.

For a reproducible example with data:

  1. Run the seed query.
  2. Open Snapshots and create a snapshot.
  3. Export the snapshot file.
  4. Share the snapshot file and the query link together.

The query URL uses the hash fragment (#q=...) so the static export can refresh cleanly. Very large queries can produce long URLs; when in doubt, share a snapshot and keep the query short.

Use parameters in playground examples​

Application code should use parameters, and the playground can run them too. Write $name placeholders in the query, open the Params panel, and provide a JSON object:

MATCH (p:Person {name: $name})
RETURN p
{ "name": "Ada" }

For tiny docs examples that should run without opening the Params panel, trusted inline literals are still fine:

MATCH (p:Person {name: 'Ada'})
RETURN p

When you move the query into an application binding, switch to parameters:

await db.execute(
  "MATCH (p:Person {name: $name}) RETURN p",
  { name: "Ada" },
);

Boundaries​

  • The playground runs in one browser tab and is best for small local graphs, examples, and debugging.
  • The hosted app has no account, no sync, and no shared database.
  • Clearing browser site data clears local playground state.
  • The Cancel button drops a pending result from the UI, but the underlying WASM call currently runs until it returns.
  • Full explain / profile plans are available through bindings and HTTP endpoints. The playground's Plan tab is an editor analysis view.
  • WASM is snapshot-only. For WAL-backed durability, use a filesystem binding or the HTTP server.

Move from playground to code​

The query text moves directly into a binding; only host values and persistence setup change.

Next stepGuide
Run the query in a Node or TypeScript appNode
Run it from PythonPython
Embed the same WASM package yourselfBrowser (WASM)
Put it behind a local HTTP processHTTP server
Keep a durable filesystem-backed graphWAL and checkpoints

See also​