[kryptiskt]

The big news here is that Racket now can run threads in parallel. While there were ways to get parallelism before (like places), this is much more lightweight and familiar. Anything that expands the areas where Racket is viable is good news to me since I like writing stuff in Racket.

[zelphirkalt]

While reading the release notes, I was also surprised, that they finally have this kind of multi-threading. I knew about places, but they were kind of inflexible, as you couldn't easily send a lambda in Racket, and serializable-lambda was infectious, so one ended up having to pre-define all logic and at runtime only sending data not functions to other places, which was a shame. One could not really build a thing that distributes work via multiple places with that. Or at least no one managed to do that and no one could tell me how to do it. I hope that with the new concurrency stuff this is now possible, even if it may not be as conceptually clean as places were supposed to be.

Ultimately, multi-threading is one reason, why I mostly used GNU Guile, instead of Racket in recent years. Guile's story of using multiple cores is much more solid, using its futures and possibly fibers via a library. I have used futures, which are backed by a pool of threads underneath, to implement a toy parallelized decision tree algorithm/model, that had linear (or close to) speedup.

[jetti]

What kinds of things do you write in Racket? I’m a clojure dev and so I’m a big fan of lisp. I’m just curious what kinds of projects you would use Racket for

[bmitc]

I'd say anything you use Clojure for except for Clojurescript.

[eru]

And I guess expect for stuff where you really want Java integration?

[bmitc]

There's a Java interface. I've never used it though.

https://docs.racket-lang.org/jni/index.html

[stOneskull]

i'm also curious.. do you use clojure because of jvm? i want to learn some kinda lisp, but there are so many choices. why not just common lisp or the one with emacs.

[lucyjojo]

personal case -

clojure works on the jvm, or without (babashka, technically graalvm i think), or in the browser (clojurescript). i think there is a .net implementation, not sure.

then you get clojure inspired languages that are quick to learn if you know clojure (janet, C runtime, fennel on the Lua platform).

And soon a clojure optimized for integration with C++ (Jank).

Bonus, clojure is relatively simple language. (it's a small language where most things are immutable, with a small-ish set of functions operating on a small-ish set of provided data structures).

common lisp is cool but looks way (waaay) more complex. so you will need to invest way more to learn it (might be worth it, dont know). i technically "learned" it but never felt the impetus to use it.

i occasionally do some stuff in emacs lisp. but i'll mainly be running clojure & babashka (and rust). currently refreshing my ocaml, and learning ada (this thing is great, should have learned it a long time ago). also nim.

[pjmlp]

There is a .NET version, but hardly gets much love, it is already a challenge for F#, and the Iron languages are gone as well.

Unfortunely the CLR seems to have changed meaning from Common Language Runtime to C# Language Runtime, regarding Microsoft focus on the ecosystem.

[jetti]

I personally use Clojure because I got a job doing it, I hadn’t touched it before my current position. I would pick it now over Common Lisp and Elisp because I prefer the syntax (I like the brackets in addition to parentheses) but also the Java integration and build tooling make things easier to get going.

[foretop_yardarm]

I use clojure over common lisp because I find the ecosystem (libraries) a bit more approachable (feels like there is more web oriented stuff in clojure, plus gui support with javafx.) That said, the actual experience of working in common lisp is better (bit better repl/recompilation, conditions, native compilation.) Personally, I don't find scheme as practical for writing programs as either of these two options (too fragmented and/or niche.)

[ModernMech]

I feel like version 9 just getting parallel threads kind of contradicts the homepage when it says Racket is "Mature" and "Polished".

[kryptiskt]

It's not at all strange, Python and OCaml are mature and polished and they still have tackled the same issue very recently.

[spdegabrielle]

This is addressed in the blog post linked from the release announcement: https://blog.racket-lang.org/2025/11/parallel-threads.html

[ModernMech]

That post is even more worrisome!

> To address larger problems with the implementation and to improve performance, we started in 2017 rebuilding Racket on top of Chez Scheme. Rebuilding took some time, and we only gradually deprecated the old “BC” implementation in favor of the new “CS” implementation, but the transition is now complete. Racket BC is still maintained, but as of August 2025, we distribute only Racket CS builds

So they're billing Racket as "Mature Practical Extensible Robust and Polished". Of those I will give them "Extensible" and "Robust". You can't say you're mature and polished and practical if you've just rewritten the entire thing and deprecated the legacy codebase to support new features that have been in other languages since forever.

Maybe they were talking about Racket 8.0 and didn't change the website yet?

[nesarkvechnep]

How rewriting something internally makes Racket not mature? Sounds like refactoring to me and with an extensive test suite there's nothing to be hysterical about.

[ModernMech]

Maybe I just have a different working definition of these words. To me "mature" means "fully developed" and "polished" means "achieved a high level of refinement". To me, rewriting it all to introduce a major feature that fills in a longstanding hole in the language doesn't say "mature and polished". Because often times many bugs are introduced into a codebase on a major rewrite despite extensive test suites, especially at the interfaces between features. Typically people might prefer a mature codebase to one that's just been rewritten precisely because it hasn't been vetted over years. "mature rewrite" sounds like an oxymoron to me, and I guess no one else agrees but I find it strange. That is all.

[neilv]

I think they don't always communicate well with industry practitioners, and your reactions are great evidence of that.

Racket is lead by professors, and (as is sometimes the case in systems research) some of them are very highly skilled software developers, well above HN average. But they have not been working in industry, and some have never worked in industry, so they don't always know what notes to hit, and they don't always know current subtleties of practice.

My best example of this is when someone kept saying the platform was "batteries included". My reaction was, my god, no, please don't say that: the first time the wrong person sees that, invests time with that expectation, and finds all the ways that is absolutely not true by industry convention, they will rip the ecosystem a new one.

Set expectations properly, and you attract the right people, who will love it, and they will also disproportionately be great programmers.

That said, the software engineering quality situation is much better than the impression you seem to have. They've done a very solid job of rehosting Racket internals, and of generally maintaining backward-compatibility over the years. Much better than Python, for example. (Also, Racket docs are usually much better than most ecosystems I have used in recent years.)

[shakna]

The rewrite started in 2017.

Fears about refactoring introducing bugs are fine and valid - but after eight years, haven't really happened. Seems the extensive test suite did its job.

This isn't a case of Python 2 v 3. Packages weren't broken en masse. The API remained stable.

If anything, the rewrite has proved that it is mature. Because they could perform a refactor without breaking everyone's everyday.

[hajile]

Nobody would consider Chrome or Firefox to be immature or lacking polish because they have replaced entire compilers several times over the past few years? I don't have an exact count, but they probably do this every 3-5 years which puts them way ahead of Racket.

I'd also note that Chez Scheme was a commercial implementation bought and open-sourced by Cisco. It wasn't something they threw together. Because it is a complete scheme v6 implementation they are building on instead of rolling their own implementation in C. Coding against a stable Scheme API has to be easier and less buggy than what they had before (not to mention Chez being much faster at a lot of stuff).

[bmitc]

I think you should read the old posts as to why Racket transitioned it's guts from primarily C to Chez Scheme. It would save a lot of time in the discussion here if you became familiar with that transition.

The short story is the same as anything written in C: it's an unwieldy language.

[nothrabannosir]

They might be making a distinction between the language and the current implementation. In fact I would call going through multiple different fundamental implementations without changing the semantics, an argument in favor of the maturity of the language.

[empthought]

Wait til you hear about NodeJS not supporting parallel threads until version 12...