Clojurians Log v2

To be merged soon: jank Support running against Phel in #clojure-test-suite: https://github.com/jank-lang/clojure-test-suite/pull/873 > Kudos to @j.s @emma.audrey.g @jeaye!

@leif.eric.fredheim you've been looking at Rust, right? what got you back to C?

genuinely curious, cause I'm working on AI-built "Clojure" in Rust 😛

which one?

not public yet

just lives between me and Claude

@tylertracey09 is also making one in rust https://clojurians.slack.com/archives/C03RZGPG3/p1776625152001149

oh nice

I can't get over Rust's weirdness, tried this thing 7 times and rage quit every time it started destroying my program with helpful circular compiler suggestions

"Type-hinted functions compile to native code through MLIR and LLVM." – that's almost exactly what I'm aiming for

I actually love Rust, it is verbose, but it's first low-level language I actually wrote something working in

@andrzej.fricze The idea was using C99 to achieve a minimal footprint and maximal portability (for the embedding use case) with no special toolchain dependencies. Following "the Lua model." Also, I have no experience with Rust, but I do have some experience with C and C++.

ok, that makes sense

I also like the dump simplicity of C, hehe

I have basically zero experience with any C, but already have some with Rust, so I'll stay on the path. my idea is to have Clojure-ish language with hints that allow AOT compilation as close to metal as possible

Clojure with bit of SBCL soul

check https://github.com/carp-lang/Carp

The core idea I started with is being able to embed mino into any host language that supports C FII, which is virtually all languages (including Rust).

nice. it's purely interpreted, right? tree-walking and interpreting right away? or is there something happening in between?

btw. I didn't know about https://github.com/rekola/nanoclj. seems Clojure is growing into language having the most implementations ever 😅

@andrzej.fricze I'm working on a bytecode VM experiment now.

@xnooga, early result from bytecode VM experiment:

./mino -e '(defn run [] (let [j 10000000] (loop [i 0 j 10000000] (if (zero? j) i (recur (inc i) (dec j)))))) (time (run))'
Elapsed time: 169.048 ms

Should be able to match Lua 5.5 at ~70 ms with some more work, I think.

what's your value representation?

Right now, just to get something working: 64-bit tagged-pointer Value* (3 low tag bits), so ints/bool/nil/char are inline immediates and everything else is a heap object pointer.

I have some ideas on how to leverage the fact that Clojure has persistent and immutable data structures, so the VM can probably make some bold assumptions that wouldn't be possible to make in other contexts. Messing about with that now.

teehee

note that this is basically cheating by pattern matching, I'm trying to do "hotspot opts"

added a way to detect hot loops and lower to optimized bytecode which only does arithmetic and comparisons fast

seems to work with recur and TCO too

but it's cursed and experimental

I'm refreshing my memory about how Erlang's BEAM works.

Hehe, found a solid optimization.

./mino -e '(defn run [] (let [j 10000000] (loop [i 0 j 10000000] (if (zero? j) i (recur (inc i) (dec j)))))) (time (run))'
Elapsed time: 28.148 ms

i got it down to ~170 using legit means just now

but anything lower than that is going to be very hard

@leif.eric.fredheim what did you do?

@xnooga, several things, but this is what yielded the biggest gain in that specific scenario: > Fused Counted-Loop Opcodes > > The compiler recognizes two common (loop ...) shapes: > >

(loop [i 0]     (if (zero? i)  (recur (dec i))))
> (loop [i 0 j N] (if (zero? j)  (recur (inc i) (dec j))))

But I'm not sure yet whether that won't break in insidious ways in other places.

I've tracked and benchmarked each change, and will release that with the updated changelog if/when I merge the experimental branch.

yesh fused opcodes are OP

I've had biggest gains on them in paserati, and it lends itself to this because the VM is beefy

JS is orders of magnitude more complex than clojure

hey @leif.eric.fredheim, welcome to the club of Clojure implementors 😄

Thanks! I just saw your implementation as well. Awesome!

I thought about doing a Go implementation at first, but decided ANSI C made more sense for the embedded use case.

I also did a PoC implementation in C++ and Rust, before landing on ANSI C 😅

Borrowing the things that Lua got right.

are you running https://github.com/jank-lang/clojure-test-suite ?

Yeah, mino passes that.

Or... At least it did last time I checked 😅 Lemme' check again.

mino also borrows the "actor model" from Erlang/BEAM, so that isolated/sandboxed runtimes are able to talk to each other without sharing state. I need that for cooperating bots.

wait, does it run all of these from source? https://github.com/leifericf/mino/blob/main/tests/compat/run.clj

Some of them. I'm using those as an "extended test suite."

I for one am loving this recent reaffirmation of Clojure as a symbiote that can make it’s way into anything. If AI helps speed that up, or improve the quality of the symbiosis: all the better. Kudos!

Nice! I myself mull over writing a "Lua Clojure" - I keep stumbling upon Lua everywhere and I just don't like the language at all. And Fennel doesn't quite cut it.

this is a tree walking interpreter, right? how's perf?

I'll add it to my bench comparison

BTW this is something you could be interested in: https://dependablec.org/ > the plainest possible C, that doesn't require any extensions, compiler settings, build steps

Yes! Thanks, @p-himik - I can't believe I haven't run into that yet.

You might also be interested in what Eskil Steenberg Hald does in general. :) He's the guy behind Dependable C.

@xnooga: The performance is quite shit in some cases to be honest. Here's the result of @borkdude’s test loop:

./mino -e "(time (let [x 0 j 10000000] (loop [i 0 j 10000000] (if (zero? j) i (recur (inc i) (dec j))))))"
Elapsed time: 9006.64 ms

I'd say perf is less important than completeness

you can always make this into a bytecode compiler or a simple JIT later working against a slow baseline

Yeah, I'm thinking to do a heavy push on performance after it's on-par with "the canon" in terms of features.

do you have results of the clojure-test-suite?

Not easily available where I sit now! (I've got everything set up on my Mac at home.)

please do share when you have a chance, I'm very curious :)

https://tratt.net/laurie/blog/2026/retrofitting_jit_compilers_into_c_interpreters.html Feels relevant while we're throwing around ideas 😅

yeah, meta tracing

there was a clojure impl called pixie, it was written in rpython and used pypy to obtain a blazing fast JIT

@xnooga, here are the current test results. Summary:

Suite files processed: 223
  OK (all assertions pass): 166
  Test failures:            49
  Load errors:              4
  Process crashes (segv):   2
  Timeouts (>30s):          2
  No summary line:          0

Aggregate (across files that completed): 207 tests, 4542 assertions: 4472 passed, 41 failed, 29 errors

nice!

I'm not 100% sure it makes sense to pass all tests in the embedded context as it might imply bloating up the C codebase significantly in some cases.

And I also want the artifact to be as small as possible. It's around 300 kb now.

But I'll be pushing it as far as possible within reason 🙂

yeah, that makes sense

also, this is for embedding in games, right?

Embedding in general, I'd say. But my particular need and focus is on games.

Clojure is quite interesting choice for a game scripting language 😄

Basically any situation where one might use Lua.

not that I don't support this decision wholeheartedly!

The pain of dealing with designer/user-written Lua scripts is real 😅

At first, I was only going to work on a very small subset of Clojure's core.

But as it turns out, doing more didn't increase the size that much.

as long as you're not pulling deps machine code is quite small

The only "dependency" so far is imath - But it's vendored C code.

are you producing static binaries?

Yeah, mino is available in "standalone" via Homebrew and Scoop.

300kB is nice, mine is 10MB 😂

10MB is still quite small, though!

But I need to spawn up to 100.000 runtime instances to simulate players (for game engine load testing; simulating player behavior).

So far, I've only tested it with 10K instances on my MacBook.

I might need to add support for distribution across several physical machines at some point (similar to how Erlang/BEAM does it).

But now I'm leaning towards that being the responsibility of the host.

BEAMy clojure could be very fun

Indeed! I migrated to Clojure from the Erlang/Elixir community in 2020, and I've been following https://clojerl.org and https://lfe.io 🙂

@xnooga, I've got some more tests passing now:

Suite files processed: 223
  OK (all assertions pass): 214
  Test failures:            8
  Load errors:              1
  Process crashes (segv):   0
  Timeouts (>30s):          0
  No summary line:          0

abs.cljc  fail=0  error=1  pass=9
dec.cljc  fail=1  error=0  pass=13
derive.cljc  fail=0  error=1  pass=2
inc.cljc  fail=1  error=0  pass=14
parents.cljc  fail=0  error=1  pass=5
reduce.cljc  fail=0  error=1  pass=7
short.cljc  fail=1  error=0  pass=23
vec.cljc  fail=1  error=0  pass=19

how many assertions total?

Aggregate (across files that completed): 219 tests, 5389 assertions: 5381 passed, 4 failed, 4 errors

congrats

Thanks, although I'm still finding plenty of bad bugs 😅

And the STM and Agent implementation isn't complete yet.

same

4696 / 4921 assertions, 217 files 🤔

one of us must be counting the assertions wrong

Yeah, something fishy there. I think maybe my test harness is bugged.

or mine is bugged 😄

I'll look into this

https://clojurians.slack.com/archives/C0A2CQQQVPB/p1776469397764149

that was before I stopped double counting 😄

Ah, nice! I didn't know there was a Slack channel for it.

Did a significant performance push today. I think this is as fast as it gets without going bytecode/JIT:

mino -e "(time (let [x 0 j 10000000] (loop [i 0 j 10000000] (if (zero? j) i (recur (inc i) (dec j))))))"
Elapsed time: 4785.35 ms

Tempted to take a stab at a register-based bytecode interpreter 😅 #MustResist

good idea, if I were making let-go VM today it would be register based, even with stack allocation

I did one for paserati and it behaves much better than a stack vm

I'll do an experiment/"spike" and see how it goes.

it's going to take some yak shaving 😉

But I don't think I'll ever do JIT because it's so much code, especially tracing JIT. If so, it would likely be a simpler copy-and-patch JIT.

If I want to keep mino small for embedding.

I made a small JIT and you can fit this into ~1000LOC for a single OS/arch, the problem starts whenm you want it to be portable

forget tracing 😄

LuaJIT is about 30KLOC (also C).

yeah, it will bloat

But it's insanely fast. LuaJIT 2.1 (tracing) does https://clojurians.slack.com/archives/C06MAR553/p1778449759566689?thread_ts=1778232073.320339&cid=C06MAR553 in ~4 ms.

I measured Babashka at 237 ms on my machine (median of 3 runs).

Lua 5.5 (register-based bytecode) does it in ~70 ms.

So I'm thinking best case for mino would be around ~70 ms.

yes, tracing JITs are brutal, the machine code for this loop in LuaJIT would probably be something like label inc dec compare jump

to reach even 70ms you'd have to figure out good value representation and have a decent optimizer

Yeah, more realistic is around Babashka's performance, I think.

But even that will be difficult.

go incremental, bytecode VM should get you in babashka ballpark

@xnooga I've merged the bytecode VM to main now. You will find a detailed log of all changes https://github.com/leifericf/mino/blob/main/CHANGELOG.md if you're curious or want to try some of those things yourself. All the bytecode VM changes are from version https://github.com/leifericf/mino/blob/main/CHANGELOG.md#v01050--bytecode-vm-foundation to https://github.com/leifericf/mino/blob/main/CHANGELOG.md#v01450--fusion-cycle (inclusive). Note that some of those changes, especially the last opcode fusion stuff, are potentially quite flaky and dangerous. But I've added a bunch of tests and run some exploratory adversarial tests, and it seems fairly stable. The challenge is to know in advance which aspects of Clojure are truly static and predictable, so it's safe to treat them as axioms when optimizing the bytecode (I have a separate idea about that involves a formal and executable Clojure language spec and “meta-analysis engine” written in core.logic or Prolog with introspection, but that will be a separate huge project later).

http://mino-lang.org/documentation/bytecode-vm/

wow, great progress, no notes

also, comes along really really fast 😄

I've been practicing coding with heavy AI use almost every day for 6 months, as I'm in charge of those experiments at work. I’ve built several tools to help with that, like https://noumenon.leifericf.com (and other proprietary tools). That's why it's so fast. But there are undoubtedly serious downsides to that approach as well. mino sort of doubles as my experimentation/test bed for AI-driven coding, improving my Claude Code skills and custom sub-agents, and other tools I’m building. It's taking a stab at building something relatively large and complex with AI, learning how to write better specs and tests for AI agents, trying different LLMs, writing better prompts, and adapting my workflow for AI agent use, etc. I tried to pick a serious, real project I’ve been thinking about for some time and, at the same time, solve a real pain point in game engines for work.

I understand this completely, I've been early adopter of these tools myself. Completely understand the idea of having an experimental project outside work as a lab for dialing these workflows in. Last April I started https://github.com/nooga/paserati and managed to get it to 98.4% compliance with latest ecma262 spec - that's ~30k tests proving that the approach works. I have many thoughts about this but not sure if this thread is a good place for this conversation 😄

let-go was hand-coded and boosted with AI, paserati is completely "vibe coded"

Yeah. Unfortunately, there is quite a lot of irrational fear and hostility against the use of AI. The topic is a bit controversial, like politics and religion. I'm trying to remain rational, skeptical, and pragmatic; focusing on what works and what doesn't work by actually trying things out for myself on real problems.

I'm by no means zealous about using AI, and I understand that there are many legitimate criticisms. At the moment, I'm viewing it as "just another tool to learn and evaluate," because it seems like it's here to stay for better and for worse.

I hate it and love it at the same time 😂

yes, I've been called names and nearly banned from places for discussing paserati, even though the communities there seemed interested in it last year 😅

Same…

But as a former pastor-in-training and aspiring theologian/Christian apologist for 10+ years, I have become somewhat immune to rejection and contention, hehe

I have a huuge blogpost about using AI and the paserati experience, its technological and cultural implications, my feelings, much like yours are quite ambivalent: excitement vs dread

The main objections i hear from work are ethical and environmental.

hm, is it ok if I DM you? I'm thinking we should move this convo off announcements thread :D

Ah, I thought this was DM! Haha

My bad

😞 I hoped that discussion will develop here 😄

Haha, maybe such discussions deserve a channel of their own.

I started hugely AI-skeptical, then organized few editions of AI conference and right now I'm working in startup building AI-guided coding platform

and TBH I've no idea what is my opinion about AI 🤖

I have probably 3 or 4 different ones and they change hourly

maybe we could start a thread in #mino? I think we are pinging a bunch of ppl now, not sure 🤔

I think there are considerations that sound ethical at first, but are actually pragmatic: • If LLMs are the new junior devs, we’re currently at the all-time high of senior devs. What happens when they retire? • If you don’t understand what your app is doing, there might be problems further down the line. This is already true for complex enough systems, but LLMs add an additional layer of distance between the person and the artefact.

Let's make a channel for AI stuff, I guess. Unless one exists already.

#ai-assisted-coding

Ah, nice

As for myself, I'm really only interested in the practical applications of AI.

Other people with more time can fight over the ethical and sociopolitical stuff.

Not that I think it's unimportant or uninteresting. I just don't have enough time or energy to learn about all the details and nuances of those issues.

it's also hard to know what will be the long-term impact

do we know will Anthropic be on the stage in a year? I've no idea. do we know how much will new GPT cost in a year? I've no idea

do we know how the law will change to accomodate for code or art generated with help of AI? also no idea 😛

we can only guess and do our best in learning how to harness this tools

Yes. For example, some argue against AI because of power consumption. Others argue for AI because the power consumption encourages the long-term development of technologies like clean nuclear energy and other methods. I don't know either way.

What I can do is figure out how to use (and not use) AI in my life.

yeah, apparently at some point cars were treated like solution to pollution in cities, because you'd have so much horse shit laying around that air used to be just filthy

so maybe AI will, in the end, force the world to develop better technology for creating/storing energy

let's hope for that 😄

and I'm not trying to make some particular analogy, just rather: fuck we really don't know what future brings

I imagine all the world's PCs, cellphones, and other tech also use a significant amount of energy. Not to speak of electric vehicles, heating, refrigerators, and other power-consuming inventions we take for granted today. Why is nobody protesting those things?

well they are useful 😄

I suspect it's because those things are old, boring, and normalized. AI is new and scary, with many unknowns.

I think the only thing I'm comfortable saying with a fair degree of certainty is that AI is here to stay in some shape or form for the remainder of my lifetime. That's my operating assumption. I can choose not to deal with that. Instead, I have chosen to adapt and make the best of it.

But I don't resent or criticize more conservative devs who went the opposite way.

I had a heated argument with a person who pointed out all the downsides - I ask them if they drive and they said it's different because in US you risk unemployment if you cannot get to work by car. The same person also stated that they cycle /dev/urandom > coding agent > /dev/null because their boss checks token usage and mandates that all developers use coding agents. This is like leaving your car on idle in protest of the oil industry. And this person could not see the contradiction while claiming that this is good because "the slop does not get out into the world". I completely agree with many of the problems - resource consumption, brain rot, harmful generated content, unclear IP story, slop. But at the same time I don't see how LLM output in itself can be such big of a problem - it's text, it's inert unless executed, and since these generators are tools it is up to us humans to curate and execute whatever comes out.

It's the same story with all contentious topics like carnivores vs vegetarians. There has always been and always will be topics that divide groups of people. But each person can choose how to engage, integrate and react.

ultimately I think it's a mix of justified fear and dogma enforced by bad experiences 🤷‍♂️ IMO it's better to know your enemy if you think it's your enemy

what's interesting, when let-go hit the first page of hackernews people were annoyed by my README with em-dashes but were excited by the code itself

If there is one lesson I learned in my decade as a Pentecostal pastor-in-training and my subsequent self-deconversion, and the bringer of https://www.streetepistemology.com to Norway, it's this: it's not worth your time and energy talking to people who are https://en.wikipedia.org/wiki/Epistemic_closure and thus incapable of critically evaluating and revising their own belief-forming process (epistemology). I often see the same pattern in these AI-related debates.

For someone who's not familiar with Lua, how does the binary size compare to what Lua produces?

The total memory footprint is about 500 KB. A minimal, stripped down version can be under 64 KB. mino will likely land somewhere in the middle.

I don't know if it's intended for it, but the size and boot time would make it plenty fast/small for eg. edge runners as well.

I've made it modular as well in a similar way to Lua. So the host can install only what it requires to keep the size down.

But the standalone binary ships with everything included by default.

I suppose there could be some use cases I haven't thought about where it could be a good fit. I've mainly focused on embedding constraints, but that might inadvertently lead to advantages in other scenarios.

@henrik re edge runners, I'm trying to set up let-go as a custom runtime on AWS Lambda, my hope is that it will start in less than 10ms there , which is not to shabby for a lambda

Last time I checked, mino did ./mino -e '(+ 1 2)' in 6.8 ms. When a host creates one runtime upfront (`mino_state_new` + mino_install_all) it starts in 3.5 ms. Measured on my M3 MacBook Pro. But a lot has changed since last I measured. I need to update the performance page with new numbers, and I suspect it's slower now (because of more lazy-bundled libs).

But I also haven't spend much effort on optimizing things yet. The speed is just a coincidence at this point.

I think that you might be spending precious miliseconds on parsing and tree-walking core libs, let-go caches them as bytecode so there is almost no penalty for loading the stdlib

Yeah, I'm still a bit torn about whether or not to go in the AST/JIT direction. I'm not sure how much it will bloat up the footprint and make the code base more difficult to reason about. And I’m not sure if it provides more pros than cons to the embedding story.

One tricky aspect is also how to strip out as much as possible and allow the host to install only what it wants in the runtimes.

Lua provides some general good design direction for those things, though.

There is also LuaJIT.

My thinking is to get mino “feature complete” and then try to get as much performance out of it before adding additional layers. But I’m not sure.

Very cool! Not sure how I missed this

I ended up going down a bit of a rabbit hole on my end. If anyone has heard of parrot from nvidia. I've been trying to build a DSL for automatic kernel fusion. Its pretty finicky

Ironically I feel like this is something where the power of lisp could be felt clearly by non believers, if you will. If you look at parrot codebase, it's rough. I mean maybe it's transparent to people that think that way regularly. Not to me, though.

Something akin to Hy for Mojo could be cool as well

Of course I put together “Clojo” but it's more of a gimmicky look ma no hands vibe. Could be neat to see it through, though.

To chime in on the AI discussion. I'm honestly incredibly conflicted about using LLMs myself. I've been avoiding it for personal projects recently because it definitely starts to impact my own attention to detail and skill I feel. There's no opportunity to avoid it at work anymore

found it useful immediately, thank you!

Music to my ears!

One suggesion: when the currently selected library has many direct dependencies, only a few of them fit on screen (vertical) and scrolling the list is quite slow. There might be an improvement possibility to this overview

Are you looking at com.repl/rama with its 190 dependencies? Yes, need to come up with something that works when there's so many. Mouse wheel and trackpad scroll works better than clicking one at a time.

If it's not obvious, those are available today (the docs should call that out better) but it's not obvious what to do to make it better. Cmd-click to scroll a page at a time instead of one at a time?

It wasn't rama repl, it was one of the corporate projects I work on 🙂 Thanks for the suggestion, I'll try cmd-click next week

Cmd-click is something I'd have to implement.