Built on Electric Clojure

Serve live Clojure objects and link to them in a web navigator 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.

The simplest possible agent: expose (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), start a REPL, and paste one line at a time:

REPL

;; Start a REPL with snapshot updates enabled
$ 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

The result: a navigable, sortable table of every loaded namespace — live, from your REPL, in like 5 lines of code. Live example: demo.clojure.net/clojure.core$all-ns.

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 {(all-ns) {* [ns-name ns-publics]}})

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)

Connect and get a live URL. No frontend code, no ports to open, no server to deploy.

Try it yourself

Datomic schema viewer in 20 LOC

Bring your own classpath. Write a Datomic query as an ordinary Clojure function, name the columns to display, and connect. The agent receives a live *db* via the third argument to connect! — dependency-injected bindings, so the agent only sees what you provide:

REPL

;; 1. Write your query — an ordinary Clojure function
(require '[clojure.repl.deps :refer [add-libs]])
(add-libs '{com.datomic/peer {:mvn/version "1.0.7187"}})
(require '[datomic.api :as d])
(def ^:dynamic *db*)
(def conn (do (d/create-database "datomic:mem://scratch") (d/connect "datomic:mem://scratch")))
;; (def conn (d/connect "datomic:dev://localhost:4334/mbrainz-1968-1973"))
(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
(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}
                                          {:db/cardinality :db/ident}]}})})

;; 3. Connect — get a public URL instantly
(agent/connect! "wss://index.clojure.net/agent" sitemap
  (fn [] {#'*db* (d/db conn)}))

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

Going further

Datomic entity browser

Built with this stack, hyperfiddle/datomic-browser is a polished Datomic observability tool providing out of the box Datomic entity navigation, EAVT index lookup, entity history and schema, tested on very large Datomic databases. Built entirely with HFQL sitemaps.

Live demo (MusicBrainz): datomic-browser.clojure.net

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.
Service-intermediated PII-safety architecture. In regulated environments, restricting access to PII is essential. The hyperfiddle-agent architecture powering these demos means all PII access is service-intermediated by your backend functions, giving you a central control point to defend your PII.

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

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

satellites

Track orbital positions via CelesTrak TLE

Browse all demos at: https://demo.clojure.net/.