We'd love to see more Clojure submissions at BOB!
bobkonf.de/2027/cfc.html

Clojure 1.12.6 is now available

• CLJ-2794 - gen-class - incorrectly treats interface default methods as abstract, throwing when the var delegate is unbound
• CLJ-2974 - FnLoaderThunk - de/serialization no longer supported, throw

I have been working on a distributed Datalog engine à la Datomic on top of object storage. The system is called Triplox. I am using SlateDB at the storage layer. The main ideas are roughly the following (in no particular order):

• Object storage centric. In it's final version Triplox should simply need a single (or likely two) S3 bucket(s) for deployment.
• The Datomic Data model and API as main inspiration.
• A Client/Server architecture. I hope that this will open the door to ecosystems outside of the JVM.
• Incremental Datalog queries. You should be able to dynamically subscribe and detach from incremental Datalog queries. This is the most experimental part of Triplox and will need quite a bit of effort to get right, make fast, and to fully support all features of Datalog. See this page for an introduction.

I also wrote a intro post a while back. If you have questions, suggestions or feedback in any form please ask away. If you have an incremental Datalog problem or are working on sync engines, Triplox might be of interest .

Repo: https://github.com/fiV0/triplox
Website: https://triplox.xyz/
Incremental query tutorial: https://github.com/FiV0/triplox-incremental-tutorial

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

Minecraft is well known for being single-threaded, and parallelizing it is a difficult problem: everybody wants to write to the same shared state at the same time. Projects take years to deal with locks, thread ownership, splitting regions, and game logic is subject to threading rules: mechanics break against them, features crawl. Some remain quite sparse and have little to parallelize.

I wanted to see how it would feel in Clojure, but there was no Clojure server to look at, so I made one. The ideas parallel servers reinvent by hand - immutable snapshot, pure read phase, changes as data - are the language's defaults. If writing from many threads is difficult, then don't write: all game logic is pure functions (fn [world events]) that read the snapshot in parallel and return changes as deltas, merged in one place. The merge preserves order, so the parallel run is bit identical to the sequential one, and no mechanic cares how many cores it runs on.

The outcome: a server with mob AI, explosions, combat and item physics that matches vanilla 1.8.9 performance on one core and runs 4.5x faster on six. ~5500 lines of Clojure. It's a proof of concept; if you're curious, the code is on GitHub

https://github.com/Nozistance/collider

Today babashka 1.13.220 is released, with a new babashka.ffi namespace for calling C libraries directly from Babashka scripts. The babashka.ffi library is also available as a standalone library for JVM Clojure, so you can use it in your Clojure projects as well. Note that the API is still experimental, although no changes are currently planned. It just needs more exposure and your feedback :). Read the blog post for details.

Slipway provides support for Eclipse Jetty in Clojure.

This release is a significant upgrade to previous versions of Slipway, including:

• Embedded Jetty 12.1 with native handlers (no Servlet/EE dependencies).
• Websockets (combining Jetty with Sente).
• Extended OIDC support including:
  • Authorization Code Flow with Refresh Token redemption
  • Client Credentials Flow
• Multi-Handler Server implementations
• Virtual Host pinning of Handlers to Connections

Fold your state into the DOM!
A minimal zero-deps Reagent-like in Squint and CLJS.

API allows the full read and edit access to your data in OrgPad. The work was massive since OrgPad allows a lot of types of content and I wanted the API to be as simple to use as possible. Since OrgPad is written in Clojure, it allows aside JSON also EDN and Transit inputs/outputs.

https://github.com/nooga/legmacs

https://github.com/nooga/let-go

https://github.com/dharmatech/drawterm

I will be writing primarily Clojure soon, after more than a decade of writing Scala. Do you have any hints or advice beyond what I can find in books or other learning resources?

Like competing approaches, nuances, political landscape, informal standards, footguns or anything like that?

Choq: Choq: Cherry on QuickJS

A ~5MB binary chock full of scripting goodies.

This runs the cherry compiler inside an embedded QuickJS engine via rquickjs.

It supports nREPL, loading JS library from https://esm.sh, and has a few Node.js compatible packages built in like "fs", "path", etc.

Hi all,

I'm releasing Clorch, a deep learning library in Clojure built on LibTorch.

Now we can run inference, build custom models, and train them all in Clojure, with no Python/PyTorch calls at all!

PyTorch-style tensors, autograd, neural-network modules (including LLM components), optimizers, data loading, CPU/CUDA support (including distributed GPU training) and all that jazz has been implemented :)

https://github.com/antlobach/clorch

Hello everyone,

I have created a short survey (7 questions) about the suitability of Clojure (and Noj) for data science. What are its strengths? What are its weaknesses and what is missing? Your responses will be greatly appreciated. Do not hesitate to send the survey to other Clojure users. Thank you in advance and here is the link:

https://docs.google.com/forms/d/e/1FAIpQLSclQp6E90LGan72tAavY4hnrsH02trRxPLD0oG_WeoYYkTeNQ/viewform?usp=publish-editor

I've been researching ways to better structure LLM output when building mini-apps that run on the browser.

I believe that an S-expression based DSL is a better output format for LLMs when generating interactive UI/logic.

To test this, I built a Clojure-based interpreter that runs in the browser. The LLM is fed the language context, then emits the DSL to generate safe, sandboxed apps that can be shared instantly.

I wrote up an article diving into some of the trade offs:

https://allentraid.substack.com/p/we-made-the-ai-write-in-a-language

Would love to hear thoughts from the Clojure community!