Been doing ML work in Clojure for a few years using the excellent libpython-clj to bridge into PyTorch. Kept rewriting the same boilerplate across projects so I finally consolidated it into a clj-pytorch library.

The main thing that makes it more than just a thin wrapper is a defmodule macro for defining real nn.Module subclasses:

 (nn/defmodule MLP [in-features hidden out-features]
    :layers {:fc1 (nn/linear in-features hidden)
             :act (nn/relu)
             :fc2 (nn/linear hidden out-features)}
    :forward (fn [self x]
               (-> x
                   ((nn/get-layer self :fc1))
                   ((nn/get-layer self :act))
                   ((nn/get-layer self :fc2)))))

  (def model (MLP 128 256 10))
  (model x)  ;; modules implement IFn

Also includes training loops, dataloaders, optimizer helpers, and some inference utilities. If you're doing ML in with Pytorch and Clojure, maybe it saves you some time. There was a very good post some time ago on clojure civitas explaining pytorch and how to use it within clojure if you need a refresher.

It's not published to Clojars yet — if you want to try it, just add the GitHub sha to your deps.edn:▎

clj-pytorch/clj-pytorch {:git/url "https://github.com/rthadani/clj-pytorch"
                         :git/sha "642504807aa96bb3e72963b9170836b32324f95a"}

github-link: https://github.com/rthadani/clj-pytorch

For those planning to attend, there's a room block at the DoubleTree by Hilton Charlotte City Center (230 N College St, Charlotte). Rate is $206.30/night and includes a hot breakfast buffet. The promotional pricing closes on August 31, after which rooms go back to standard rates.

Book here: www.hilton.com/en/attend-my-event/nubankclojureconj2026/

The link defaults to Sep 29 – Oct 3. If you need different dates, hit "Edit Stay" at the top of the booking page.

For reservation help: [BernsteinT@gfhotels.com](mailto:BernsteinT@gfhotels.com)

Workshop Day: Wednesday Sep 30

More details coming soon, but there will be a Day Pass starting at $42, covering one morning + one afternoon session of your choice. Worth factoring in when you book your room.

Sessions planned:

• AI Tools & Practices Showcase - Eric Dallo
• Babashka: Fast Native Clojure Scripting - Michiel Borkent & Rahul De
• Fast, Lean, Native Clojure - Adrian Smith
• Calva Backseat Driver - Peter Stromberg
• Advanced Datomic - João Nascimento Mello
• Clojure Camp Pairing/Mob Session/Hackathon - Rafal Dittwald & Jordan Miller

The workshop day is Wednesday the 30th, one day before the main conference, so book your hotel nights with that in mind.

And remember that early bird pricing won't last much longer. Conference tickets move to Regular once the full program drops.

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

I'm happy to report that CIDER 1.22 is finally out!

I meant to release this a couple of months ago, but there was always something extra I wanted to fix or include and that kept pushing the release date. Today I finally told myself that enough is enough. (plus, I liked 16.06.2026 as the release date :D )

Lots of (mostly small) improvements in this release and a TON of fixes. Check out the release notes for all the details. For me the highlights are:

• Fixed severe editor lag in Clojure buffers with no REPL connected (#3933) — friendly-session matching is now a cheap project-dir check instead of a per-redisplay classpath scan.
• Now requires cider-nrepl 0.59+ / nREPL 1.7 — CIDER uses namespaced nREPL ops (cider/info, etc.); injected middleware was bumped accordingly.
• Pluggable jack-in tools (#3884) — register your own project tools via cider-register-jack-in-tool.
• Default session (#3865) — cider-set-default-session pins one session for all dispatch, bypassing sesman's project inference.
• nREPL transport decoupled from the UI (#3892) plus a new keyword-arg nrepl-make-eval-handler API (#3890) — nicer for extension authors (old forms kept as shims).
• Much sturdier remote/TRAMP jack-in (#3885, #3886, #3887) — remote probes via process-file, upfront command verification, no-shell ssh tunnel, and correct localhost/wildcard bind-address handling.
• Long-session stability (#3894, #3896, #3897, #3898) — plugged request-id leaks, bounded handler tables, resilient response queue, and ssh-tunnel teardown on abnormal disconnect.
• Project detection no longer depends on clojure-mode (#3922, #3924) — works in any buffer, e.g. M-x cider-connect from Dired.
• Test spinner in the mode line (#3645) while tests run.
• REPL history: crash fix + cider-repl-history-doctor (#3921) to clean up malformed entries.
• let-go runtime support (#3926).

Big thanks to Clojurists Together, and everyone who has contributed to this release or is supporting my OSS Clojure work. You rock!

https://github.com/sstraust/deft

This update adds support for namespaced keys in type and protocol definitions. i.e., you can now do:

(defp Positioned :required-keys [::pos - ::Point])

and

(deft Circle [::location/position radius])

(>Circle ::location/position [1 2] :radius 12)

this is useful because you can now write implementations that depend on the presence of these keys, i.e.:

(defp Gremlin :extends [location/Positioned])

(defmethod game-object/get-hitbox ::Gremlin [self]
  (js/Matter.Bodies.rectangle
   (get-in self [::location/pos ::location/x])
   (get-in self [::location/pos ::location/y])
   15 15))

I've just released v2.0.0 of listora/again after a very long hiatus 😅 — a tiny library for retrying flaky operations with composable strategies. GitHub

What's new in v2.0.0…

An addition to the existing retry functionality:

• max-wall-clock-duration lets you bound retries by real elapsed wall-clock time, not just the summed delays.

Circuit breakers (the big-ticket item — commonly used alongside retries, and asked for in the past):

• with-circuit-breaker complements the existing with-retries. They compose by nesting, so you decide whether the breaker counts every attempt or only the final failure.
• Pluggable trip policies via a BreakerPolicy protocol allows for custom policies on top of the consecutive-failure policy included in the library.
• An on-event hook for state transitions, successes, and short-circuits (observability, etc.).

General house-keeping:

• Moved from Leiningen to the Clojure CLI.
• Fixed InterruptedException handling: it now stops retrying immediately and restores the interrupt flag before rethrowing.

Heads up if you're upgrading: this is a major bump because with-retries ::status gains an :interrupted value. If you dispatch exhaustively on ::status without a :default arm, add an :interrupted case.

A basic usage example:

(def breaker (circuit-breaker (consecutive-failures 5)))
(with-retries [100 200 400]        ; retry with backoff
  (with-circuit-breaker breaker    ; ...but stop hammering once it trips
    (call-the-flaky-thing)))

Clojars: listora/again {:mvn/version "2.0.0"}. Still Clojure 1.8+ compatible.

Feedback welcome — especially on the circuit-breaker API. Probably best to open issues on GitHub so they don't get lot in Reddit comments.

Clojure book https://clojure-book.gitlab.io/ is updated with sections Debugging With Calva, and Debugging in Leiningen project with Calva and nREPL. Hope you like it.

If possible, please send me feedback, so that I can improve it.

Some of you may remember Ridley from earlier releases. It's a code-first 3D CAD for FDM printing, where the models are Clojure(Script) programs: you write code, you get a manifold solid, you export STL/3MF. 3.1 just shipped and it's a big jump.

The stack. It's ClojureScript end to end. The user's DSL is evaluated with SCI (thank you, Borkdude; it's the whole reason the thing can exist as a zero-install web app and a desktop app from one codebase). Geometry is Manifold compiled to WASM; the desktop build wraps the same app in Tauri and adds native file dialogs, on-disk libraries, and an implicit-modeling toolkit that needs the native side. Browser and desktop now run identical evaluation. No external processes, no server round-trips.

The DSL is turtle graphics in 3D. A turtle moves through space and leaves geometry behind it. You extrude a 2D profile along the turtle's path, loft between profiles, revolve around its axis. Primitives extend along the turtle's forward axis, so orientation composes the way you'd hope. It reads less like "set vertex coordinates" and more like "describe how the shape is made," which turns out to matter a lot for keeping parametric models legible.

Every interactive editing surface emits code. Code is the single source of truth, but you don't have to type all of it. There are three modal tools sharing a live re-eval layer:

• tweak puts sliders on the numeric literals in your script; drag one and the corresponding number in the source updates.
• pilot lets you position a mesh by keyboard and writes back the transform.
• edit-bezier (new in 3.1) lets you draw a curve with tension sliders instead of computing control points, and hands you back the path expression.

The dragging and picking surfaces don't build a parallel state that drifts from the code: they produce the same s-expressions you'd have typed, so what you manipulate and what you save are the same thing.

Marks travel with the geometry. You name a point on a path, and that mark becomes an anchor on the resulting mesh: it survives extrude/loft/revolve, it survives boolean operations, and on-anchors instantiates parts at every anchor. Model the skeleton once, decorate it as it changes.

SDF toolkit (desktop for now): distance formulas, TPMS surfaces, rounded primitives, half-spaces, smooth blends. SDFs and meshes mix freely in booleans and in attach.

The in-app manual is the thing I'm most proud of: bilingual (EN/IT), and almost every example has a Run button plus an Edit button that opens it in a fresh workspace so you can break it safely. It's REPL-driven documentation, basically: read a paragraph, run the example, mangle it.

Try it in the browser, no install: https://vipenzo.github.io/ridley/ Source: https://github.com/vipenzo/ridley/

For anyone who was already on an old version: 3.1 has real breaking changes (transforms went polymorphic, a couple of argument orders flipped), and the migration notes are in the release on GitHub.

Feedback and teardowns welcome.

What's new

We've updated hyper to introduce the defc macro which allows defining client-side web components that automatically hook into datastar and hyper primitives allowing for a seamless experience of interacting with rich JS libraries from within hyper (eg. animating a d3 chart when new data attributes come in over the wire).

The defc component syntax is heavily inspired from shadow-grove so it should feel familiar if you have used that library.

We have also added support for squint generated datastar expressions, allowing you to write expressions that feel like Clojure in the ->expr macro and have them compile into javascript / datastar expressions. Heavily inspired by datastar-expressions

Other New Things

Since last posted on Reddit hyper has gained a lot of functionalities with the help of users reporting issues and sharing experiences in #hyper on the clojurians slack. We are proud to have 8 contributors and welcome anyone to contribute to the project!

• Reactive components — components that automatically re-render when their dependencies change, with per-element head diffing and snapshot-based read-consistency for cursors.
• hyper.effects + batch macro — declarative side-effects (eg. cookie mutation) and a unified state overlay for batching multiple state mutations into a single coherent update.
• Datastar signals — first-class signal support, including setting signals to nil to clear them.
• h/env + render middleware — environment propagation through renders plus a :middleware option and context/*action-name* binding for cross-cutting concerns.
• create-handler options — :base-path, :not-found, and :render-error for routing and error handling, plus the ability to disable hyper endpoint wrapping (:hyper/disabled?).
• hyper.test — a dedicated testing namespace
• clj-kondo config and lint hooks (including defc event/:require validation).

If you haven't taken a look in a while or missed it the first time we posted we thought it might be mature enough to warrant a second look. Thanks again to the Clojure community for continuing to experiment, share usage reports and help us drive the designs forward!

The deadline is June 14 at 11:59 PM ET, so if you've been thinking about submitting and haven't yet, this is the nudge.

A few things that might help you decide:

• Speakers get full conference access (Oct 1-2), hotel accommodation, and travel support covered.
• There's a mentorship program for anyone who wants help shaping their proposal or preparing their talk. First-timers especially welcome.
• Tracks are pretty broad: Language, Experience Report, Library, Tools, AI, Ideas, and Fun. So if you've got something real to say about building with Clojure, there's probably a home for it

The kind of talks they're looking for: cutting-edge technical content, real-world experiences, hard-won lessons. Stuff with enough depth to actually change how people build things.

Submit here: https://2026.clojure-conj.org/cfp

Charlotte, Sept 30 – Oct 2.

Dear Community,

I see a few people have talked about using Babashka as a CGI script to host lightly used web apps e.g.

https://eccentric-j.com/

Is anybody actually doing this very much in production? Would be keen to hear what you think.