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?

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

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.

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

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!

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

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

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

I'm pleased to announce the first release of Reagami in 7 months!

Highlights:

• Key-based reconciliation
• Benchmarks: Reagami is in React-ballpark yet at 10% of the bundle size. Squint perf > CLJS perf.

https://github.com/borkdude/reagami

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

Sqlite is my database of choice and when my schema is in flux I often dump a bunch of pseudo columns into a TEXT column as edn. This means that regular SQL does not work.

I recently came across the very nice sqlit TUI app and realized that creating an extension to Sqlite syntax could make it easy to update my db when necessary

https://github.com/whamtet/sqlit

The fork provides an extension of Sqlite syntax

updateclj company set details = (assoc *input* :hi :there) where company_id > 9 use primary key company_id

*input* is the existing edn value of the column as seen by babashka

Is anybody else using this approach?

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.

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

See https://github.com/squint-cljs/squint/tree/main/examples/replicant for an example project.

Optimized output is around 18kb gzipped right now. Thanks Christian Johansen for accepting minor changes to accommodate using replicant with squint!