For those who didn't follow, some news from 2022:

- SBCL is now callable as a shared library

- SIMD support

- faster (de)compression with zstd

- TRACE supports tracing macro functions, compiler-macro functions, individual methods and local functions (flet and labels)

- the SBCL repository reached 20,000 commits.

- Prebuilt SBCL binary for Android (Termux) (unofficial)

https://lisp-journey.gitlab.io/blog/these-years-in-common-li...

SIMD support is huge, and if you're willing to do a little hacking (SBCL is very easy to extend) you can even use it without the intrinsics

In fairness, "SIMD support" is not exactly "the compiler can reduce code to AVX instructions" but more like "you can now write non-portable custom assembly-like code to make your code faster".

That's what I mean by "willing to hack"! Getting the compiler to use SIMD instructions is actually pretty easy- you just specify where to use them and let it handle them. Then you pinky promise that your array really is made of floats and turn safety off.

Still better than no SIMD at all imo

Yup. I used to use Clozure CL all the time, but since the code I write tends to involve lots of number crunching, SB-SIMD and Loopus are indispensible.

Even before SB-SIMD, SBCL has always seemed like the best Common Lisp implementation for any arithmetic. Or at least this seems to be case when you benchmark CCL against it :)

but i assume a somewhat nicer interface than the internal VOP intrinsic stuff that sbcl has always had

For such a small team developing SBCL, it has been hugely stable, consistent, and advancing for years. SBCL has many ways it could improve, but it definitely exceeds most bars of quality for serious—even commercial—projects.

These kind of projects always impress me. Is it commercially backed or just a labor of love for the maintainers?

It's a mix of volunteer work, contract work, and contributions from paid employees. Google historically has been a big contributor since they use SBCL for Google Flights.

Wasn't ITA Software using CCL before their acquisition by Google? I wonder why they switched to SBCL. Right now CCL seems to be rather understaffed but this wasn't the case when they switched, as far as I know.

Back in 2009, before the acquisition, a developer ITA software presented at the SBCL workshop (audio here: http://www.sbcl.org/sbcl10/materials/cracauer-talk.ogg), talking about the company's use of SBCL. They'd also talked about using CCL; the last I heard was that they used one on desktops, the other in prod deployments.

CCL was primarily used for another project, and the decision to do so was dramatic and made many people unhappy. This thread has some juicy details from the time: https://news.ycombinator.com/item?id=911163

I haven't looked in a while, so I'm wondering what SBCL's GC latency profile is like nowadays. IIRC, it used to be a non-incremental STW conservative GC, which is a bit unfortunate.

It's at least good enough to release a game on Steam. Here's an experience report: https://raw.githubusercontent.com/Shinmera/talks/master/els2... (https://kandria.com/)

> Overall we have needed to do surprisingly little actual performance analysis and optimisation work to make Kandria run well. This is definitely in large part thanks to SBCL’s quite good native code compiler and type inference systems, and the prior work we’ve done to design critical libraries to not be completely obscene in terms of their performance characteristics.

> […]

This might align with your interest, from 2023.

https://applied-langua.ge/~hayley/swcl-gc.pdf

Which is itself based on Immix which was really neat:

https://www.cs.cornell.edu/courses/cs6120/2019fa/blog/immix/

Cool!

Thank you!

Follow-up question: is there a way to "freeze" the GC? As in, I've done all my allocations, now I want to run a main loop uninterrupted, and force clean up inside at_exit().

If you're not allocating, the gc won't run anyway. If you made a mistake and are allocating where you don't want to be, a gc pause might be preferable to a crash.

Try setting or binding SB-KERNEL:*GC-INHIBIT* to true.

That's a recipe for disaster. Never do that.

Damn, I searched the sources on GitHub for WITHOUT-GC but found nothing; I should have searched for SB-SYS:WITHOUT-GCING which is the actual user-facing interface. Thanks for the correction.

SYS:WITHOUT-GCING is better but is still fraught with danger (that's why I didn't mention it).

I think you'll want without-interrupts for that: https://sbcl.org/sbcl-internals/The-deferral-mechanism.html

That's not related to garbage collection.

It's also generational and moving, but other than that you're right.

For anyone wondering how it can be conservative and moving, for values that may or may not be pointers, it treats the data as pinned.

Originally CMUCL targeted RISC processors that had a lot of registers, so it maintained two stacks. X86 is extremely register starved, so the conservative GC was written.

In practice, the conservative nature doesn't cause problems on 64 bit architectures.

Why would a lisp gc need to be conservative, anyways? Unless we're talking about ffi or something.

Untagged memory addresses or integers may be produced as intermediate results.

I've found it to be pretty performant, but I rarely push it so who knows. SBCL is often good at avoiding allocations if you type hint things, which I'm usually doing when I need performance (messing around with sims mostly). But of course if you're doing unavoidably allocation-heavy work that doesn't do anything for you, so I'm not sure how much the gc hurts