Libraries

Two kinds of libraries run on Jolt. Jolt libraries are first-party packages from the jolt-lang org; many bind native code through Jolt's FFI to cover ground the JVM would get from java.*. JVM libraries are ordinary Clojure/JVM libraries that load and pass their conformance checks on Jolt unchanged, a few leaning on host shims Jolt provides. See the examples repository for runnable projects.

Community-maintained libraries and tooling live at jlt-commons — a community-led home, supported by the core team, for adopted projects whose original maintainers moved on and for new libraries the core team does not want to own.

Jolt libraries

First-party libraries from the jolt-lang org.

• db: Postgres and SQLite access (jdbc.core), binding libpq and libsqlite3 through the FFI.
• http-client: HTTP client over POSIX sockets, OpenSSL (TLS), and zlib.
• xml: clojure.xml/parse (libxml2) plus a clojure.data.xml emit API.
• yaml: YAML load/dump over the system libyaml (jolt.yaml, clj-yaml.core compat).
• crypto: OpenSSL FFI for hashing, HMAC, and ciphers; backs ring-defaults' session/CSRF crypto.
• time: the formatting and zone layer of java.time (DateTimeFormatter, ZoneOffset/ZoneId, ZonedDateTime/OffsetDateTime, localized formatting, java.util.Locale) plus tick's idiomatic API. The base value types (Instant, LocalDate, Duration, Period, Year/YearMonth, ...) are in core with no dependency; this library adds the rest (RFC 0008).
• transit-jolt: Transit (JSON) read/write.
• jolt-fressian: Fressian binary serialization, the format Datomic and clojure.data.fressian use. Wire-compatible both ways, gated against a real JVM Fressian reader and writer.
• instaparse: context-free grammars (EBNF/ABNF) turned into parsers, a port of Engelberg/instaparse: left-recursive and ambiguous grammars, PEG-style lookahead, hiccup and enlive output, detailed error reporting.
• router: a routing trie that mirrors reitit.Trie, so reitit runs on Jolt.
• logging: logging API with a native backend (drives clojure.tools.logging).
• otel: OpenTelemetry SDK: tracing (with-span, W3C Trace Context propagation) and metrics (counters, histograms), exported over OTLP via http-client. Reads the standard OTEL_* environment variables; every API has a no-op fallback.
• mulog: structured event logging and tracing, a port of BrunoBonacci/mulog: log events with global/lexical context, trace with flake trace IDs, duration, and error capture, buffered dispatch to publishers (console built in). The Java classes it bundles (flake event IDs, NanoClock, the timer pool) are supplied as portable Jolt registrations; flakes are bit-for-bit with the JVM's.
• nrepl: nREPL server and client for editor connections.
• glimmer: reactive UI toolkit: Reagent-style reactive atoms, components that return hiccup, and a reconciler that patches the live widget tree in place (positional and keyed). Widgets come from a backend, so the same components render as GTK widgets or as text in a terminal.
• glimmer-gtk: the GTK4 backend for glimmer: widget constructors, prop setters and :on-* signals bound through the FFI, Pango markup from hiccup, and the g_application_run app loop (including the main-thread marshalling that keeps nREPL-driven UI development safe).
• glimmer-tui: the terminal backend for glimmer, over ncursesw: a widget set, box layout, painting, and an input loop with keyboard focus and mouse support. Binds only the ncurses 6.0 API, which macOS and Linux already ship, so a terminal UI needs nothing installed. A screen abstraction with an in-memory implementation lets an interactive app be mounted, typed into, and asserted on without a tty.
• glimmer-gl: OpenGL primitives for glimmer: composable 3D geometry and shaders-as-data, plus :gl-area and :scale widgets registered into glimmer-gtk so a GL pane lives in the same reactive tree.
• ring-chez-adapter: Ring adapter for serving HTTP, with the middleware whose Ring originals need a JVM library: file uploads (an RFC 7578 multipart/form-data parser ported from defnull/multipart, incremental or all at once), gzip, and static files.

JVM libraries

Third-party Clojure/JVM libraries confirmed to run on Jolt.

Web and routing

• ring-core: via :deps/root "ring-core", on the ring-app example.
• ring-codec: URL/form encoding.
• ring-defaults: the standard middleware stack (params, static resources + content-type, session, security headers); session/CSRF crypto via crypto.
• reitit-core: data-driven routing; the reitit.Trie Java class is mirrored by router.
• integrant: data-driven system configuration (#ig/ref), with its dependency and meta-merge deps.

Data and schemas

• malli: data schema validation, on the malli-app example.
• honeysql: SQL formatter and helpers.
• clojure.data.json: JSON reading and writing.
• clojure.spec.alpha: data specs.
• core.match: pattern matching.
• core.cache: caching (Basic/FIFO/LRU/LU/TTL/Soft + wrapped), over data.priority-map.
• core.memoize: function memoization over core.cache.
• core.async: CSP channels and go blocks (<!/>!/alts!, pipeline, mult/mix/pub/sub), on real OS threads or on fibers.
• core.logic: relational logic programming (unification, run/fresh/conde, finite domains).
• math.combinatorics: permutations, combinations, subsets, selections, cartesian products, partitions.
• core.contracts: programming by contract (contract/with-constraints/provide), over core.unify.
• data.zip: zipper navigation, including clojure.data.zip.xml; XML via xml.
• data.csv: reading and writing CSV.
• data.codec: base64 encode/decode over byte arrays.
• data.priority-map: priority maps (keyfn / custom comparator), with subseq/rsubseq.
• tools.macro: local macros (macrolet/symbol-macrolet), mexpand/mexpand-all.
• algo.monads: monad macros and monads (maybe/seq/state/writer/reader/...), over tools.macro.
• test.check: property-based testing (generators, quick-check, shrinking).
• tools.cli: command-line argument parsing.
• tools.reader: a Clojure reader in Clojure (edn + full reader, indexing/pushback reader types).
• rewrite-clj: parse/rewrite Clojure source while preserving whitespace and comments (nodes + zipper), over tools.reader.
• edamame: configurable EDN/Clojure parser with source locations (parse-string, parse-next, syntax quote, reader conditionals, auto-resolve).
• yamlstar: YAML load/dump (pure-Clojure parser, JSON-safe integer policy).
• medley: collection utilities.
• ordered: insertion-ordered map and set (ordered-map/ordered-set), with transients and #ordered/map / #ordered/set reader tags.
• config: environment configuration.
• aero: EDN configuration with tag literals (#ref/#env/#or/#profile/#long/...).
• mount: application state lifecycle (defstate, start/stop/swap, restart-on-recompile).

Databases

• clojure.jdbc: via db's jdbc.core, over built-in SQLite access (libsqlite3 through Chez's FFI).
• migratus: database migrations over db.

Templating, markup, text

• Selmer: Django-style templates.
• hiccup: HTML from Clojure data, on the hiccup-app example.
• markdown-clj: Markdown to HTML, on the markdown-app example.
• cuerdas: string manipulation.
• camel-snake-kebab: word-case conversions.
• clj-rss: RSS feed generation, over xml's clojure.data.xml emit.
• text-diff: line-level diffing in diff -u unified format, with ANSI colorization.

Date and time

• tick: runs on Jolt through time, which adds the formatting/zone layer over core's base java.time and bundles tick and its #time/... literals.

Logging

• tools.logging: runs verbatim over a native clojure.tools.logging.impl stderr backend.

Loading a JVM library is per-function: a namespace can load with most functions working and a few not. If something is missing, it's usually a clojure.core function Jolt doesn't implement yet, a Java class to shim, or a method missing from a class Jolt part-shims; the last two you can supply from your own project without waiting for a release. See Host Interop.