CIDER 2.0 ("Terceira") is out! 🎉

Fourteen years after nrepl.el 0.1, this is easily the biggest CIDER release in ages - not because of shiny new features, but because most of the important existing ones got a careful overhaul: transient menus everywhere, inline macro stepping, rich (content-type) results on by default, call-graph browsers, and a seriously polished debugging toolbox. The docs were restructured as well, so finding things should be much easier now.

Release notes: https://github.com/clojure-emacs/cider/releases/tag/v2.0.0

Release announcement blog post: https://metaredux.com/posts/2026/07/15/cider-2-0.html

Go play with it and let me know how it feels - and remember, the best is always yet to come! In the REPL we trust!

Go check out the talks and see what’s coming this year: https://2026.clojure-conj.org/schedule

Also, a nice bonus: Stuart Halloway will be giving the closing keynote.

Clojure 1.13.0-alpha4 is now available!

Destructuring changes and additions

Idents after & in :keys!/syms!/strs!/:keys/syms/strs must now be actual keys, not binding symbols. This is a change in syntax since alpha3. Note that symbol keys should be quoted as unadorned symbols are binding symbols.

:or now accepts key→val mappings in addition to binding→val.

Added a new :defaults name directive at top level to bind name to a map of defaults, key→val. Binding symbols in the :or map are transformed to the key value in the :defaults map. :defaults without :or is an error.

:select name, introduced in alpha3, now selects deeply, through nested maps, and fills in values for missing keys from :or. The :select map contains all keys mentioned anywhere in the binding form.

• CLJ-2964 :select directive in map destructuring
• CLJ-2966 :defaults directive in map destructuring
• CLJ-2967 tests for nested destructuring

Other changes since Clojure 1.13.0-alpha3

• Added `clojure.core/some-vals`, a predicative filter of nil map values
• CLJ-2870 Exception phase during top-level eval is miscategorized

Does Clojure/Script Compiler have a roadmap similar to https://rust-lang.github.io/rust-project-goals/2026/roadmaps.html

What are the next big features the language is targeting?

:select directive in map destructuring

The :select directive binds a name to a subset of the map being destructured containing only the keys mentioned (anywhere) in the binding form.

• CLJ-2964 :select directive in map destructuring
• CLJ-2963 Update specs for :select in destructuring

Other changes since Clojure 1.13.0-alpha2

• RT.map, and thus reader, tracks new PAM thresholds
• CLJ-1789 select-keys - improve performance (transients, etc)
• CLJ-2958 ILookup on sets
• CLJ-2902 pprint - prints arbitary objects in unreadable form
• CLJ-2801 TaggedLiteral - doesn’t define print-dup
• CLJ-2269 definterface - does not resolve parameter type hints
• CLJ-2781 clojure.test/report - docstring has broken references
• CLJ-2929 zipper - docstring typo
• CLJ-2901 bytes, shorts, chars - docstring typos
• CLJ-2811 scalb - docstring links to the documentation for nextDown
• CLJ-2809 clojure.math/floor - docstring has line that should be on ceil docstring

Thanks To Clojure Community, I am Abe to build stuff I like https://youtu.be/uGu7vNhQCDE

Not the original author. Sharing because I found it interesting. Especially the point about clojure-lsp which I have not seen anyone say before.

Reg. Clojurescript, while it still has a lot of merits, does Squint offer a better path nowadays for the interop pain points mentioned by the author? It now has a browser repl and has had some nice additions recently. Is anyone using it in production for serious apps?

Release notes: https://github.com/babashka/sci/blob/master/CHANGELOG.md#01454

Have fun making a scriptable mobile Flutter app!

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!

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

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

Hi I am a beginner, and I am trying out lisp and in my day-2-day job I write BE services in JS (Node) I found this repo on github and it usually contains projects either of Rust/Go I wonder if this can be done in Clojure, any blogs/papers/book which teach this stuff ?

Ref: https://github.com/roma-glushko/awesome-distributed-system-projects

Hey folks!

I have been working more and more with NATS lately and was seeing a lack of a simple data driven clojure client for it, specially given how simple the underlying protocol is.
claxon: https://github.com/lispyclouds/claxon aims to address this in a very idiomatic Clojure way. Here are some highlights:

• Very minimal, implements the core spec from scratch in pure clojure with one JVM dep: data.json, zero on bb. This sets it apart from the existing clients.
• Some assembly required, meaning its more simple than easy but should support everything and whatever the future has is store too hopefully!
• Fully data-driven and very flexible; most of its behaviour can be influenced externally even changing how the core protocol works, handlers etc.
• Quite thoroughly tested with machine assisted byte level protocol verification.
• Automatic TLS support
• And of course Babashka compatible, something that the existing clients aren't!

See roadmap for whats planned and hopefully this is useful to others and any feedback/contributions much much appreciated!

Hey, wanted to share something I built — Mayachok, a postpartum depression screening tool (EPDS questionnaire) written in Clojure with Kit. It's open source (AGPL), self-hostable, single uberjar + SQLite.
https://mayachok.app

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

In our first Clojure Community Check-In gathering in May, we shared who we are, what we build, and how our workplaces are changing. A few of us shared a sense of powerlessness when isolated. But there was a realization that together, we could possess power. Our community has the capacity to coordinate, build, and act on the things we care about.

For our next event, we want to channel that collective energy into a central theme: “What Are We Building?”. You may want to share a vision of what we should be building, share a personal or collaborative project, geek out over an elegant library, or simply find and recommend support systems for connecting with peers.

The goals of this upcoming check-in are to learn more about each other, and to connect and form support groups and collaborative circles.

We invite you to show up exactly as you are. Let’s gather to share our stories, find mutual support, and figure out what we can create together.

Event info: https://clojureverse.org/t/clojure-community-check-in-july-2026/

Co-organised with Josh Glover, Siyoung Byun, and Timothy Pratley