I tried out subzero to make web components with #Clojurescript. The build with shadow is eye-watering 350kb for a button component. I know my way around in CLJS but it's not unlikely I just made some stupid mistake. Does anyone have some experience using it?
https://github.com/raystubbs/subzero
#clojurescript
I just realized ClojureScript has no support for rational numbers 😔
I am spoiled: I got so used to everything "just working" in #ClojureScript that it didn't even occur to me that it might not have exact rational arithmetic like #Clojure.
https://swannodette.github.io/2025/11/24/aimless/
This is really a delightful trick from @swannodette@mas.to. Instant #clojurescript repl for exploration. No project, no ShadowCLJS, etc.
It's some kind of "tiny" magic to import your own web component and use it together with others in a web project. Just include the JS file and add the html tag. (in my case [:my-component] bc #Clojurescript). That's the way! #webdev
A mashup between reagami and webcomponents. I don't know why you would do this, but you can!
Minigraph progress: multiple selection and drag selection. https://github.com/apossiblespace/minigraph #clojure #clojurescript
pr-str, prn, etc now print EDN instead of JSON in squint, as you can see in this beautiful draggable button demo
In edamame you can intercept the parsing of maps, so you could even return ordered maps. Or if you have a custom type, like a js Map, you can intercept map first (to return an ordered coll) and then build the js Map from that.
user=> (e/parse-string "#js/map {:a 1 :b 2}" {:map (fn [& m] m) :readers {'js/map (fn [x] (prn :x x))}})
:x (:a 1 :b 2)
Once upon a time, I used to be an outlaw; so I wrote code like this (just for fun):
const char* gauge(int n, int s, int b) {return n < s ? "Smol" : n > b ? "Big" : "Mid";}
The method to the madness was that at least I could differentiate things by looking at the braces and other symbols.
Now, there's the OG called Lisp and its comrades like Scheme, Racket, etc.
Their rule is: if you keep a close eye on parentheses, the rest are just whimsical words that you type — which is kinda similar to my outlaw days.
(define (gauge n small big)
(cond((< n small) "Smol")
((> n big) "Big")
(else "Mid")))
But at least, for the love of eyewear, can't we make it a norm to CAPITALIZE the procedure names?
(define (GAUGE n small big)
(cond((< n small) "Smol")
((> n big) "Big")
(else "Mid")))
P.S. I know, code is data and data is code, so at the end of the day it doesn’t matter.
But still, for the love of .......🥸
Did I ever tell y'all about this (possibly insane) thing I did to embed #ClojureScript in a webpage using a #WordPress plugin? It works!! #programming https://sr.ht/~earneson/playfair-key-generator/
Out of band DOM updating (manually messing with DOM elements) counter example in Reagami
The on-render hook in reagami just got more awesome. You can now pass data from mount to update to unmount, by just returning data!
Building Browser-Native Presentations with Scittle
https://clojurecivitas.github.io/scittle/presentations/browser_native_slides.html
By Burin Choomnuan
It suddenly occurs to me that #replicant 's pure-data-only model for Hiccup means that one could get server-side rendering 'for free' if their view functions are pure, by say, running them through #chasis.
This wouldn't handle hydration, but this accidental convergence really shows how data-oriented tech naturally flows together.
Today I forked the somewhat abandoned PivotTable.js and spent my time upgrading it's dependencies to the latest versions, even JQuery from v1 to v3, and rewriting parts of it for cleaner code and much better performance, using conditional rendering.
The library is written in #coffeescript which makes sense for the time it was created in (~10 years ago I think). But coffeescript seems downright idiotic compared to modern #javascript it only adds overhead and you will get a very unoptimized and bad js output.
I was thinking of rewriting the whole library in #typescript with functional programming patterns, or #clojurescript . I was leaning more towards clojurescript tbh.
But I realized too much work is put in this library and fully rewriting it would be very costly for me. Even though I'm getting paid to do it, we got a lot more to do.
The library is very well put together and has many capabilities. You can tell it has took a lot of time & effort.
But the code is very questionable.
Full rewrite some day maybe
Reagami now has an on-render hook that you can use to mount/update/mount a 3rd party JS component.
#clojure #clojurescript #squintcljs
Demo:
Here are my September and October 2025 OSS highlights and updates.
https://blog.michielborkent.nl/oss-updates-sep-oct-2025.html
Thanks for supporting my work!
And perhaps see you at the Conj?
Edamame, a configurable parser for EDN and Clojure code now supports ClojureCLR! Thanks to Ambrose Bonnaire-Sergeant.
Reagami, my copy-pastable Reagent-without-React-like lib was ported to CLJS (minimal changes needed) and now can even run in a SCI playground:
https://babashka.org/sci.configs/?gist=568945514e5061273ee1eb26f2c699ed
You can also test it with regular CLJS, maybe interesting for :lite mode. Git repo here: https://github.com/borkdude/reagami
Client Info
Server: https://mastodon.social
Version: 2025.07
Repository: https://github.com/cyevgeniy/lmst