Awesome Jolt

• Language and Compiler
• Getting Started
• Official Libraries
• Community Projects
• Applications
• JVM and Clojure Libraries That Run on Jolt
• Tooling, Testing and Examples
• Documentation and Guides
• Ecosystem Infrastructure
• Related Projects
• Community and Support
• Contributing
• License

• jolt - The core project: a self-hosted Clojure implementation that compiles to Chez Scheme by default, or to Gambit compiled to JavaScript for the browser. Ships a Clojure-compatible standard library.

• Getting Started guide - Installation for Linux and macOS: prebuilt binaries, Homebrew, or building from source.
• homebrew-jolt - The Homebrew tap (brew install jolt-lang/jolt/jolt), a formula that installs prebuilt binaries or builds from source.
• deps.edn Internals - How Jolt resolves dependencies straight from git repositories with no Maven involved, cached at ~/.jolt/gitlibs.

First-party libraries maintained in the jolt-lang organization. Many bind native code through Jolt's FFI to cover ground the JVM would get from java.*.

Database and Storage

• db - jdbc.core for Jolt: PostgreSQL and SQLite access binding libpq and libsqlite3 through the FFI, running real clojure.jdbc and a next.jdbc-shaped surface with no JVM.
• doltera - A pure-Jolt MySQL-protocol client for Dolt, speaking directly to dolt sql-server over TCP: handshake, mysql_native_password auth, packet framing, and prepared statements.
• duratom - A durable, dereffable atom that persists every mutation to a pluggable backend. It implements glimmer's IReactiveCell protocol, so it drops into a glimmer app unchanged.

Networking and Web

• http-client - An HTTP client over POSIX sockets, OpenSSL for TLS, and zlib. Runs clj-http-lite unmodified.
• ring-chez-adapter - A Ring adapter for serving HTTP, binding BSD sockets directly through the FFI, plus middleware whose Ring originals need a JVM library: multipart file uploads, gzip, and static files.
• router - A routing trie that mirrors reitit.Trie, so reitit-core runs on Jolt unmodified.

Serialization and Parsing

• transit-jolt - Transit (JSON) read and write.
• jolt-fressian - Fressian binary serialization, the format Datomic and clojure.data.fressian use, wire-compatible both ways and gated against a real JVM Fressian reader and writer.
• xml - clojure.xml/parse over libxml2, plus a clojure.data.xml emit API.
• yaml - YAML load and dump over the system libyaml, with jolt.yaml and clj-yaml.core compatible APIs.
• instaparse - A port of Instaparse: EBNF and ABNF grammars turned into parsers, with left-recursive and ambiguous grammar support, hiccup and enlive output, and detailed error reporting.

Cryptography

• crypto - OpenSSL bindings through the FFI for hashing, HMAC, and ciphers. Backs ring-defaults' session and CSRF crypto.

Logging Metrics and Tracing

• logging - A logging API with a native backend that drives clojure.tools.logging.
• mulog - A port of BrunoBonacci/mulog: structured event logging with global and lexical context, tracing with flake trace IDs, duration, and error capture, buffered dispatch to publishers.
• otel - An OpenTelemetry SDK: tracing (with-span, W3C Trace Context propagation) and metrics (counters, histograms), exported over OTLP. Reads the standard OTEL_* environment variables, and every API has a no-op fallback.

Structured Concurrency

• tapestry - Structured concurrency primitives for Clojure on Jolt, backed by core.async fiber handles rather than manifold. Marked pre-1.0.

Date and Time

• time - The formatting and zone layer of java.time (DateTimeFormatter, ZoneOffset/ZoneId, ZonedDateTime/OffsetDateTime, localized formatting, java.util.Locale), plus tick's idiomatic API on top. The base value types (Instant, LocalDate, Duration, Period, ...) ship in core with no dependency; this library adds the rest.

Math and Primitives

• primitive-math - A compatibility port of primitive-math, so code written against it (clj-uuid's bit operations, for one) runs unchanged. Jolt has no primitive types, so this is about compatibility rather than speed.

Process and Shell

• process - The babashka/process library for shelling out and managing sub-processes.

The Glimmer GUI Toolkit

Glimmer is Jolt's reactive GUI toolkit. One portable core plus a backend per platform.

• glimmer - The portable core: Reagent-style reactive atoms, components that return hiccup, and a reconciler that patches the live widget tree in place. Widgets come from a backend, so the same components render as GTK widgets or as text in a terminal.
• glimmer-gtk - The GTK4 backend: widget constructors, prop setters and :on-* signals bound through the FFI, and the g_application_run app loop, including the main-thread marshalling that keeps nREPL-driven UI development safe.
• glimmer-tui - The terminal backend, over ncursesw: a widget set, box layout, painting, and an input loop with keyboard focus and mouse support. Needs nothing installed beyond what macOS and Linux already ship.
• glimmer-uikit - The AppKit backend: the same hiccup renders as real macOS NSWindow/NSStackView/NSButton widgets, driven through the Objective-C runtime by a plain C FFI.
• glimmer-gl - OpenGL primitives for glimmer: composable 3D geometry and shaders as data, plus :gl-area and :scale widgets registered into glimmer-gtk.
• glimmer-datastar - A web backend over Datastar: implements the server side of the Datastar v1.0 wire protocol, JSON signals on actions and datastar-patch-* SSE events, with no Ring middleware stack needed.

Projects maintained at jlt-commons, a community-led home for adopted Jolt libraries and for new work the core team doesn't want to own directly. Six of these arrived by transfer from their original maintainer, with stars, issues, and history intact; two were started here directly by Jolt's author. Each keeps its own release cadence and publishes its own docs at jlt-commons.github.io/<repo>/.

Graphics and Games

• raylib-jlt - 119 raylib examples in native Clojure, calling the system libraylib over its C ABI through jolt.ffi. Docs and gallery.
• raygui-jlt - 24 examples of raygui, raylib's immediate-mode GUI library, bound the same way. Docs and gallery.
• raylib-ios - raylib and SDL2 running on a physical iPhone as portable bytecode with no JIT, since iOS forbids generating code at runtime. Seventeen scenes at 60 fps. Parts derive from a demo repository whose own license request is still pending; see the repo's NOTICE. Docs and gallery.
• raylib-android - raylib on an Android phone as native arm64 code, with no JVM, Kotlin, or Java anywhere in the app. Seventeen scenes under an owner loop of about thirty lines.

GUI Rendering

• glitter - A Replicant-style GTK4 renderer: one state atom, a pure state -> hiccup view, and event handlers as data. Docs.
• glitter-gl - OpenGL geometry, matrices, and shaders for glitter, plus a :gl-area widget to draw them in. Docs.
• glitter-uikit - The same renderer model driving native macOS NSView widgets through AppKit instead of GTK4. Docs.

Concurrency

• ebb - A port of missionary: composable tasks and flows with real cancellation and glitch-free dataflow, running on Chez fibers.

Independently maintained software built with Jolt, hosted and maintained outside jlt-commons and jolt-lang.

• talk - An XMPP server speaking RFC 6120 (core) and RFC 6121 (IM and presence): SASL, SCRAM-SHA-256, resource binding, rosters, presence, offline delivery, and a Prosody-inspired module architecture.
• frq - A freeq IRC client, its screens built as glimmer components over Vidya/egui, ported from a Rust client of the same shape. Runs unchanged on desktop, in a terminal, and on Android.
• jolt-native - Native capabilities for Jolt, one shared object per capability: a retained-tree UI ABI over egui (also paintable to a terminal) and freeq's AV media plane over MoQ. What frq links against.

Ordinary Clojure/JVM libraries confirmed to load and pass their conformance checks on Jolt unchanged, a few leaning on host shims Jolt provides. Loading is per-function, so a namespace can load with most functions working and a few not. See the full compatibility list for the details behind each one.

Web and Routing

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

Data and Schemas

• malli - Data schema validation, on the malli-app example.
• honeysql - A 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, and 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, via xml.
• data.csv - Reading and writing CSV.
• data.codec - Base64 encode and decode over byte arrays.
• data.priority-map - Priority maps (keyfn or a 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, and more), over tools.macro.
• test.check - Property-based testing: generators, quick-check, shrinking.
• tools.cli - Command-line argument parsing.
• tools.reader - A Clojure reader written in Clojure, covering edn and the full reader, with indexing and pushback reader types.
• rewrite-clj - Parses and rewrites Clojure source while preserving whitespace and comments (nodes and a zipper), over tools.reader.
• edamame - A configurable EDN/Clojure parser with source locations (parse-string, parse-next, syntax quote, reader conditionals, auto-resolve).
• yamlstar - YAML load and dump: a pure-Clojure parser with a 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, and more).
• mount - Application state lifecycle (defstate, start/stop/swap, restart on recompile).

Databases

• clojure.jdbc - Via db's jdbc.core, over built-in SQLite access.
• migratus - Database migrations over db.

Templating Markup and 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 unified diff -u format, with ANSI colorization.

Date and Time

• tick - Runs on Jolt through time, which adds the formatting and zone layer over core's base java.time types.

Logging

• tools.logging - Runs verbatim over a native clojure.tools.logging.impl stderr backend.

• nrepl - nREPL middleware and client for editor connections, growing Jolt's built-in nREPL server into the op set editors like CIDER expect: sessions, completion, eldoc, macroexpand, tests, stack traces.
• clojure-test-suite - A clojure.core compliance test suite, originally built to characterize JVM Clojure's behavior for the jank native-code dialect, used here to validate Jolt's own conformance.
• examples - Runnable sample projects (an HTTP client and server, a Ring app, hiccup, Markdown, malli, a ray tracer, FFI) that double as a tour of the ecosystem. Each has a deps.edn; run one with jolt run -m app.core or jolt -M:alias.

• Getting Started - Requirements and installation for Linux and macOS.
• Rationale - Why Jolt targets Chez Scheme instead of the JVM.
• Differences from Clojure - Where Jolt's semantics diverge from JVM Clojure.
• Host Interop - Supplying a missing clojure.core function or shimming a Java class Jolt doesn't cover yet.
• Native Interop, the FFI - Calling C libraries directly from Jolt.
• Cljc Interop - Writing .cljc code that runs on both the JVM and Jolt.
• REPL-Driven Development - Working against a live Jolt process.
• Writing Libraries - Conventions for publishing a Jolt library.
• Testing - How Jolt's own test suite and conformance checks run.
• Building and Running - Building jolt from source and running projects.
• deps.edn Internals - How dependency resolution works under the hood.
• Scheme Backends - Chez by default, Gambit compiled to JavaScript for the browser.
• Fibers - Jolt's lightweight concurrency primitive, underneath core.async.
• Extension Points - Where and how to hook into the compiler.
• Numeric Performance - The numeric tower and where its costs show up.
• Module Map - A contributor-oriented tour of the jolt codebase.
• RFCs - Design notes behind Jolt's language decisions: transients, type hints, structural type inference, the numeric tower, and more.
• Language Specification - The formal spec, including a coverage report against clojure.core.

Shared tooling behind the jlt-commons organization, so no individual project maintainer has to build it alone.

• docs-engine - A small Babashka static-site generator, its only external dependency markdown-clj, that turns a project's docs/ markdown and a site.edn config into a GitHub Pages-ready site.
• ci-builds - A fan-out CI tool that dispatches every project's own workflow against one pinned Jolt version and renders a single pass/fail table across the org, so a Jolt release regression is caught fleet-wide rather than repo by repo.
• meta - Governance and the project-proposal queue: how to propose a project, volunteer to maintain one, or ask for something the org isn't doing yet.
• .github - Org-wide default community health files (profile README, code of conduct, contributing guide, security policy, issue and PR templates), applied to any org repo that doesn't define its own.

Other projects worth knowing about while exploring the Jolt ecosystem.

• jank - A native-code Clojure dialect on LLVM. Its clojure.core compliance suite is what clojure-test-suite started from.
• clj-commons - The community-maintained home for Clojure/JVM libraries. jlt-commons is modeled openly on it.
• Clojure - The language Jolt implements, still running on the JVM.

• #jolt on the Clojurians Slack - Development discussion, questions, and design decisions, shared with the wider Jolt community rather than split by organization.
• jolt-lang/jolt issues - Bug reports and feature requests for the language and compiler.
• jlt-commons/meta issues - Propose a project, volunteer to maintain one, or ask for something new.
• jolt-lang on GitHub - The core language organization.
• jlt-commons on GitHub - The community organization for adopted and new libraries.

Contributions welcome. Read the contribution guidelines first, then open a pull request.

To the extent possible under law, the contributors to this list have waived all copyright and related or neighboring rights to it, under the CC0 1.0 Universal public domain dedication. This list only points to and describes other people's work; each linked project keeps its own license, so check a repository before depending on it.