Awesome Jolt

• Language and Compiler
• Getting Started
• Official Libraries
• Community Projects
• Applications and Libraries
• 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.

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.

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.
• 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.

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. Four moved over from jolt-lang, and their old URLs redirect. Fifteen were started here, nine of them by Jolt's author. Each keeps its own release cadence, and most publish their own docs at jlt-commons.github.io/<repo>/.

Graphics and Games

• raylib-jlt - raylib bindings in native Clojure, calling the system libraylib over its C ABI through jolt.ffi, with a keyword-argument drawing API on top. Docs.
• raylib-jolt-demo - 187 raylib examples built on raylib-jlt, each one its own small runnable project. 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. The platform: host loop, bindings, and the build, deploy, and live tools. Docs.
• raylib-ios-demo - What runs on raylib-ios: 137 scenes, each a sub-project that builds an iPhone app of its own, plus a gallery app holding them all. 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. Docs.
• graviton - A physics game where you place gravitational attractors to steer a ship toward prizes and away from death zones. A Jolt and raylib port of a 2018 ClojureScript game, with its field math checked by writ.
• ents - Bindings for flecs, the C entity component system, with an API modeled on vybe. Components read and write as plain maps, and systems and observers are written as binding vectors over components. When a callback throws, the exception is rethrown from the progress or set-c! call that drove it, so the world stays usable.

User Interfaces

• glitter-core - The natives-free two-thirds of glitter: the Replicant-style reconciler and IRender/IMemory protocols, with no GTK4/AppKit/anything-else toolkit dependency at all. What glitter, glitter-uikit, and uikit-demo all build on. Docs.
• nexus-jolt - A Jolt port of nexus: data-driven action/effect/placeholder dispatch. Not GUI-specific, but its only consumers today are glitter and friends, so it's listed here. Docs.
• glitter - The GTK4 renderer built on glitter-core: 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.
• uikit-demo - A demo of glitter-uikit: a hub of live example windows (counter, currency converter, live FX, particle toy) built as a real macOS app bundle. Docs.
• ftxui-jolt - A reagent-style API over FTXUI, the C++ terminal UI library: components as functions returning hiccup, rendered through FTXUI's own event loop, focus handling, and mouse support.

Concurrency

• ebb - A port of missionary: composable tasks and flows with real cancellation and glitch-free dataflow, running on Chez fibers. Docs.
• ensemble - Erlang processes and the OTP behaviours on Jolt's native fibers: links, exit signals, monitors, selective receive, gen_server, gen_statem, gen_event, supervisors, and applications. Distribution is not part of it yet.
• tapestry - Structured concurrency primitives for Clojure on Jolt, backed by core.async fiber handles rather than manifold. Marked pre-1.0.

Storage

• 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.

Parsing and Translation

• 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.
• clj-to-ys - Translates Clojure source into idiomatic YS (YAMLScript), as a CLI or a library, built on the instaparse port.

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.

Cloud Services

• aws-api-jolt - Runs cognitect's aws-api unmodified from Maven, supplying the HTTP client it expects over http-client plus the classpath resource that makes it discoverable. All four AWS wire protocols are exercised against live AWS.

Machine Learning

• lev - Pure-Clojure inference for the Laya decision models: ModernBERT and mmBERT encoders plus a decision head, scorer and act head, f32 end to end with no JVM and no Python. Reproduces the Python package's answers across all three checkpoints and routes per request the way its Router does.

Specs and Verification

• writ - Checks plain Clojure against a spec of what the code is for: signatures for the public functions plus laws run through test.check, with static rules taken from Bend. Built as a gate for code an LLM writes.

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

• lambda-mvp-jlt - An AWS Lambda custom runtime for Jolt, implementing the provided.al2023 contract in about 60 lines of Clojure over Jolt's built-in HTTP client, with a benchmarking tool for cold vs. warm boot time.
• lambda-mvp-jnk - The same custom-runtime contract implemented in jank (native Clojure via C++/Clang/LLVM) and deployed as a Lambda container image rather than a zip, since jank's toolchain needs a newer glibc than AL2023 ships.
• lambda-mvp-cljs - The same family running on AWS Lambda's managed nodejs24.x runtime instead of a custom one, so the whole deployable is a shadow-cljs-compiled handler and a zip.
• lambda-mvp-rst - A fork of lambda-mvp-jlt that embeds a Rust capability into the runtime via jolt-diplomat: the handler builds its JSON response with real serde_json instead of hand-assembled strings, since Jolt has no JSON library of its own.
• lambda-mvp-bb - The same family in Babashka via blambda. Nothing is compiled ahead of time here: the handler is required and interpreted at cold start by Babashka's own SCI interpreter.
• raylib-pacman - The same Pac-Man written four times against raylib, once each for babashka, Clojure on the JVM, jank and Jolt, whose copy binds raylib-jlt over jolt.ffi. The game logic barely changes between the four, so what they really compare is the drawing layer and each runtime's own route into C. Docs and demos.
• lisp-games - Two small graphical programs, borkdude's helitorus and raylib's own mesh-instancing example, each ported to babashka, Clojure on the JVM, jank and Jolt, whose ports bind raylib-jlt. helitorus rebuilds and projects its whole surface every frame and reports compute and draw milliseconds separately, so what separates the four runtimes is measured rather than guessed. Docs and demos.
• 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.
• jolt-edge - A Clojure HTTP server that runs as a WebAssembly module on Wasmer Edge: Jolt compiled to wasm32-wasix, with the source compiled on cold start and a second variant compiled ahead of time for comparison. No JVM, no JavaScript, no build step.
• clojev - An unofficial Clojure SDK for TypeSafe's System One API: typed Noul, Choice and Score questions, validated answers, and retries with exponential backoff that respect Retry-After. The core is portable .cljc over a swappable transport, so the same code runs on the JVM over java.net.http or on Jolt over http-client.
• farolero - A Jolt port of Farolero, implementing Common Lisp-style conditions, handlers, restarts, and interactive recovery while preserving JVM, ClojureScript, and Babashka support.
• go-to-sleep - A macOS menu-bar app that enforces a weekly bedtime schedule by locking the session during sleep blocks, and locking it again after each unlock. A root LaunchDaemon owns the schedule, so quitting the app doesn't stop enforcement, and once a block is within eight hours the schedule can only grow. Built and packaged as an Apple silicon .pkg with Jolt.
• snitt - A screenshot and screen-recording app for macOS and Windows that lives in the menu bar or tray, with region capture, annotation, and video trimming. The jolt branch ports it from C++ to Jolt, and its UI runs on glimmer-qt, a glimmer backend over Qt Quick that ships in the same repo. The default branch is still the C++ app.

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.
• standard-clojure-style-jolt - A port of Standard Clojure Style to Jolt: a standard-clj CLI (check/fix/list, stdin support, .standard-clj.edn config) plus a library API (format/parse/parse-ns), compiling to a native binary with no JVM.

• 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.
• setup-jolt - A GitHub Action that installs jolt on a runner from its prebuilt releases and verifies the published sha256, covering Linux x86_64 and macOS x86_64/arm64.
• 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.
• raylib-jnk - A guide to calling C and C++ from jank, written while porting raylib's examples. The 213 ported examples live in raylib-jank-demo, one small project each, so they sit side by side with raylib-jolt-demo. Guide and gallery.
• raygui-jnk - The 24 raygui-jlt examples ported to jank, with the same names and descriptions so the two read as one library through two Clojure implementations. Docs and gallery.
• raylib-clj - raylib bindings for Clojure on the JVM, calling the C library through coffi over JDK 22's foreign-function API. Its 113 examples moved to raylib-clj-demo, laid out the same way as the Jolt and jank demos. Docs and gallery.

• #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.