Built on Electric Clojure

Browse your live Clojure objects in a web UI

One function call turns your live REPL into a navigable web app. Namespaces, databases, Java objects, files — anything with structure becomes browsable. No frontend code, no build step, no deployment.

Example: browse a live Datomic database schema from your REPL. Write a query, define what columns to show, call connect! — the result is the navigable web UI below.

REPL

;; 1. Write your query — an ordinary Clojure function
(require '[datomic.api :as d])
(def ^:dynamic *db*)
(defn schema []
  (d/q '[:find [(pull ?e [:db/ident
                          {:db/valueType [:db/ident]}
                          {:db/cardinality [:db/ident]}
                          *]) ...]
         :where [?e :db/valueType _]] *db*))

;; 2. Add one dependency, define what columns to show
(require '[clojure.repl.deps :refer [add-libs]])
(add-libs '{com.hyperfiddle/hyperfiddle-agent {:mvn/version "v0-alpha-SNAPSHOT"}})
(require '[hyperfiddle.navigator-agent :as agent] '[hyperfiddle.hfql2 :refer [hfql]])
(def sitemap {`schema (hfql {(schema) {* [:db/ident
                                          {:db/valueType {:db/ident name}}
                                          {:db/cardinality {:db/ident name}}]}})})

;; 3. Connect — get a public URL instantly
(agent/connect! "wss://index.clojure.net/agent" sitemap
  (fn [] {#'*db* (d/db (d/connect "datomic:dev://localhost:4334/mbrainz-1968-1973"))}))

Datomic schema browser showing database attributes with db/ident, valueType, and cardinality columns

The result: a navigable, sortable table of every schema attribute in the database — live, from your REPL, with no frontend code.

How it works

Three moving parts: a dependency, a sitemap describing what to show, and a single function call to go live.

{:deps {com.hyperfiddle/hyperfiddle-agent {:mvn/version "v0-alpha-SNAPSHOT"}} :mvn/repos {"clojars" {:url "https://repo.clojars.org/" :snapshots {:update :always}}}}

Add one dependency. No build step.

(hfql {(schema) {* [:db/ident :db/valueType :db/cardinality]}})

Describe what to show. Each sitemap entry becomes a navigable page — the HFQL query defines the data and which columns to render.

(agent/connect! url sitemap (fn [] {#'*db* (d/db conn)}))

Connect and get a live URL. The third argument injects runtime bindings — the agent only sees what you provide. No ports to open, no server to deploy.

Try it yourself

Browse your loaded namespaces

The simplest possible agent. Exposes (all-ns) as a navigable page — click into any namespace to see its public vars, arglists and docstrings. Install Clojure 1.12+ (brew install clojure on macOS), open a REPL with clj, and paste:

REPL

$ clj -Sdeps '{:mvn/repos {"clojars" {:url "https://repo.clojars.org/" :snapshots {:update :always}}}}'
Clojure 1.12.3
(require '[clojure.repl.deps :refer [add-libs]])
(add-libs '{com.hyperfiddle/hyperfiddle-agent {:mvn/version "v0-alpha-SNAPSHOT"}})
(require '[hyperfiddle.navigator-agent :as agent]
         '[hyperfiddle.hfql2 :refer [hfql]])
(def sitemap {`all-ns (hfql {(all-ns) {* [ns-name ns-publics]}})})
(agent/connect! "wss://index.clojure.net/agent" sitemap)
;; => {:agent-id "a1b2c3d4" :agent-url "https://a1b2c3d4.clojure.net"}

Namespace browser showing clojure.core namespaces with ns-name and ns-publics columns

demo.clojure.net/clojure.core$all-ns live example

Going further

Datomic Browser

The namespace example is one query, one page. hyperfiddle/datomic-browser shows what happens when you add more: a multi-page Datomic entity browser with URL routing, pagination, search and drill-down — built entirely with HFQL sitemaps.

Datomic entity browser showing schema attributes with db/ident, db/valueType and other columns

datomic-browser.clojure.net live demo (MusicBrainz)

Web-based, designed for internal production use

Everything above works the same in production. Embed the agent in your deployed services, control what’s exposed, and give your team a web UI for production data.

Classpath-embedded. Ships as Ring middleware — drop it into any Clojure service or microservice. No sidecar, no separate deploy.
Your queries, your functions. Write ordinary Clojure functions — ORMs, custom query layers, whatever your stack uses. Any database backend: Datomic, XTDB, SQL, or your own data sources.
You control access. Database connections are dependency-injected — the agent only sees bindings you explicitly provide. You write the queries, so PII filtering and data redaction are handled in your code.
Enterprise-scale. Designed for huge datasets. Streaming virtual scroll over hundreds of thousands of rows. Long-running queries show elapsed time and can be cancelled mid-flight.

What can you browse

Anything you can write a Clojure function for becomes browsable. Databases, JVM internals, network APIs, the filesystem — here are some sitemaps that already exist:

git

Navigate branches, commits, diffs, blame

io/file

Walk a recursive file tree via Java NIO

jvm

Inspect threads, heap, GC via MXBeans

jvm-deep

Diagnose deadlocks, stack traces, CPU time

spring-ecommerce

Browse a Java Spring product catalog (coming soon)

weather

Query Open-Meteo forecasts, no API key

processes

See running processes, top CPU/mem

bgp

Explore internet routing tables, AS prefixes

disk

Check file stores, partitions, usage

maven

Search Maven Central artifacts

clojure-deps

Resolve deps.edn, walk the dependency tree (coming soon)

satellites

Track orbital positions via CelesTrak TLE

See all connected agents, their uptime, and regional deployments at index.clojure.net.