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 lean on host shims Jolt provides). See the examples repository for runnable projects.

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 — 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 (hashing, HMAC, ciphers); backs ring-defaults' session/CSRF crypto.
• time — the formatting and zone layer of java.time (DateTimeFormatter, ZoneOffset/ZoneId, ZonedDateTime/OffsetDateTime, named-zone offsets and DST, 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.
• instaparse — context-free grammars (EBNF/ABNF) turned into parsers: left-recursive and ambiguous grammars, PEG-style lookahead, hiccup and enlive output, detailed error reporting. A port of Engelberg/instaparse.
• router — 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 — GTK-based reactive UI toolkit.
• glimmer-gl — OpenGL primitives for Glimmer.
• ring-chez-adapter — Ring adapter for serving HTTP.
• multipart — RFC 7578 multipart/form-data parser (incremental push parser and parse-form-data), ported from defnull/multipart; splits request bodies into :params and :files for ring.

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.
• 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 or a Java class to shim — see Host Interop.