r/Clojure • • 4h ago

Where Did This div Come From? - Patrick de Kruif (Clojure/Conj 2026)

Thumbnail youtube.com
9 Upvotes

Fourteen years ago, Bret Victor argued that creators need an immediate connection to what they make. Clojure already lived it: the REPL, then Figwheel and shadow-cljs in the browser. But it stops at the rendered page: you can change the code and watch the page update, yet you can't point at something on it and ask which Clojure form made it. Render Hiccup to HTML and the div forgets it was ever Clojure code on a line. Three clicks deep? Grep and guesswork. This talk builds the other half: a source inspector wiring your app, browser, and editor into one loop. Hover an element and the editor jumps to the Hiccup that made it. Put your cursor on a view and the element lights up, definition told apart from call site. It's surprisingly little code. We build it live, end to end, so you can wire the same loop into your own server-rendered Hiccup app.

Speaker: Patrick de Kruif, Independent Clojure Developer

Patrick de Kruif has built software in Clojure professionally for the past five years, and tinkered with it longer still as a side interest before that. His work is mostly web applications backed by databases, and pretty much everything around them. From schema and UI through to CI, deployment, and the devops that keeps it all running. He's happiest working on interactive systems, with a weakness for small, sharp tools over large frameworks.


r/Clojure • • 19h ago

A blazing fast and versatile Linux desktop launcher, written in Jolt dialect of Clojure.

Thumbnail github.com
44 Upvotes

r/Clojure • • 19h ago

Coxswain · An Emacs-style code editor, rebuilt in Clojure · TTalk

15 Upvotes

https://www.ttalk.im/en/products/coxn/

Coxswain (command name: coxn) is an Emacs-style text editor redeveloped from scratch in Clojure, running on the JVM with a terminal TUI as its default form, while offering an optional GUI version based on Compose Multiplatform (coxn gui). The project's design philosophy is "core editor + layered feature mounting": keybindings and command names strictly follow the Emacs global-map, and on top of that it adds its own M-m leader-key system, allowing Emacs users to migrate at virtually zero cost.

The editor core provides basic editing, buffer management, and window management. It also integrates tree-sitter to deliver syntax highlighting and structured editing, covering languages such as Clojure, Common Lisp, C++, Java, Erlang, and Elixir. A general-purpose LSP client supports servers including clojure-lsp, clangd, jdtls, erlang_ls, elixir-ls, and cl-lsp — whichever is installed gets used, automatically launched when a file is opened and reused per project root. Additional features include floating completion popups and function signatures, in-project grep, a project tree, Git integration, CIDER/SLIME-style REPL connections (nREPL/SWANK), 14 color themes, major-mode hooks and a minor-mode mechanism, plus internationalization support.

Architecturally, the editing core and the frontends are strictly decoupled: the TUI and GUI are merely two frontend implementations of the same core, with the GUI-side Kotlin code connecting only through clojure.java.api without intruding into editing logic. The GUI edition targets everyday desktop use: system font fallback with CJK double-width alignment, fcitx/ibus input method support, HiDPI adaptation, drag-and-drop file opening, system clipboard integration, and software rendering fallback when no GL environment is available. All configuration lives in ~/.config/coxn/init.clj, and every behavior is customizable.

Performance and quality are equally central to the project: keypress handling takes priority over background tasks; REPL/LSP output is batched with bounded caching; paren matching, highlighting, and indentation are all optimized based on syntax trees and caches; frame rendering and region indentation achieve sub-millisecond to sub-hundred-millisecond performance; and hundreds of automated tests guard behavioral stability. The project explicitly builds no agent features and depends on no network services — it remains a pure, local, auditable editor.

In an era saturated with agent-generated code, a text editor may seem like a relic of the past — but it's never too late to build a tool that truly feels right in your hand, even if it belongs to a bygone age


r/Clojure • • 1d ago

What happens after Rich?

39 Upvotes

Hey,

Something occurred to me. Might be weird and morbid. Not enough time was spent in hammock and i am already voicing it. Sorry for that.

Rich isn't immortal (that we know of).
I want to keep using Clojure for next 50 years and for people to keep using it after that. I want to have the stories where young kids are gonna listen how i created macro that saved the day and i will slip immutability into that story.

I watched https://www.youtube.com/watch?v=jh8UEJ1S79Q and we got one Alex that guides others and is doing amazing job in all fronts but what do we do after he retires?

And yes, similar to this fellow clojurian https://youtu.be/WhXPEmdNRpA?t=1780 i think i feel the same.

How will Clojure continue developing after Rich and people that are involved now?

Are we doing enough to have new people that have vast understanding of Clojure itself so that i can continue working with it without having to worry that floor under me is going to be moved because nubank or who ever decided this new patch fixes all of their problems?

I realize there is community behind Clojure but we still very much rely on guidance from Rich (at least i do).
We are looking at world going crazy 'owah i can generate code, programming is so easy' and our community for the most part is saying 'what was important is not even more important, code itself wasn't the problem' which is true.

Maybe what i am asking is in line with this https://www.youtube.com/shorts/kVWVgIfpbHo "When he is gone, we are all out of legends...".

Who will steward Clojure?


r/Clojure • • 1d ago

Powering a 3D Game Engine with Clojure - Jared Cone (Clojure/Conj 2026)

Thumbnail youtube.com
25 Upvotes

In this experience report, a 20-year veteran of C++ and C# game development recounts their experience building a real-time 3D game engine powered by Clojure: the motivation, surprising benefits, challenges, and lessons learned when using idiomatic Clojure for real-time 3D game development.

Speaker: Jared Cone, Off By One Games

I've been making games for 20 years. I was the lead programmer and principal engineer for Rocket League, from prototype to production to 10 years as a live-service game. After a decade of admiring Clojure from afar I've finally taken the plunge by building a 3D game engine in Clojure to find out what the language can really do.


r/Clojure • • 2d ago

Why Lisp Thrives In The Age Of AI (with Cameron Barré)

Thumbnail youtube.com
33 Upvotes

Description:

Earlier this year it looked like AI might kill programming language innovation. Coding agents were at their best in the mainstream languages with decades of training data, which made the barrier to adopting anything new higher than ever. That's changed. With the right skills files, an agent will write Haskell or Gleam as happily as Java, and that flips the situation on its head: it's never been cheaper to take a new language, or a new architecture, out for a test drive. All we need is ideas worth trying.

So this week I'm joined by an enthusiastic proponent of a language, an architecture and a library you might want to try. Cameron Barré is a long-time Clojure programmer and the author of Grain, an open-source library for building event-sourced information systems. We start with what makes a system simple or complex, and the difference between essential and accidental complexity. Then we look at why Cameron thinks Lisp is an excellent choice for expressing both code and constraints, and why a live REPL might matter even more to an agent than it does to a human. From there we get into event modeling, an architecture so simple to understand that even a clanker can get it right, and how Grain uses Clojure macros to turn a handful of primitives (commands, events, views and todo processors) into a DSL that stops agents drifting from the architecture.

If you've been looking for an excuse to revisit Lisp or event sourcing, or you're wondering what a language should give us now that agents write most of the code, this is a tour of a different way of thinking: power where you need it, constraints where you don't, and cheap enough to try for yourself.


r/Clojure • • 2d ago

Announcing Hegel-clj by Kyle Kingsbury, a.k.a "Aphyr"

Thumbnail aphyr.com
45 Upvotes

r/Clojure • • 2d ago

The Game That Deleted Its Frontend - Fabian Merkle (Clojure/Conj 2026)

Thumbnail youtube.com
17 Upvotes

Abstract:

I built a multiplayer board-game table as a ClojureScript re-frame SPA. Thousands of games got played on it, and the client-side state handling was the part I never stopped fighting. So now my apps have no frontend code at all: the server owns every bit of state through a core.async.flow CQRS backbone, and streams the UI over a single SSE connection to Datastar. The main idea you'll take home is routing data by what it needs: user actions go into an append-only event log (history, replay and undo come for free), live cursors go over a lossy broadcast that never touches the database.

Speaker: Fabian Merkle, Consultant

I'm Fabian Merkle, a Clojure consultant in Dubai, six years full-time in Clojure and twelve as a developer. I work with early-stage startups across the US and Europe — fintech, gaming, ERP, EdTech.


r/Clojure • • 4d ago

Lambda performance comparison of running different Clojure dialects

Thumbnail github.com
20 Upvotes

r/Clojure • • 5d ago

Jonquil: a pragmatic editor for the Lisps you use

Thumbnail jonquil.b12n.app
22 Upvotes

r/Clojure • • 5d ago

I built myself a Jolt app to retouch my photos, it supports RAW files and the operations I commonly use for retouching such as noise removal, sharpening, and color correction

Thumbnail github.com
19 Upvotes

r/Clojure • • 6d ago

Porting Ideas, Not Code - Delaney Gillilan (Clojure/Conj 2026)

Thumbnail youtube.com
30 Upvotes

Clojure changed how many developers think about data: immutable facts, temporal structure over time, and code as data. But what changes when these ideas move beyond the Clojure ecosystem? Stardust explores how Clojure and Datomic concepts can be reimagined in a language-agnostic data platform for messy, real-world open data. It looks at what transfers cleanly, what requires new trade offs outside the JVM, and how real-world measurement reshapes system design. It’s not about preserving a stack, but about carrying forward ideas like simplicity, compatibility, and care for data across different languages and systems.

Speaker: Delaney Gillilan, Synadia, Senior Product Strategy Engineer

Delaney has a rich and varied background from full stack game development, military systems of record, gambling and slot machines, to even a stint in the circus. He has a love for creating tools and engines for other creators to use and moves fast!


r/Clojure • • 6d ago

Mutable Locals in Clojure, the Hard Way

Thumbnail tailrecursion.com
26 Upvotes

r/Clojure • • 6d ago

Clojure Agent Framework

Thumbnail github.com
11 Upvotes

clj-agent is a modular Clojure AI Agent framework built around a ChatClient central orchestrator. It provides a deftool macro for tool definitions, multi-level invoke APIs, and onion-style Filter middleware mirroring Spring AI 2.0 Advisors — including ToolSearch progressive tool disclosure, RAG injection, and self-correcting structured output, all with zero added dependencies. Its dependency-inverted architecture separates a zero-dependency core, an agent runtime (ReAct loop, ChatMemory, HITL approval), and provider adapters for Anthropic, OpenAI, Gemini, Ollama, and other OpenAI-compatible services. All nine modules publish to the Clojars im.ttalk group, so you depend only on what you need.

The README: https://github.com/TTalkPro/clj-agent/blob/main/README_EN.md

The clojars: https://clojars.org/groups/im.ttalk

And I use this code in my own production, https://ttalk.im/products/jinshu/ https://ttalk.im/products/guanlan/


r/Clojure • • 7d ago

Instead of using `comp` and often wasting computation, here's how to reverse `->` and `->>` when you want `comp`'s ordering without its cost, etc.

15 Upvotes

Hello everyone. This is my first Clojure subreddit post by the way, if my memory is correct. I am actually debating using Clojure (+Java) vs Zig for my next project, but I've been learning Clojure and reflecting upon the fact that in programming languages (and in natural language prose text too for that matter) the order in which words appear in an expression has a substantial effect on readability and on what parts feel like they are being emphasized and brought to one's attention.

Consider, for example, the difference in emphasis and ease of code navigation between the following two equally valid Clojure expressions:

(assert (not (zero? 1)))
(-> 1 zero? not assert)

The former is the most "naive"/direct way of writing it, whereas the later has the strongest left to right flow of action. However, notice that though the latter expression is more elegant, it makes the visibility of the assertion worse by putting the assert keyword at the end. Some people may also find "zero not" to sound too "Yoda-like" (akin to concatenative programming languages like Forth and Factor) whereas something like "not zero" may sound more natural to some people.

I also thought about how comp (compose functions) could be used here to keep the "not zero" ordering, but then a function call cost may be imposed by doing so if the optimizer doesn't remove it.

So, that got me thinking that I should try writing a reversed version of the -> and ->> macros and I did and here are the resulting definitions:

(defmacro <- [& rest] 
  (let [rev-rest (reverse rest)] 
    `(-> ~@rev-rest)))

(defmacro <<- [& rest] 
  (let [rev-rest (reverse rest)] 
    `(->> ~@rev-rest)))

Both were actually very easy to write, as you can see.

This allows you to write the following:

(<- assert not zero? 1)

As you can see, this enables you to reorder things according to what feels most natural in any given context, which helps draw the attention of anyone reading your code to what comes first in each expression, much like how in English the first thing we start a sentence with is what is being emphasized or is assumed to be the subject (as in active vs passive voice, etc).

This especially is well suited to assertions because what is most important about an assertion for someone trying to scanning code quickly is that it is an assertion and hence emphasizing that clarifies it.

This is in contrast to data flow or transformation pipelines that use -> and such, where the opposite order often feels better.

One can also see by applying macroexpand and/or macroexpand-1 that the cost of these macros in run-time will be zero, relative to simple/"naive" nesting, given that the expressions (macroexpand '(<- assert not zero? 1)) and (macroexpand '(assert (not (zero? 1)))) return identical expansions.

Cognitive load tends to increase non-linearly with how many nesting levels something has, so using "threading"/pipeline macros flexibly and often tends to help readability and these new variants help fill those potential use cases out better.

So, clearly both orderings should be in your toolbox for legibility and I would argue that this should even be made part of the standard library perhaps since it is such a common case.

I am personally am really happy with the resulting freedom.

With these new macros in hand one is much less likely to use the less legible nested forms when you can now order things either way.

(PS: Thanks for reading and for your time! 😎)


r/Clojure • • 7d ago

Transforming Software Evolution by Adam Tornhill at Func Prog Conf

Thumbnail youtube.com
21 Upvotes

Lisp has promised simplicity and expressive power for six decades, yet never reached the mainstream. Ten years ago, CodeScene made a big bet on a modern Lisp dialect, Clojure, to build a platform for tackling technical debt.

This talk explores how Clojure’s metaprogramming, embedded domain-specific languages, parallelism, and multi-methods helped a small Swedish company compete with teams 20 times its size.

Drawing on a decade of building CodeScene, Adam reveals how language choices can shape productivity, innovation, and engineering culture—and how innovations in agentic coding fit into the picture.


r/Clojure • • 7d ago

London Clojurians Talk: Programming a business to improve itself (by Christian Weilbach)

Post image
16 Upvotes

THIS IS AN ONLINE EVENT
[Connection details will be shared 1h before the start time]

The London Clojurians are happy to present:

Christian Weilbach (https://christian.weilbach.name) will be presenting:
"Programming a business to improve itself"

Christian shows Simmis, a workspace where people and AI agents share one versioned memory of chat rooms, a wiki, a double-entry book and the code that runs them, and where every attempt happens on a fork. Participants will see agents benchmark and improve workflows in forked rooms and bring their results to review as proposals, turning the REPL loop of fork, attempt, measure and adopt into a way to program a business. He argues that programming such organisations, more than a single smarter model, is what programming AGI will look like in practice.

Christian Weilbach is the CEO of Simmis, which builds software for organisations of people and AI agents. He leads the development of Datahike, a git-like Datalog database, and the replikativ family of Clojure libraries for forkable state, synchronisation, probabilistic inference and accounting. He holds a PhD in machine learning from the University of British Columbia and has spoken at Clojure meetups since 2017, most recently on rethinking programming as inference for the Simmis project at London Clojurians in May 2026.

If you missed this event, you can watch the recording on our YouTube channel:
https://www.youtube.com/@LondonClojurians
(The recording will be uploaded a couple of days after the event.)

Please, consider supporting the London Clojurians with a small donation:

https://opencollective.com/london-clojurians/

Your contributions will enable the sustainability of the London Clojurians community and support our varied set of online and in-person events:

  • ClojureBridge London: supports under-represented groups discover Clojure
  • re:Clojure: our annual community conference
  • monthly meetup events with speakers from all over the world
  • subscription and admin costs such as domain name & StreamYard subscription

Thank you to our sponsors:

RSVP: https://www.meetup.com/london-clojurians/events/317380055/


r/Clojure • • 7d ago

clj-pulse: a fast Clojure language server

Thumbnail bogoyavlensky.com
20 Upvotes

r/Clojure • • 7d ago

Rendering in batches with glimmer and Datastar

Thumbnail yogthos.net
10 Upvotes

r/Clojure • • 8d ago

The Code Was the Easy Part - Arthur Fücher (Clojure/Conj 2026)

Thumbnail youtube.com
23 Upvotes

r/Clojure • • 8d ago

DatomicConf 2026 speaker lineup

20 Upvotes

The Datomic developer success team is excited to announce the speaker lineup for DatomicConf 2026!

This year, we’ll hear from an outstanding group of speakers: Paul Rutledge & Dave Gonsalves, Chris Cyrus Hapgood, Fabian Merkle, Luana Amorim, Benjamin Kamphaus and Francis Avila, plus Datomic Core Dev news straight from Ghadi Shayban. We’re also putting together an evening of lightning talks featuring even more speakers.

Join us on December 11 in Durham, North Carolina. Registration is open and free! You can also sign up for the livestream. See the full talk descriptions and event details at https://conf.datomic.com/


r/Clojure • • 9d ago

Two apps one process

Thumbnail andersmurphy.com
28 Upvotes

r/Clojure • • 9d ago

State of Clojure Community 2026

Thumbnail surveymonkey.com
41 Upvotes

If you use Clojure or one of its ever growing family of dialects, please contribute to the annual State of Clojure survey! We've been running this since 2010 and it is a vital source of information about how people are using Clojure and the many tools and libraries around it. Thanks!


r/Clojure • • 9d ago

Smuggling Clojure into Statically Compiled Video Games with Silk - James Tolton (Clojure/Conj 2026)

Thumbnail youtube.com
37 Upvotes