r/Clojure

Checked keys
You can now ensure that required keys are bound during map destructuring by using the new checked variants of the :keys/:syms/:strs directives - :keys!/:syms!/:strs!, which will throw if the key is not present. You can also, in all directives, specify keys after & which will not be bound, for documentation or checking purposes.

• CLJ-2961 Checked keys
• CLJ-2960 Specs for checked keys
• CLJ-2949 req! - Variant of get that reports on key not found
• CLJ-2954 let/loop/let* - disallow & as local binding

Other changes since Clojure 1.12.5

• PersistentArrayMaps of only keyword keys now grow up to size 64 (previously was 8) before transitioning to PersistentHashMaps. PAM identity scans are more efficient than PHM lookups in this range, also makes more usage sites monomorphic and thus easier to optimize.
• CLJ-2891 Remove ACC_FINAL designation from static initializer constants. This change was made as a prepatory step towards moving the Java bytecode baseline to address new verifier checks.
• Runtime and test dependencies updated to latest versions

This release fixes a bad build with alpha1, otherwise unchanged.

Babashka.fs is a file system utility library for the JVM and babashka. It's been ported to Node.js now too. The JVM implementation is the reference implementation. All operations remain synchronous. There are only a few gaps (see above link) but most things work exactly the same.

Babashka.fs can be used via CLJS (vanilla + shadow), Squint and nbb on Node.js, bun and Deno. All of this is tested in CI.

Happy scripting!

lgx 0.1.0 is out - a project and dependency manager for let-go (a Clojure dialect written in Go).

let-go is great for CLIs and scripts: no JVM required, standalone binaries, fast startup. But it was missing project tooling. lgx fills that gap in one binary:
- lgx new myapp
- lgx install
- lgx run
- lgx nrepl
- lgx build
- lgx test
- lgx <task>

It uses a single lgx.edn file, close in spirit to tools.deps, with git/local deps, transitive dependency resolution, contexts/overlays, and custom tasks that can replace small ad-hoc Makefiles. It already runs a real project: I built wtr, a git worktree CLI, with let-go and lgx. It ships as prebuilt binaries for macOS and Linux.

Try it:
brew install abogoyavlensky/tap/lgx nooga/tap/let-go

lgx new hello
cd hello
lgx run

GitHub: https://github.com/abogoyavlensky/lgx

Please include any restrictions (remote/on-site, geographical, workpermit, citizenship) that may apply.

While working on my game, I ended up creating a thin Clojure facade over LibGDX where each Java class is represented by exactly one Clojure namespace.

Current code: https://github.com/damn/moon/tree/da56223d5f0b0c3d51ae037c4cec7c8aed1a8f64/src/com/badlogic/gdx

The idea is simple:

* each LibGDX class is imported in exactly one namespace

* application code never imports LibGDX classes directly

* application code calls Clojure functions instead

* the facade only wraps the constructors and methods that I actually use

For example, if a LibGDX class has 100 methods but I only need 15, only those 15 are exposed.

The motivation isn't to replace LibGDX or provide a complete wrapper. It's to reduce the Java interop surface, give my project a stable Clojure API, and have a single place where each Java class is referenced.

I'm considering extracting this into its own open-source repository, even though it's primarily written for my own projects.

A few questions I'd be interested in hearing opinions on:

* Does this seem like a reasonable use of the facade pattern in Clojure?

* Is there a precedent for wrapping Java libraries this selectively?

* Would you keep the namespaces as `com.badlogic.gdx.*` to preserve the 1:1 mapping with the Java classes, or would you prefer a Clojure-specific root namespace such as `clojure.gdx.*`?

I'd appreciate any thoughts, especially from people who have built Clojure APIs over existing Java libraries.

I am sharing this because I have struggled now for a few years with this topic and seem to finally found a simple solution.

FOL is a Clojure-style LISP that transpiles to Common Lisp (specifically, SBCL). The latest version, 0.1.1, has been augmented with APL/q-style array operations and adverbs. All q operations and adverbs have been implemented, but as in APL, they work on n-dimensional arrays, rather than q's one and two dimensional arrays. There are specialized arrays containing only floats <f32-array>, doubles <f64-array>, and fixnums <fixnum-array>, as well as a generic <array> type that holds anything. See the manual section on arrays for more information on these.

In addition, there have been a few transpiler optimizations made - type metadata is migrated to Common Lisp declarations, as are optimizer variable valuess. Small functions/methods can  be inlined. assoc has been optimized and now does not cost as much in loops. Direct slot access for objects has been added to the transpiler.  Type-aware collections have been added. Sequential assocs that are long enough are wrapped in transient operations. See the optimization section at the end of the manual for more information on these and other optimizations.

The next phase of this work is to check the transpliler on Common Lisp implementations other than SBCL. When I have completed testing, I will run comprehensive benchmarks on these systems and Clojure to compare their runtimes. I have the Common Lisp systems I need for the testing, other than Allegro. If anyone would like to help by testing FOL in that system, I would be grateful. Testing against Clojure to find places where the syntax is different and/or the functions are not present would be appreciated, too.

FOL can be found at GitHub.com/frankadrian314159/fol.

https://clojure.org/news/2026/06/23/deref

Have been using Clojure at work for years, but only now started dabbling in its open-source space! This was an obscure learning that I thought was worth sharing, since no else has written about it AFAIK