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.
  • 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.
  • 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.
  • multipart: RFC 7578 multipart/form-data parsing (multipart.core), ported from defnull/multipart: an incremental push parser or all-at-once parse-form-data, plus application/x-www-form-urlencoded bodies. Backs ring-chez-adapter's upload middleware; http-client checks the bodies it builds against it.
  • ring-chez-adapter: Ring adapter for serving HTTP, with the middleware whose Ring originals need a JVM library: file uploads (via multipart), gzip, and static files.

Community libraries

Community-maintained libraries and tools from the jlt-commons org.

  • awesome-jolt: the community's curated list of Jolt tools and libraries.
  • aws-api-jolt: cognitect aws-api running on Jolt, the unmodified Maven release against real AWS.
  • duratom: durable atoms that persist to disk, a port of jimpil/duratom.
  • ebb: a functional effect and streaming system, a port of leonoel/missionary.
  • ensemble: lightweight Erlang-style actors with mailboxes and supervisors, a port of puniverse/pulsar.
  • ftxui-jolt: a functional terminal UI built on FTXUI.
  • glitter: a Replicant-style GTK4 renderer: one state atom, a pure state-to-hiccup view, and event handlers as data.
  • glitter-core: the natives-free core of glitter: the reconciler and the IRender/IMemory protocol seam.
  • glitter-gl: OpenGL for glitter: composable meshes, shaders as data, and a :gl-area GTK4 widget.
  • glitter-uikit: an AppKit renderer for glitter driving native macOS views; see uikit-demo.
  • 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.
  • lev: a Jolt implementation of Laya's non-autoregressive System 1 decision engine.
  • 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.
  • nexus-jolt: data-driven action, effect, and placeholder dispatch, a port of cjohansen/nexus.
  • raygui-jlt: 24 raygui examples: raylib's immediate-mode GUI called from Jolt over the C ABI.
  • raylib-jlt: 187 raylib examples binding libraylib 6.0 directly over its C ABI; the same scenes run on iPhone and Android as native code.
  • tapestry: structured concurrency: a fiber is a derefable handle to a unit of concurrent work on its own thread, and results, errors, timeouts, and cancellation all flow through that handle. Cancellation is cooperative, over core.async, since Jolt has no JVM thread interruption.
  • writ: checks plain Clojure against a spec of what the code is for: signatures for the public functions and laws that say what the results mean. Built for LLM-written code, the spec is written first, the implementation second, and writ is the gate between them. Laws run on generated inputs and are proved by rewriting, induction, or a solver.

JVM libraries

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

Web and routing

Data and schemas

  • malli: data schema validation, on the malli-app example.
  • honeysql: SQL formatter and helpers.
  • clojure.data.json: JSON reading and writing. Ships with Jolt; writing a java.time.Instant needs time.
  • 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

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.