Babashka is a native Clojure interpreter for scripting, compiled with GraalVM native-image to produce a self-contained, fast-starting binary (`bb`). In production, it serves as a replacement for bash or Python scripting in Clojure, offering a REPL, task runner, nREPL server, HTTP client/server, process spawning, file I/O, database access via JDBC, and foreign function interface (FFI) to C libraries. The architecture is a monolith with modular feature flags: environment variables such as `BABASHKA_FEATURE_CSV` or `BABASHKA_FEATURE_JDBC` control which optional libraries (XML, YAML, CSV, Transit, http-kit, spec, logging, etc.) are compiled into the binary. The core interpreter is SCI (Small Clojure Interpreter), extended with a rich set of built-in namespaces that wrap popular Clojure libraries. Build scripts and CI pipelines automate testing on Linux, macOS, and Windows, and the project maintains an extensive library compatibility test suite with over 100 third-party Clojure libraries pinned to specific git SHAs. The codebase demonstrates exceptional craftsmanship: the JLine-based REPL with inline autosuggestion and eldoc, the FFI trampoline dispatch, the custom GraalVM features for binary size optimization, and the deftype map interface support are all non-obvious solutions to real problems in building a scripting runtime on the JVM. While primarily an application, the repository also contains a valuable data asset in `test-resources/lib_tests/bb-tested-libs.edn`, a curated registry of library compatibility that could support research on Clojure library portability.
Metabase is an open-source business intelligence platform that enables users to query, visualize, and share data through an intuitive interface. The system is built as a full-stack application with a Clojure backend and React/TypeScript frontend, supporting both self-hosted and cloud deployments. The architecture follows a modular monolith pattern with clear separation between the core application, enterprise features, and embedding SDK components. The codebase demonstrates sophisticated engineering practices including a comprehensive plugin system that allows enterprise features to extend core functionality, a custom query builder with both GUI and SQL interfaces, and a robust embedding SDK for integrating Metabase components into external applications. The frontend utilizes modern React patterns with Redux for state management, while the backend employs Clojure's functional programming strengths for data processing and API handling. Key architectural highlights include the metabase-lib library for query construction and metadata management, a sophisticated visualization system with ECharts integration, and a multi-tenant embedding solution with JWT/SAML authentication. The codebase shows strong attention to internationalization, accessibility, and performance optimization through features like query caching, lazy loading, and bundle splitting.
Penpot is a full-stack, open-source collaborative design and prototyping platform. The codebase is a polyglot monorepo comprising a Clojure backend (REST/RPC API, PostgreSQL, Redis, S3 storage), a ClojureScript frontend (React-based UI with custom text editor and design system), a Rust WebAssembly renderer (Skia-based shape rendering and export), a Node.js media processor (image/font conversion), a TypeScript MCP server (AI integration via Model Context Protocol), and a plugin ecosystem (SES-sandboxed JavaScript runtime with Angular/TypeScript example plugins). The architecture follows a microservices-like pattern with separate deployable components, real-time collaboration via WebSocket/Redis message bus, and background task processing. The system is designed for self-hosting and enterprise deployment with features like SSO, audit logging, webhooks, and rate limiting.
Reagent is a ClojureScript library that provides a minimal, efficient interface to React, enabling developers to define UI components using Hiccup-like vectors and manage state with reactive atoms. The library's architecture centers around three core concepts: reactive atoms (ratoms) for state, a Hiccup-to-React element compiler, and lifecycle macros like `with-let` and `defc`. Under the hood, Reagent implements its own reactive state management system (RAtom, RCursor, Reaction) that triggers automatic re-rendering of components when dereferenced state changes. The codebase demonstrates deep integration with React internals, including support for hooks, contexts, fragments, portals, error boundaries, server-side rendering, and concurrent mode. It is fully compatible with both React 18 and 19, and provides a seamless interop path with existing React libraries via `adapt-react-class` and `:>` syntax. The test suite is comprehensive, covering functional components, lifecycle behavior, reactive updates, and performance benchmarks. While primarily a UI library, the reactive state management components are designed with sufficient abstraction to be studied as a standalone pattern for reactive programming in ClojureScript.
This repository contains `clojure-mode`, an Emacs major mode for editing Clojure, ClojureScript, and related languages. The system provides syntax highlighting (font-lock), indentation, navigation, and a suite of refactoring commands directly in the editor. The architecture is a single large Emacs Lisp file (`clojure-mode.el`) with an additional extra font-locking package. It defines a base `clojure-mode` derived from `prog-mode`, plus derived modes for ClojureScript, ClojureC, ClojureDart, Joker, Jank, and EDN data files. Key entry points are the mode activation functions and interactive commands like `clojure-align`, `clojure-thread`, `clojure-cycle-privacy`, etc. The indentation engine uses a backtracking algorithm that walks up the sexp tree to apply contextual indent specs (shared with `clojure-ts-mode`). Font-locking is regex-based and extensible, with special handling for docstrings, discard macros, and character literals. The package depends only on standard Emacs libraries (`cl-lib`, `imenu`, `align`, `subr-x`) and requires Emacs 27.1+.
Etaoin is a pure Clojure library that implements the W3C WebDriver protocol for automating major browsers (Chrome, Firefox, Safari, Edge). It provides a comprehensive, idiomatic Clojure API for browser control—navigation, element interaction, JavaScript execution, screenshots, shadow DOM, and more—without requiring Selenium or Java interop. The library also includes a Selenium IDE (.side) file executor, Chrome DevTools performance log parsing, and a rich macro DSL for resource management (with-driver, with-wait, with-postmortem). Internally, it uses multimethod dispatch to handle browser-specific quirks, a generic polling mechanism for waits, and a composable action builder for complex input sequences. The codebase is well-structured, extensively tested across multiple browsers and runtimes (JVM Clojure and Babashka), and provides clj-kondo hooks for linting its macros. It is primarily a library for integration into other projects (UI testing, web scraping, automation), but also offers a CLI entry point for running IDE scripts.
taoensso/encore is a foundational Clojure/ClojureScript utility library rather than an end-user application. It provides a broad collection of general-purpose cross-platform primitives: macros for control flow and aliasing, predicates and coercions, collection/string/time helpers, concurrency constructs, caching and memoization, rate limiting, async runners, environment configuration, Ring helpers, and ClojureScript AJAX support. The core functionality lives in a single large namespace, with additional experimental namespaces for byte manipulation, statistics, signal handling, and timers. It is designed to be embedded in other libraries and applications, not run standalone. The architecture is modular at the namespace level: `taoensso.encore` is the core grab-bag, while `taoensso.encore.bytes`, `taoensso.encore.stats`, `taoensso.encore.signals`, and `taoensso.encore.timers` provide focused, self-contained subsystems. A small Java class supplies high-performance NanoId/HexId generation. The code is heavily optimized for cross-platform behavior and performance, using reader conditionals, custom deftypes, CAS loops, and transient collections. It has a robust test suite and CI coverage for Clojure, ClojureScript, GraalVM, and Babashka. Although it contains statistical and byte-level utilities that could support data work, the repository is not a data pipeline or research project. There are no datasets, notebooks, or ETL flows. The stats module is a reusable library component, not an analytical schema. This is a dependency-first library with high reuse value for Clojure developers needing battle-tested utilities.
Baleia.nvim is a Neovim plugin that colorizes text with ANSI escape sequences (8, 16, 256 or TrueColor). It processes buffers containing ANSI codes, strips them from the text while applying appropriate syntax highlighting, and supports both manual and automatic colorization modes. The architecture features modular Lua components handling ANSI parsing (ansi.lua), lexical analysis (lexer.py), asynchronous processing (scheduler.lua), and Neovim highlight rendering (renderer.lua). The plugin integrates with Neovim's buffer system through autocommands and API functions, efficiently handling large files via chunked processing.
Logseq is a privacy-first, open-source knowledge management platform built as a monorepo containing an Electron desktop app, Capacitor-based mobile apps (iOS/Android), a web app, and a Node.js db-sync server. The codebase is predominantly ClojureScript (CLJS) with React/Rum for the UI, DataScript for the in-memory graph database, and SQLite (via better-sqlite3 and sqlite-wasm) for persistence. It uses shadow-cljs for CLJS compilation, webpack for JS bundling, and Tailwind CSS for styling. A separate OCaml-based CLI (logseq-cli) built with Melange provides graph inspection, sync, and CRUD operations against the same db-worker-node backend. The architecture separates concerns into deps/ subprojects (db, outliner, graph-parser, db-sync, common, publishing, shui) that are compiled as separate shadow-cljs targets and shared across Electron, browser, mobile, and CLI runtimes. The system has two graph types: file-based graphs (Markdown/Org) and DB graphs (SQLite-backed with DataScript in-memory querying). DB graphs enable real-time collaboration (RTC) via a Cloudflare Worker-based sync server (deps/db-sync) using WebSockets and D1 SQLite. The db-worker-node is a long-lived Node.js process that manages SQLite connections and sync state, communicating with the UI via a thread-api IPC mechanism. The outliner module handles block tree operations with structural invariants, while the graph-parser handles Markdown/Org parsing via mldoc. The publishing module generates static HTML sites from graphs. Key architectural patterns include: missionary for reactive async flows, promesa for promise composition, malli for schema validation, datascript for Datalog queries, and a component-based UI with Rum/React. The codebase has extensive test coverage via cljs.test, Playwright E2E tests (clj-e2e), and Python-based CLI E2E tests (cli-e2e). The repository is actively maintained with recent commits, 43k+ stars, and active issue triage, though the large monorepo complexity and multi-language surface (CLJS, OCaml, Swift, Kotlin, Python, JS) create maintenance challenges.
FiraCode is a monospaced programming font with extensive programming ligatures, built and maintained primarily by Nikita Prokopov. The repository contains the source design file (FiraCode.glyphs, Glyphs.app format), a Clojure-based pipeline that programmatically generates OpenType contextual alternates (calt) substitution rules from a list of ligature sequences, and a comprehensive build system (Makefile, shell scripts, Dockerfile) that orchestrates font production (OTF, TTF, variable, WOFF2, WOFF) using modern font tooling (fontmake, glyphsLib, gftools, fontbakery). The project also includes extensive OpenType feature files (stylistic sets, character variants), a Google Fonts QA workflow, and distribution packages for npm, Homebrew, and direct download. The architecture is a font development pipeline: source → Clojure ligature generator → fontmake compilation → hinting → packaging. It does not run as a service; its production output is the font files delivered to users via package managers or CDN. External dependencies include Python font libraries, a Clojure runtime, and Glyphs.app (proprietary) for editing the source file. The repository is actively maintained with recent commits and an extensive changelog, though some Google Fonts compliance items remain unresolved and the build chain is sensitive to upstream library changes.
This repository is the open-source 'Rainbow Brackets Lite' IntelliJ IDEA plugin, a free and feature-limited version of the popular Rainbow Brackets plugin. The plugin colorizes nested brackets (round, square, squiggly, angle) with distinct colors to improve code readability, and provides additional features like rainbow indent guide lines and scope highlighting via mouse shortcuts. It is implemented as a JetBrains plugin using the IntelliJ Platform SDK, with core logic split between an Annotator (for simple leaf-elements) and a HighlightVisitor (for more accurate per-language matching via BracePairProvider extension points). The architecture follows standard IntelliJ plugin patterns: extension points for brace providers, custom text attributes, and a thorough settings UI integrated into the IDE's color scheme page. The codebase is well-structured with proper separation of concerns, utility functions (memoization, color blending), and comprehensive tests for multiple languages. While tightly coupled to the IntelliJ API, several components (BracePairProvider interface, memoization utility, color blending) demonstrate non-obvious skill and could be extracted for reuse in other JetBrains plugins or JVM projects.
This repository provides a Ring adapter for Jetty web servers, enabling Clojure/Ring applications to run on Jetty 11 and 12 with support for modern web protocols. Despite its 'jetty9' name, it tracks recent Jetty releases and adds features like HTTP/2, HTTP/3, and WebSocket support that aren't in the official Ring Jetty adapter. The architecture centers around a core adapter that creates and configures Jetty Server instances, with separate implementations for synchronous and asynchronous Ring handlers. It cleanly separates concerns: connection handling (HTTP/HTTPS/HTTP/2/HTTP/3), request/response translation between Jetty and Ring models, and protocol-specific upgrades (WebSocket). The adapter supports virtual threads, SSL/TLS configuration, and serves as a drop-in replacement for the official ring-jetty-adapter while offering more recent Jetty versions and additional features. Notable for its quality implementation are the WebSocket bridge that properly translates between Jetty's WebSocketListener and Ring's WebSocket protocols, and the asynchronous handler implementation that correctly manages the race condition between handler completion and timeout using atomic state and Jetty's scheduling facilities. The optional HTTP/2 and HTTP/3 modules demonstrate good practices for extending the core adapter with dynamically loaded dependencies.
This repository defines the Transit data interchange format (v0.8), a cross-language serialization specification for conveying values between applications. It does not contain any implementation code for reading or writing Transit; instead, it provides the authoritative specification (README.md), a comprehensive suite of example data files in multiple representations (EDN, JSON, verbose JSON, MessagePack), and a Clojure-based testing infrastructure to verify that third-party Transit implementations correctly encode/decode according to the spec. The test harness in `src/transit/verify.clj` orchestrates roundtrip tests by invoking external implementation processes (via `bin/verify`), using both hand-crafted corner cases and generative random data to ensure correctness. The repo acts as the central reference for all Transit implementations across languages including Clojure, Java, JavaScript, Python, Ruby, and others.
This repository is a curated list of interesting open source projects organized by programming language. It contains markdown files with links and descriptions for each language. There is no application code, data pipelines, or analytical models. It serves as a reference directory for developers seeking open source projects to contribute to or learn from. The repository is well-maintained with recent updates and a large community following.