March 2023 Report: Jan. and Feb. Updates for 2023 Long Term Projects

By Kathy Davis

Here are the first reports (Jan. and Feb. 2023) from our developers who are receiving annual funding for their 2023 projects. They have been busy! Thanks all for the great work!

2023 Annual Funding: Bozhidar Batsov

January/February 2023 Report


I’ve been mostly working on the next CIDER release, which I hope to release in March. Here’s how things are shaping up so far:

New features



There has been one small improvement here recently:


Things have been relatively quiet on this front. There’s some ongoing work to improve the test suit and have it running on Windows. I’ve also been in communication with David Miller to discuss the state of nREPL for ClojureCLR and the outstanding work there. The project is very close to being usable and it’s current status is documented here. David could definitely use some help from people knowledgeable in CLR to drive it through the finish line!

2023 Annual Funding: Michiel Borkent (January 2023)

In this post I’ll give updates about open source I worked on during January 2023.

Sponsors: But first off, I’d like to thank all the sponsors and contributors that make this work possible! Top sponsors:

If you want to ensure that the projects I work on are sustainably maintained, you can sponsor this work in the following ways. Thank you!

If you’re used to sponsoring through some other means which isn’t listed above, please get in touch.

Attention: If you are using Github Sponsors and are making payments via Paypal, please update to a credit card since Github Sponsors won’t support Paypal from February 23rd 2023. Read their statement here. If you are not able to pay via a credit card, you can still sponsor me via one of the ways mentioned above.


Native, fast starting Clojure interpreter for scripting. New releases in the past month: 1.0.170 - 1.1.173. Highlights:

Babashka compatibility in external libs

I contributed changes to the following libraries to make them compatible with babashka:

Check the changelog for all the changes!


The new babashka http-client project mostly replaces babashka.curl. This month the default client was improved to accept gzip and deflate as encodings by default, reflecting what babashka.curl did. Also babashka.http-client is now available as a built-in namespace in babashka v1.1.171 and higher.


Static analyzer and linter for Clojure code that sparks joy Three new releases with many fixes and improvements in the last month. Check the changelog for details. Some highlights:

A new project around clj-kondo is clj-kondo-bb which enables you to use clj-kondo from babashka scripts.
Also lein-clj-kondo got an update.


This is a new project and gives you access to a subset of instaparse via a pod. Instaparse was request a few times to have as a library in babashka and instaparse-bb is a good first step, without making a decision on that yet. See the relevant discussion here.


Remove unused Clojure vars. In the 0.3.5 version, Carve got the following updates:

 bbin install io.github.borkdude/carve


CLI to transform between JSON, EDN, YAML and Transit using Clojure Version 0.4.23:


File system utility library for Clojure. Fs has gotten a few new functions:


A CLI to add common aliases and features to deps.edn-based projects. his month there were several small fixes, one of them being to always pick stable versions when adding or upgrading libraries. See full changelog for details.


Light-weight static blog engine for Clojure and babashka. The blog you’re currently reading is made with quickblog. Version 0.2.3 was released with contributions from several people, mostly enabling you to tweak your own blog even more, while having good defaults. Instances of quickblog can be seen here:

If you are also using quickblog, please let me know!

A collection of ready to be used SCI configs for e.g. Reagent, Promesa, Re-frame and other projects that are used in nbb, joyride, scittle, etc. See recent commits for what’s been improved.


Edamame got a new function: parse-next+string which returns the original string along with the parsed s-expression.


Lein to deps.edn converter. This tool can convert a project.edn file to a deps.edn file. It even supports Java compilation and evaluation of code within project.clj. There is now a lein plugin which enables you to sync your project.clj with your deps.edn every time you start lein. Several other minor enhancements were made. See changelog.


I added the ability to build and deploy 4ever-clojure to Github Actions. Every time a commit is merged, the site is automatically updated.

Brief mentions

The following projects also got updates, mostly in the form of maintenance and performance improvements. This post would get too long if I had to go into detail about them, so I’ll briefly mention them in random order:

Discuss this post here.. Published: 2023-02-05 Tagged: clojure oss updates

2023 Annual Funding: Michiel Borkent (February 2023)

In this post I’ll give updates about open source I worked on during February 2023.


Native, fast starting Clojure interpreter for scripting. New release: 1.2.174. Highlights:

Babashka compatibility in external libs

I worked together with the maintainers of the following libraries to make them compatible with babashka:

Http-client: Babashka’s http-client

The babashka.http-client namespace mostly replaces babashka.curl. This month support for :multipart uploads was added, mostly based on and inspired by hato’s implementation.


Static analyzer and linter for Clojure code that sparks joy. New release: 2023.02.17. Some highlights:


Configurable Clojure/Script interpreter suitable for scripting and Clojure DSLs. This month:


File system utility library for Clojure. Highlights:


Clojure library for shelling out / spawning sub-processes. This month I looked into wrapping output of processes with a prefix so when ran in parallel, you can easily distuingish them. A preliminary solution is in this thread.


Interact with clojure-lanterna from babashka. A very experimental 0.0.1 release was published. You can try it out by playing tetris in the console with babashka:

bb -Sdeps '{:deps {io.github.borkdude/console-tetris {:git/sha "2d3bee34ea93c84608c7cc5994ae70480b2df54c"}}}' -m tetris.core


Scripting in Clojure on Node.js using SCI. Finally nbb has gotten support for passing maps to keyword argument functions:

(defn foo [& {:keys [a b c]}])
(foo :a 1 :b 2 :c 3)
(foo {:a 1 :b 2 :c 3})

Several other improvements have been made in the area of macros and resolving JS library references and resolving dependencies in an nbb.edn file, relative to an invoked script which is not in the current directory. See changelogs here.


VSCode CLJS scripting and REPL (via SCI). This month I contributed a built-in version of rewrite-clj to joyride, so joyriders can rewrite their code from within VSCode.


Showcase CLJS libs using SCI. A little project to show how you can use SCI to showcare your CLJS library in an interactive way.

Brief mentions

The following projects also got updates, mostly in the form of maintenance and performance improvements. This post would get too long if I had to go into detail about them, so I’ll briefly mention them in random order:

Other projects

These are some of the other projects I’m involved with but little to no activity happened in the past month.

Discuss this post here. Published: 2023-03-01 Tagged: clojure oss updates

2023 Annual Funding: Sean Corfield

January/February 2023 Update
:tags [“clojure” “” “open source” “” “community”]}

As part of Clojurists Together’s Long-Term Funding for 2023 I talked about working on which I had resurrected a few years ago, as a GitHub Pages project, powered by Cryogen.

It was originally created over a decade ago, intended as a community hub for general documentation related to Clojure that couldn’t be found on and which wasn’t bound by the Clojure Contributor Agreement.

A lot has changed since then. The Contributor Agreement has gone from a purely paper and “snail mail” process to an online e-form. The website is now on GitHub and accepts Pull Requests (if you’ve e-signed the CA) – and it has expanded massively,compared to the material it covered back then. itself grew a lot of ambitious content, including extensive guides to and clojure.core.typed that are now very dated.

In addition to cleaning up and modernizing, I also said that I wanted to help streamline the beginner experience around Clojure tooling, and I’ve started to talk with Alex Miller about possible avenues for that.

My first couple of months have focused on reviewing the content to establish what is still relevant and pruning outdated content, as well as streamlining my own open source projects around tooling.

build-clj &

I was very pleased when landed and I aggressively switched all my open source projects and my work projects over to it.

I initially felt that there was a lot of boilerplate and duplication in the build.clj files I was creating and my initial reaction was to create a simple wrapper that provided “sane” defaults to make build files smaller and simpler. As people started using this wrapper, it began to develop more “knobs & dials” to make it more configurable – and then I created deps-new as a modern “replacement” for [clj-new ( in turn derived from boot-new, which derived from lein new), with the idea of supporting more declarative templates for projects. That led to more “knobs & dials” on my wrapper as the projects created by deps-new depended heavily on the wrapper.

In January, I stripped the wrapper out of all my open source projects build.clj files as a way to make them a better example for beginners. I went on to strip the wrapper out of the usermanager example application]( that I regularly link beginners to, as a basic web application, and out of the project templates in deps-new so that people creating projects via that will no longer use my wrapper.

The net result should be many more examples of how to use directly and a normalization of how build.clj files should be written. I think the HoneySQL build.clj file in particular is a good example of how to run various tasks, such as test-doc-blocks and Eastwood, as well as running multi-version testing, both Clojure and ClojureScript tests, and building and deploying a library JAR to Clojars.

I plan to write a cookbook for that expands on the official guide, covering the sorts of things I’ve found useful in both my open source and work projects.

As noted above, has grown dramatically since was created and provides more up-to-date content in many areas, so I’ve focused on pruning the duplicated and outdated content and linking to the official site where up-to-date content now exists.

In particular, the following pages have been unlinked and removed from the navigation, in favor of other sources:

I’ve temporarily removed all the ecosystem and library pages from the navigation to make the main sections easier to find, while I review and update them over the next few months.

The following pages have been overhauled/updated:

Nearly 60 pages have been updated to fix broken links. Changes so far this year!

I welcome feedback on both the updated content and the site itself, either via the #clojure-doc channel on Slack (self-signup at or via clojure-doc discussions on GitHub. Feel free to open issues directly for errors on the site and of course pull requests on the source branch are also welcome!

What’s Next?

In March/April, I plan to review and/or overhaul the Getting Started, Introduction, and Web Development sections, with a focus on the latter.

Additional Project Releases

In addition to changing all my projects to use plain instead of my wrapper for it, HoneySQL 2.x has had four releases in January/February, that have mostly focused on improving documentation and also compatibility with 1.x to make it easier for folks to migrate.

2023 Annual Funding: Eric Dallo

January/February 2023 Report


New opensource project!

jet.el is a Emacs package that uses jet, offering, via a smooth magit-like UI, multiple ways to quickly convert between edn/json/transit/yaml.

Parse edn/json/transit/yaml directly from Emacs using a smooth magit-like interface. Besides the main entrypoint, the package has lots of commands to parse and:

Available at MELPA!


Clojure-lsp is a tool that can be used both in your editor like Calva, Emacs, Vim and others, and as a command line tool, mostly as a linter for formatting, cleaning and finding diagnostics for a whole project.

There were some improvements on the documentation regarding what and how clojure-lsp can be used in outside your editor here.

Release 2023.01.26-11.08.16

The most important features of this release were the find definition of symbols and the edn file support for both editor and lint via CLI, improving the IDE experience, being able to find the definition and references of keywords and symbols, besides that, there was a lot of fixes, performance improvements, and new settings for more projects support.





Release 2023.02.27-13.12.12

Mostly improvement on completion performance, some improvements on the hover feature, and fixes.





Worked on analysis stuff regarding edn support for clojure-lsp.

2023 Annual Funding: Christophe Grand

January 2023 Report

This month we merged our changes for a better hot reload (see Update #2) and then went on bugfixing and doing small improvements for a while.

A problem kept bothering us: in our cljd.flutter (well in January it was still cljd.flutter.alpha2) we have :watch to react to updates to all kind of stateful objects and sub to narrow the scope of changes we are interested in for a given “watchable”. This is very useful as it allows to change the frequency at which a piece of UI is updated: one can have a big atom holding a lot of state (and this changing frequently) and watch a slower changing subset of it.

However sub only allowed to narrow one watchable. This led to awkward code were every other watchables (IO or framework related) updates had to be shoe-horned in a single canonical atom with the help of listeners (whose lifecycles have to be tied to specific parts of the widget tree) and hair-pulling naming decisions on paths inside this atom.

We first extended sub to allow to apply a function across several watchables latest values, somehow behaving like a join.

It worked but felt quite stiff and not very pleasing to use. sub relied on the f & args update convention (as used in swap!, update-in etc.) but there’s no agreed upon convention for when one has several input and thus it doesn’t mesh as well as the single-input version with the core lib.

This dissatisfaction led us to develop “cells”. Cells as in spreadsheets. So cells are expressions which recompute their value when their dependencies values change. Obviously we made cells watchable. A cell is defined by using the $ macro (because it caches its latest value) and inside (dynamically, not lexically) a cell one can take (<!) from other cell or any other watchable.

Example: assuming now is an atom (a plain old one) updated at 60fps, then ($ (.-day (<! now))) is a cell recomputed at 60fps but yielding a new value once a day. So any widget (or other cell) depending on this cell will only be updated once a day.

This generalizes nicely to multiple dependencies and even to dynamic dependency graphs. Another interesting fact to know about cells is that a cell is recomputed only when it’s watched (and this cascades transitively: an unwatched cell doesn’t watch its dependencies…).

Another consequence of cells is that the push for a single big canonical atom goes away.

This changed positively the way we write apps. So much that in our February workshop we talked only about cells, not subs.

New boost

2023 Annual Funding: Thomas Heller

January/February 2023 Report


Time was mostly spent on doing maintenance work and some bugfixes. As well as helping people out via the typical channels (eg. Clojurians Slack). Current shadow-cljs version: 2.21.0 Changelog

Notable Updates

2023 Annual Funding: Nikita Prokopov

January and February have been two months dedicated to Clojure Sublimed, my Sublime Text plugin for Clojure development.

I wasn’t happy how REPL implementation was coupled with syntax highlighting, so I decided to decouple them. That lead to a lot of yak shaving, but also to a much better code base (not in a single file anymore!) and to an ability to add new REPLs much easier. I also added Socket REPL support (no need to load nREPL anymore!) and gave Shadow-CLJS some long deserved love.

Unfortunately, while everything is almost ready, it just didn’t make it to end-of-February deadline, so expect the proper release somewhere in the beginning of March. Brave people could already use it from master (I do). Also expect a huge blog posts with a lot of details on this adventure — it was very fun!

More detailed changelog:

Clojure Sublimed

Sublime Executor:

Humble UI:


Sublime Color Schemes

2023 Annual Funding:Tommi Reiman

January/February 2023 Report

Spent a lot of time with Malli and Reitit for revisiting, prioritizing and designing the essential missing core features.

For Malli, my top priority is to resolve the derivation and declaration of effective types, which will simplify library internals, writing schema extensions and make CLJS bundle size smaller. Might have to break the protocol-api for this.

For Reitit, drafting a proper plugin system, have studied how this is solved in other ecosystems (e.g. fastify, phoenix). Reitit is powerful, proper plugin system which makes it much more approachable.

Have also reviewed lot’s of PRs, helped people online and pushed out some smaller features and release the following:


0.10.1 (2023-01-21)

0.10.0 (2023-01-12)

* (require '[malli.experimental.describe :as med])

(med/describe [:map {:closed true} [:x int?]])
; => "map where {:x -> <integer>} with no other keys"


0.6.0 (2023-02-21)

[metosin/ring-swagger-ui "4.15.5"] is available but we use "4.3.0"
[metosin/jsonista "0.3.7"] is available but we use "0.3.5"
[metosin/malli "0.10.1"] is available but we use "0.8.2"
[fipp "0.6.26"] is available but we use "0.6.25"
[ring/ring-core "1.9.6"] is available but we use "1.9.5"
[com.fasterxml.jackson.core/jackson-core "2.14.2"] is available but we use "2.14.1"
[com.fasterxml.jackson.core/jackson-databind "2.14.2"] is available but we use "2.14.1"  

Something else

Spring is coming!


2023 Annual Funding: Peter Stromberg

My first two months of 2023 long term funding was spent in a typical mostly-Calva-someJoyride-and-some-other-stuff manner. 😀 Even though it was an unusual two months in ways I hope will stick, as well as in ways I hope we will see less of.


Calva is growing. This is wonderful and twofold:

1. More users: We are in a period of picking up many new users. 🎉 It means we spend much more time on user support than we are used to. And that’s coming from a situation where user support is the bulk of the time we spend on Calva. We gain many insights. What the beginner experience is like. Bugs we were not aware of are discovered. Use cases we didn’t know existed look quite common. And so on.

2. More contributions: With user growth, and the various new needs and problems that reveals, bring more contributors.

The growth has changed the characteristics of Brandon Ringe’s and my work with Calva a bit. More time to support and learn from users and contributors, less time on adding features or fixing issues ourselves.

Brandon has nonetheless spent considerable time on trying to figure out a tool-chain where we can write more of Calva in ClojureScript. This is a theme throughout Calva’s short history. 😀 He has had some successes and some of the usual boring “this is really hard and strange” moments.

There’s a separate repository for figuring this out and learning before we start to try implement in the Calva project. We’ll see if that ever happens. There are advantages with the current tool-chain. Brandon mentions these:

  1. The official tooling and docs are geared toward TS, so there’s no translating stuff or figuring out how to make stuff work with cljs, aside from what we’ve already put in place.
  2. It’s really important to have input and contributions from beginners to Clojure to make Calva better for them. Some/most might be familiar with TS/JS or it might be easier for them to pick up than cljs. 1.
  3. Some contributors might be pretty familiar with VS Code extension dev, but not using cljs, and they might be more likely to contribute if it’s written somewhat or mostly in TS.

February was also a bit different in a not so pleasant way. In releasing some quite big new things, we by mistake changed things we did not want to change, and even broke some things for Windows (non-WSL) users. We have had to make two rollbacks of releases. The content of both these releases have been reworked and released again, save for one new feature which we hope to get in there soon. By this I am reminded about how special a project like Calva is, with so many use cases and different operating system environments, projects and expectations. We hope that our rollbacks were quick enough to not impact work too much for too many people. We try to learn as much as possible from the incidents. (I am pretty sure it will happen many times again. It comes with how the Calva project works.)

All in all, we have had 13 new Calva releases, including rollbacks:

Joyride with Borkdude is so fun!

I have spent most of my Joyride time, with a lot of assistance from Michiel Borkent, adding automatic testing. We’ve written a test-runner which is using clojure.test and Joyride itself. It’s for e2e testing so far (and possibly will stay like that). Like with Calva, the test-runner can support testing both the extension under development and a packaged VSIX. Both these are tested in the CI build-test pipeline.

There have been five new Joyride releases. * Basic e2e tests coverage (not tied to releases, but anyway) * Improvement in support for writing Joyride scripts with JavaScript * npm require fixes * Enable js/require * Improve JavaScript introspection from the REPL * Add rewrite-clj as a built-in library for Joyride scripts.

We have also made it possible to build Joyride using ESM, to make lazy requires possible. We got as far as we now need to make Joyride’s execution async, line nbb’s is. This needs to be spearheaded by Michiel, because he’s the one who knows what we are doing.

GitHub ReadME project attention

The GitHub ReadME Podcast geve the Calva model for comaintainership some focus. Brandon and I were interviewed. Some super high level words on what is Clojure survived the editing as well.

Various experiments conducted

As always I have been trying to figure out how we can support people new to Clojure better. This is all still quite chaotic for me, with my ideas and thinking being all over the place. Very much still in the hammock, even if some things sometimes find their way to Calva. And this time I’ve also created a Getting Started with Clojure mini-repo as a result of this thinking process. I’m hoping this project can help people find their footing quicker and give them help in starting their own first projects. I think example/starter projects in combination with Calva (and other IDE’s) support for them, as well as carefully crafted support for [neil] ( might take us far.

I have been experimenting a bit with Electric Clojure to try figure out how Calva supports it as is, and get an idea what Calva (and/or other extensions) could do to leverage this new development model. Not much to show for it, just some instructions contributed to the main and example app repositories. Electric Clojure is under rapid development, so this will have to be a revisited often this year. Thanks to the Electric Clojure team for assisting me so generously and kindly in my explorations.

I arranged my first Meetup, a [Clojure Meetup at that] (, featuring talks from [Josh Glover] ( and myself. It was hosted at the Agical (my employer) office, and food was provided by Pitch. The event was live streamed. Which was also a first for me, and not without problems. Our production broke with Josh’s presentation, leaving us only with a presenters camera which could only barely be convinced to film the slides as they where projected in the room. People tell us that it was still very enjoyable to follow the stream. * The full stream: Meetup Feb 23: Blambda! The sound of Babashka and Lambda colliding (talks start at 30 minutes) * My talk: [Give me Interactive Programming, or give me death] ( (please share around) I would summarize the meetup with the words of [Verner von Heidenstam] ( > It is fairer to listen to the string that broke than to never strain a bow.

Thanks for reading! /[Peter Strömberg (aka PEZ)] (

2023 Annual Funding: Peter Taoussanis

Hi everyone, Peter Taoussanis here :-) A brief update on my open-source work from Jan and Feb 2023 below.

Have been taking the unusual opportunity to concentrate on some larger/thornier items. Major things I’ve been working on (in ETA order):

  1. Sente v1.18,
    Beta expected: ~early March.
    Current status: in closed testing. This’ll include a significant number of improvements and overdue fixes, focused especially on reliability.

  2. Carmine v3.3,
    Beta expected: ~mid March.
    Current status: in closed testing. This’ll include a significant rewrite of the Carmine message queue - and provide greatly improved performance and inspection/monitoring capabilities.

  3. A new Clojure data encryption library,
    Alpha expected: ~late March.
    Current status: working-prototype ready. Will share more details when published, but the gist is that this’ll offer a set of tools heavily optimized for ease-of-use in some particularly common cases. Will support a future upgrade to Nippy’s encryption facilities. As part of this work, am planning to document some patterns that I’ve used in several Clojure web apps to secure user data.

With all upcoming releases, I’m also planning to start exploring some new ideas re: documentation. The intention will be to help better ease migration during major updates, and to help better accomodate beginners. Will have more to share on this later.

What then?

A big thanks again to Clojurists Together, Nubank, lambdaschmiede, and other sponsors of my open-source work.