Serve live backend objects, and link to them, in a web navigator UI
One function call turns your live service backend into a navigable web app. Namespaces, databases, Java objects, files — anything with structure becomes browsable. No frontend code, no build step, no deployment.
TODO: Death star demo video
Weave your backend service functions into a bespoke enterprise frontend
Complex forms, million row datasets, custom rules, no problem. Hyperfiddle is architected to scale to ultra-complicated custom frontends for arbitrary enterprise services with diverse architectures and data models.
Classpath-embedded, no REST APIs! Browse, query, and operate any enterprise service, object, database or backend data source, via direct classpath function calls.
Navigate enterprise service backends, the file system, internal service state — literally any object on your classpath.
Not just "data": navigate actual Java objects via method-call navigation.
B2B SaaS CTO: “We must have total control over our backends. But if we can spend almost no time on the UI and glue code — we can bypass the whole engineering planning cycle!”
Serve a function on your classpath in 5 LOC
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:
;; 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"}
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"}}}
(hfql {(all-ns) {* [ns-name ns-publics]}})
(agent/connect! url sitemap)
Datomic schema viewer in 20 LOC
Bring your own classpath. Write a query as an ordinary function, name the columns to display, and connect — the agent receives a live *db* by dependency injection, so it only sees what you provide.
;; 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")))
(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)}))
Polished example: a high quality Datomic entity browser
Built with this stack, 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. It's built entirely with HFQL sitemaps!
This example is not just a demonstration. We offer Datomic Browser as a first class product! See the Datomic Browser solution built on Navigator →
What you can browse
Anything you can write a function for becomes browsable — databases, JVM internals, network APIs, the filesystem. Some sitemaps that already exist:
Navigate branches, commits, diffs, blame
Walk a recursive file tree via Java NIO
Inspect threads, heap, GC via MXBeans
Diagnose deadlocks, stack traces, CPU time
Browse a Java Spring product catalog
See running processes, top CPU/mem
Search Maven Central artifacts
Resolve deps.edn, walk the dependency tree
Explore internet routing tables, AS prefixes
Check file stores, partitions, usage
Query Open-Meteo forecasts, no API key
Track orbital positions via CelesTrak TLE
Web-based, designed for internal production use
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.
Programmable! The builtin functionality is only 300 LOC: nav_datomic.clj. Fork it! Program it! Customize it!
Service embedded, no REST APIs
Stop wasting months building 100s of REST APIs! The Hyperfiddle server SDK uses direct classpath linking to call your functions directly, without web framework glue code.
Classpath-embedded. Browse, query, and operate any enterprise service, object, database or backend data source, via direct classpath function calls.
Never write a REST API ever again!
Neobank VP Eng: "As a digital bank, we have sophisticated customer service. We looked at Retool but a good interactive dashboard has 20-50 apis to build out and I don't want to build APIs for all of this."
Service-intermediated PII-safety architecture
In regulated environments, restricting access to PII is essential. The Hyperfiddle connector ships as an agent library that embeds inside your existing services. It doesn’t connect directly to any databases by URI — instead, it uses direct classpath linking to reuse the same backend queries that your service already has. That means all PII access is service-intermediated by your backend functions, giving you a central control point to defend your PII.
No direct database URIs. The Hyperfiddle agent embeds inside your services and sees only what your code binds. Unlike general-purpose DB browsers, it never connects directly to a production database, so centralized PII controls at your service boundary remain in force.
Service-intermediated query. Securely embed as a Java lib with no direct database access; invoke your actual service query endpoints through your existing ring middleware (auth, etc.), with dependency injection, PII protection, and built-in slow-query supervision.
Bring your own auth. Authentication and authorization are delegated to whatever the enclosing service already uses. Audit logs flow through your existing application logging.