Racket Blog

Racket Blog
Racket
blog
23 Feb 2026
Racket v9.1
posted by Stephen De Gabrielle and John Clements
We are pleased to announce Racket v9.1 is now available from
As of this release:
Documentation organization and navigation can be specialized by language family, to allow users to interact with documentation in a way that is tailored to that language family. This is currently used by Rhombus.
The
for
form and its variants accept an
#:on-length-mismatch
specifier.
3.18 Iterations and Comprehensions: for, for/list, …
DrRacket improves the GUI for choosing color schemes.
DrRacket has curved syntax arrows. The degree of curvature indicates the relative left- or right-displacement of the arrow’s target.
DrRacket’s “Insert Large Letters” uses characters that match the comment syntax of the buffer’s language, making it useful (and fun!) in Rhombus.
The
exn-classify-errno
maps network and filesystem error numbers on various platforms to posix-standard symbols, to enable more portable code.
10.2 Exceptions
The behavior of Racket BC on certain character operations (most notably
eq?
) is changed to match that of Racket CS, with a small performance penalty for these operations for BC programs.
19 Performance
1.5 Implementations
The
make-struct-type
procedure can inherit the current inspector using a
'current
flag. This is the default behavior, but there are situations in which it’s not possible to refer to the current inspector.
5.2 Creating Structure Types
Bundle configurations can better control the conventions for locating shared object files with the
--enable-sofind=
flags.
The
system-type
function can report on platform and shared-object-library conventions with new flags.
15.8 Environment and Runtime Information
The
openssl/legacy
library makes it possible to access OpenSSL’s built-in “legacy” provider, to get access to insecure and outdated algorithms.
OpenSSL: Secure Communication
Typed Racket improves expected type propagation for keyword argument functions.
There are many other repairs and documentation improvements!
Don’t forget to run
raco pkg migrate 9.0
Thank you
The following people contributed to this release:
Alexander Shopov, beast-hacker, Bob Burger, Brad Lucier, Cadence Ember, David Van Horn, evan, François-René Rideau, Gustavo Massaccesi, Jacqueline Firth, Jade Sailor, Jason Hemann, Jens Axel Søgaard, John Clements, Jonas Rinke, Matthew Flatt, Matthias Felleisen, Mike Sperber, Noah Ma, Pavel Panchekha, Rob Durst, Robby Findler, Ryan Culpepper, Sam Tobin-Hochstadt, Stephen De Gabrielle, and Wing Hei Chan.
Racket
is a community developed open source project and we welcome new contributors. See
racket/README.md
to learn how you can be a part of this amazing project.
Feedback Welcome
Questions and discussion welcome at the Racket community on
Discourse
or
Discord
Please share
If you can - please help get the word out to users and platform specific repo packagers
Racket - the Language-Oriented Programming Language - version 9.1 is now available from https://download.racket-lang.org

See https://blog.racket-lang.org/2026/02/racket-v9-1.html for the release announcement and highlights.
more →
23 Nov 2025
Parallel Threads in Racket v9.0
posted by Matthew Flatt, Ryan Culpepper, Robby
Findler, Gustavo Massaccesi, and Sam Tobin-Hochstadt
With the version 9.0 release, Racket includes support for
shared-memory threads that can take advantage of multicore hardware
and operating-systems threads to run in parallel—
not merely
concurrently with other Racket threads, as was the case in versions before 9.0.
Creating a thread that runs in parallel is as simple as adding a
flag to the call to
thread
To see the effect, try first putting the following code into a file named
"thread.rkt"
and running
racket thread.rkt
on the
command line:
#lang
racket/base
define
22
define
go
thread
for
in-range
expt
black-box
sqrt
define
t1
go
define
t2
go
thread-wait
t1
thread-wait
t2
Racket will find many square roots (tweak
to match your
machine), but will keep only one core of your CPU busy. Using
time
in the shell reports “CPU” (possibly broken into
“user” and “system”) and “real” times that are similar. To
use two cores, add
#:pool
own
to the
thread
call:
#lang
racket/base
define
22
define
go
thread
#:pool
own
<-- only change is here
for
in-range
expt
black-box
sqrt
define
t1
go
define
t2
go
thread-wait
t1
thread-wait
t2
In this case, real time should be about half of CPU time, while CPU
should remain similar to before. In other words, the parallel version
runs twice as fast. On the machine used
below
concurrent
parallel
×1
1011 msec real
979
msec CPU
10
msec CPU for GC
×2
517 msec real
1021
msec CPU
13
msec CPU for GC
Passing the new
#:pool
argument
creates a
parallel thread
; create pools via
make-parallel-thread-pool
to have a group of threads share
processor resources or just pass
own
to have the
new thread exist in its own
parallel thread pool
As a further addition to
thread
, a
#:keep
result
argument keeps the result of
thunk
when it returns, instead
of discarding the result. Retrieve a thread’s result with
thread-wait
. So, for example,
thread-wait
thread
thunk
#:pool
own
#:keep
result
runs
thunk
in parallel
to other Racket threads, blocks the current Racket thread (while
allowing other Racket threads to continue, even non-parallel ones),
and then returns the result value(s) when
thunk
completes.
To maintain backwards compatibility, the
thread
function still creates a
coroutine
thread
by default, which is a lightweight thread that is preemptively
scheduled and whose execution is interleaved with other coroutine
threads. For many tasks that need the organizational benefits of
concurrency without the performance benefits of parallelism, such as
when managing GUI interactions or orchestrating remote processes,
coroutine threads are still the best abstraction. Coroutine threads
can use
#:keep
result
, too.
Racket’s full thread API works with parallel threads. Follow the links
from the
thread
documentation to see more details on thread
pools and for more interesting uses. Of course, just because you put
tasks in parallel threads doesn’t mean that they always speed up,
as sharing and communication can limit parallelism. Racket’s
future
visualizer
works for parallel threads, though, and it can help you
understand where synchronization in a task limits parallelism.
Also, adding parallelism to Racket potentially creates trouble for existing
libraries that were not designed to accommodate parallelism. We expect
problems to be rare, however.
We’ll explore the performance details and explain why we expect most
programs will continue to work well later in this post, but first:
Racket’s Road to Parallelism
Running threads in parallel counts as news in 2025?! Well, it has been a long
road.
Racket’s implementation started in the mid-1990s, just as a wave of
enthusiasm for parallel programming was winding down. Although
operating systems by that point consistently supported within-process
threads, computers with multiprocessors were not commonly available.
Many language runtime systems from the same era—
including Python,
Ruby, and OCaml—
took advantage of the internal simplicity of a
single-threaded runtime system while offering constructs for
concurrency
at the language level. Racket has always
included threads for concurrency, and it was an early adopter of
Concurrent ML
’s
abstractions for managing concurrency well. But an absence of
parallelism was deeply baked into the original implementation.
Over time, to provide support for parallelism, we added
places
and
futures
to Racket. Places support
coarse-grained parallelism through a message-passing API, effectively
running parallel instances of the virtual machine within a single
operating-system process; limited sharing makes the implementation
easier and safer than arbitrary sharing between parallel threads.
Futures provide fine-grained parallelism for restricted computations;
a future blocks when it tries to perform any operation that would be
difficult for the runtime system to complete safely in parallel.
Places and futures are both useful, and they avoid some pitfalls of
shared-memory threads. Still, fitting a parallel task into futures or
places usually requires special effort.
Meanwhile, single-threaded execution was only one of the problems with
the original Racket (a.k.a. PLT Scheme) implementation. 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 at
Chez Scheme is a much better foundation for improving parallelism in
Racket. Part of the Racket-rebuilding effort included improving Chez
Scheme’s support for parallelism: we added memory fences as needed for
platforms with a weak memory-consistency model, and we parallelized
the Chez Scheme garbage collector so that garbage collection itself
runs in parallel. There’s still plenty of room for improvement—
the
garbage collector is only parallel with itself, not the main program,
for example—
but further improvements are more within reach than
before. Equally important, the rebuild included new implementations of
the Racket thread scheduler and I/O layer in Racket itself (instead of
C). Because of these improvements, Racket’s futures worked better for
parallelism from the start in Racket CS than in Racket BC.
With version 9.0, we finally take advantage of new opportunities for
parallelism created by the move to Racket CS. Internally, a parallel
thread is backed by combination of a future and a coroutine thread.
The main extra work was making Racket’s coroutine thread scheduler
cooperate more with the future scheduler and making the I/O layer safe
for Chez Scheme threads—
all while making locks fine-grained enough
to enable parallelism, and keeping the cost of needed synchronization
as low as possible, including for non-parallel Racket programs.
Performance
Here are some simple benchmarks on an M2 Mac to give a sense
of the state of the current implementation. This machine has 8
cores, but 4 big and 4 little, so ×4 speedup is possible with
4-way parallelism but less than ×8 with 8-way parallelism.
As an easy first example, we should expect that a Fibonacci [
code
] run of
1 iteration in each of 4 coroutine threads takes the same time as
running it 4 iterations in 1 thread, while 1 iteration in each of 4
parallel threads should take about 1/4th of the time. Also, for such a
simple function, using plain old futures should work just as well as
parallel threads. That’s what we see in the numbers below.
Times are shown as a speedup over single-threaded, then in
real elapsed milliseconds, with CPU milliseconds as the upper smaller
number to the right, and CPU milliseconds that are specifically for GC
as the lower smaller number to the right. The times are from a single
run of the benchmark.
fib
40
real msec
CPU
GC
sequential
coroutine
parallel
futures
×1
511
493
×1
506
490
×1
494
494
×1
495
495
×1
2045
1978
×1
2034
1967
×3.7
554
2210
×3.8
545
2168
×1
4154
4021
×1
4154
4021
×5.4
776
5928
×5.2
796
6006
Of course, most programs are not just simple arithmetic. If we
change our example to repeatedly convert numbers back and forth
to strings as we compute Fibonacci [
code
], then
we can see the effects of the more complex conversions. This version
also triggers frequent allocation, which lets us see
how thread-local allocation and parallel garbage collection scale.
strfib*
32
real msec
CPU
GC
sequential
coroutine
parallel
futures
×1
204
197
×1
205
198
×1.1
192
192
×1
211
203
×1
826
796
10
×1
808
780
×3.7
222
861
10
×3.7
221
857
10
×1
1619
1563
11
×1
1602
1545
×3.9
419
2544
59
×4
406
2551
59
From this table, we still see reasonable scaling up to four cores,
but the additional work and the use of the garbage collector limit
scaling beyond that point.
That first string variant of Fibonacci includes a slight cheat,
however: it goes out of its way to use a
string->number*
wrapper that carefully calls
string->number
in a way that
avoids evaluating expressions that compute the default values of some
arguments. The defaults consult the
parameters
read-decimal-as-inexact
and
read-single-flonum
which a perfectly fine thing to do in
general, but turns out to block a future, because parameter values
can depend on the current continuation. In contrast, parallel threads
continue to provide a benefit when those kinds of Racket constructs
are used. We can see the difference by using plain
string->number
in place of
string->number*
, which
will fetch parameter values 14 million times in each individual run of
strfib
32
strfib
32
real msec
CPU
GC
sequential
coroutine
parallel
futures
×1
772
751
×1.3
578
562
×1.1
721
721
×0.9
873
851
×1
3169
3085
12
×1.3
2364
2303
×4
797
3103
33
×0.8
4164
4058
×1
6409
6225
14
×1.4
4730
4608
13
×4.3
1493
9166
197
×0.8
8353
8135
The coroutine column here also shows an improvement, surprisingly.
That’s because a coroutine thread has a smaller continuation than the one in
the sequential column, and the cost of fetching a parameter
value can depend (to a limited degree) on continuation size.
The effect of parallel threads on this kind of program is
more consistent than fine details of a continuation’s shape.
Operations on mutable
equal?
-based
hash tables
code
] are another case where
futures block, but parallel threads can provide performance
improvement.
hash-nums
real msec
CPU
GC
sequential
coroutine
parallel
futures
×1
193
184
×1
190
182
×1
186
186
×1
191
182
×1
767
733
×1
763
729
×3.7
208
824
×1
763
729
×1
1541
1473
11
×1
1532
1463
×4.5
346
2373
24
×1
1539
1470
As an illustration of the current limitations of parallel threads in
Racket, let’s try a program that writes data to a byte-string
port
then hashes it
code
].
hash-digs
real msec
CPU
GC
sequential
coroutine
parallel
futures
×1
127
123
×1
127
123
×0.9
135
135
×1
126
122
×1
503
487
13
×0.9
536
519
35
×2.5
201
599
38
×1
520
504
28
×1
1022
986
33
×0.9
1097
1057
81
×2.5
403
1630
85
×1
1049
1017
60
Here we see that parallel threads do get some speedup, but
they do not scale especially well. The fact that separate
ports are not contended enables performance
improvement from parallelism, but speedup is limited by some
general locks in the I/O layer.
Even further in that direction, let’s try a program that
hashes all files in the current directory [
code
] and
computes a combined hash. When run on the
"src"
directory of
the Racket Git repository, most of the time is reading bytes from
files, and locks related to file I/O are currently too coarse-grained
to permit much speed-up.
hash-dir
real msec
CPU
GC
sequential
coroutine
parallel
futures
×1
170
169
×1
169
169
×0.7
256
248
×1
170
170
×1
692
690
×1
662
658
×1.3
515
1068
×1
681
679
×1
1393
1377
10
×1.1
1293
1290
×1.6
868
2158
18
×1
1368
1366
Having locks in place for parallel threads can impose a cost on
sequential programs, since locks generally have to be taken whether or
not any parallel threads are active. Different data structures in
Racket use specialized locks to minimize the cost, and most benchmarks
reported here run report the same numbers in sequential column in Racket v8.18 (the
previous release) and Racket v9.0. The exceptions are the
hash-nums
and
hash-digs
benchmarks, because
those measure very-fine grained actions on mutable hash tables and I/O
ports, and the cost is largest for those. Comparing sequential times
for those two versions shows that support for parallel thread can cost
up to 6-8% for programs that do not use them, although the cost tends
to be much less for most programs.
hash-nums
real msec
CPU
GC
v8.18 sequential
v9.0 sequential
×1
188
180
×0.96
195
187
×1
757
728
×0.98
773
739
×1
1520
1461
×0.98
1546
1477
12
hash-digs
real msec
CPU
GC
v8.18 sequential
v9.0 sequential
×1
118
114
×0.94
126
122
×1
474
458
12
×0.94
506
489
13
×1
947
915
25
×0.92
1025
989
26
Overall, parallelizable numerical programs or ones that manipulate
unshared data structures can achieve speedup through parallel threads
relatively easily, but I/O remains a direction for improvement.
Backward Compatibility
If a library uses mutable variables or objects, either publicly or
internally, then it must use locks or some other form of concurrency
control to work properly in a multithreaded context. Racket already
has concurrency, and the expectation for libraries to work with
threads does not change with the introduction of parallel threads.
Racket’s semaphores, channels, and other synchronization constructs
work the same with parallel threads as concurrent threads. Even
programs that use lock-free approaches based on compare-and-swap
operation (such as
box-cas!
) continue to work, since Racket’s
compare-and-swap operations use processor-level primitives.
Still, there are a few concerns:
Racket’s coroutine threads offer the guarantee of
sequential consistency
, which means that effects in one
thread cannot be seen out-of-order in another thread. Parallel threads
in Racket
expose
the underlying machine’s memory-consistency model
, which may allow
reordering of memory effects as observed by other threads. In general,
a weak memory model can be an issue for code not intended for use with
threads, but Racket—
more precisely, Chez Scheme—
always guarantees
the memory safety of such code using memory fences. That is, Racket
code might observe out-of-order writes, but it never observes
ill-formed Racket objects. The fences are not new, and they are part of
the same write barrier that already supports generational garbage
collection and the memory safety of futures. Although
sequential consistency supports lock implementations that don’t work
with weaker memory models, so they would work with coroutine threads
and not parallel threads, we have not found any such
implementations in Racket libraries.
Some Racket libraries use
atomic mode
for concurrency
control. Atomic mode in Racket prevent coroutine thread swaps, and
entering atomic mode is a relatively cheap operation within Racket’s
coroutine scheduler. When a parallel thread enters atomic mode, then
it prevents other coroutine threads from running, but it does
not
prevent other parallel threads from running. As long as
atomic mode is used consistently to guard a shared resource, then it
continues to serve that role with parallel threads.
Entering atomic mode is a much more expensive operation in a parallel
thread than in a coroutine thread; in many cases, Racket core
libraries that need finer-grained locking more specifically need to
move away from using atomic mode. Still, making atomic mode
synchronize a parallel thread with coroutine thread provides a
graceful fallback and evolution path.
Foreign functions that are called by Racket in a coroutine
threads are effectively atomic operations when there are no parallel
threads, since a coroutine swap cannot take place during the foreign
call. It’s rare that this atomicity implies any kind of lock at the
Racket level, however, and the foreign function itself is either
adapted to operating-system threads or not. Racket can already create
operating systems threads through
dynamic-place
, and
foreign-function bindings have generally been adapted already to that
possibility.
The greater degree of concurrency enabled by parallelism exposed some
bugs in our existing core libraries that could have been triggered
with coroutine threads, but hadn’t been triggered reliably enough to
detect and repair the bugs before. Beyond those general improvements,
our experience with pre-release Racket is that parallel threads have
not created backward-compatibility problems.
more →
22 Nov 2025
Racket v9.0
posted by Stephen De Gabrielle and John Clements
We are pleased to announce Racket v9.0 is now available from
Racket 9.0 is here!
A major release is always exciting and Racket 9.0 is no exception in that it introduces Parallel Threads. While Racket has had green threads for some time, and supports parallelism via futures and places, we feel parallel threads is a major addition.
As of this release:
Racket supports parallel threads.
For more information see the new blog post on the topic.
Parallel threads can be created using the
#:pool
argument to thread creation.
Threads created with
#:keep
set to
'results
will record their results for later retrieval with
thread-wait
The
black-box
wrapper prevents the optimizing compiler from optimizing away certain computations entirely. This can be helpful in ensuring that benchmarks are accurate.
The
decompile-linklet
function can map linklets back to s-expressions.
When using BC Racket, the
processor-count
function is changed to always return the parallel count.
We now distribute “natipkg” packages for AArch64, useful for package-build and package-testing infrastructure.
Check Syntax tracks identifiers more deeply nested in the “origin” field of syntax objects.
The
math
library includes
Weibull distributions
There are many other repairs and documentation improvements!
Thank you
The following people contributed to this release:
Alexander Shopov, Anthony Carrico, Bert De Ketelaere, Bogdan Popa, Cadence Ember, David Van Horn, Gustavo Massaccesi, Jade Sailor, Jakub Zalewski, Jens Axel Søgaard, jestarray, John Clements, Jordan Johnson, Matthew Flatt, Matthias Felleisen, Mike Sperber, Philip McGrath, RMOlive, Robby Findler, Ruifeng Xie, Ryan Culpepper, Sam Phillips, Sam Tobin-Hochstadt, Sebastian Rakel, shenleban tongying, Shu-Hung You, Stephen De Gabrielle, Steve Byan, and Wing Hei Chan.
Racket
is a community developed open source project and we welcome new contributors. See
racket/README.md
to learn how you can be a part of this amazing project.
Feedback Welcome
Questions and discussion welcome at the Racket community on
Discourse
or
Discord
Please share
If you can - please help get the word out to users and platform specific repo packagers
Racket - the Language-Oriented Programming Language - version 9.0 is now available from https://download.racket-lang.org

See https://blog.racket-lang.org/2025/11/racket-v9-0.html for the release announcement and highlights.
more →
20 Aug 2025
Racket v8.18
posted by Stephen De Gabrielle
We are pleased to announce Racket v8.18 is now available from
As of this release:
The
racket-lang.org
website no longer distributes Racket BC bundles, but it includes pre-built bundles for two flavors of ARM linux, AArch64 and 32-bit ARMv6 VFP.
XML structures
are serializable.
Scribble’s
HTML generation conforms better to modern standards.
Racket uses Unicode 16.0 for character and string operations.
The
redex-check
default generation strategy always uses random generation to supplement the enumerator.
DrRacket
supports the use of shift-tab to go backward to previous indentation positions.
The
macro stepper
supports the
string-constants library
, allowing internationalization of the stepper itself.
The
struct
form supports
#:properties prop-list-expr
, making it more convenient to attach multiple property values to a structure type.
Build-system improvements support containers registered at
Docker Hub
to build for all platforms that have downloads from the main Racket download site; improvements also support Unix-style builds for Mac OS in the style of MacPorts.
The
expt
function produces a more accurate result when its first argument is a flonum and its second argument is an exact integer that has no equivalent flonum representation than it did in prior versions.
TCP ports
use
SO_KEEPALIVE
correctly.
Unsafe code can use
“uninterruptible mode”
instead of “atomic mode” to allow futures to run concurrently while preventing interruptions from other threads.
The
net/imap
library supports
IMAP’s
move
operation.
There are many other repairs and documentation improvements!
Thank you
The following people contributed to this release:
Bob Burger, Bogdan Popa, Brad Lucier, Carl Gay, Chloé Vulquin, D. Ben Knoble, Gustavo Massaccesi, Jacqueline Firth, Jade Sailor, Jarhmander, Jason Hemann, Jens Axel Søgaard, Joel Dueck, John Clements, jyn, Jörgen Brandt, Mao Yifu, Marc Nieper-Wißkirchen, Matthew Flatt, Matthias Felleisen, Mike Sperber, Noah Ma, paralogismos, Pavel Panchekha, Philip McGrath, Robby Findler, Ryan Culpepper, Sam Tobin-Hochstadt, Shalok Shalom, Stephen De Gabrielle, Steve Byan, Vincent Lee, Wing Hei Chan, and ZC Findler.
Racket
is a community developed open source project and we welcome new contributors. See
racket/README.md
to learn how you can be a part of this amazing project.
Feedback Welcome
Questions and discussion welcome at the Racket community on
Discourse
or
Discord
Please share
If you can - please help get the word out to users and platform specific repo packagers
Racket - the Language-Oriented Programming Language - version 8.18 is now available from https://download.racket-lang.org

See https://blog.racket-lang.org/2025/08/racket-v8-18.html for the release announcement and highlights.
more →
17 May 2025
Racket v8.17
posted by Stephen De Gabrielle
We are pleased to announce Racket v8.17 is now available from
As of this release:
The new
drracket-core
package provides a version of drracket with a smaller set of dependencies.
Typed Racket has support for
treelists
The package manager computes
checksums
for packages when required, allowing the use and automatic upgrade of packages without them.
The
bitwise-first-bit-set
function returns the smallest bit that is set in the twos-complement representation of the given number.
The updated
dynamic-require
function makes it easier to use syntax bindings by allowing a syntax-thunk (or ’eval) to be used for them.
The
error-module-path->string-handler
parameter allows the customization of the display of module-paths in error messages.
Precision of certain
numeric functions
sin
cos
, and others) is improved on Windows platforms by using the MSVCRT/UCRT libraries.
The
string-append
function has improved performance and reduced memory use for long lists of strings in the Racket CS implementation. Differences are clearly noticeable for lists of length 1 million.
TCP ports
use
SO_KEEPALIVE
, instructing the kernel to send periodic messages while waiting for data to check whether the connection is still responsive.
Racket code using a terminal in Windows can receive mouse events as virtual terminal characters after using SetConsoleMode. (This is also already possible on macOS and Linux.) See the
tui-term
package for related example code.
The
#:replace-malformed-surrogate?
keyword can be used to specify a replacement for malformed unicode surrogates in JSON input
The
http-client
module no longer sends “Content-Length: 0” for requests without a body.
The
demodularizer
compiler/demod
) can prune more unused assignments.
Several judgment rendering forms in
Redex
are replaced by functions, allowing more convenient abstraction.
When a distribution includes no teaching languages, DrRacket’s language-dialog configuration moves into the preferences dialog and the “Language” menu disappears.
The
math library
has better support for block-diagonal matrices, including both Racket and Typed Racket.
The
math library
contains improved implementations of acos and matrix-(cos-)angle.
The
stepper
again works for
big-bang
programs.
There are many other repairs and documentation imprevements!
Thank you
The following people contributed to this release:
Alexander Shopov, Andrei Dorian Duma, Bert De Ketelaere, Bob Burger, Bogdan Popa, Bogdana Vereha, Cameron Moy, Chung-chieh Shan, Cutie Deng, D. Ben Knoble, Dario Hamidi, Dominik Pantůček, Gustavo Massaccesi, halfminami, Jacqueline Firth, Jason Hemann, Jens Axel Søgaard, Joel Dueck, John Clements, Jordan Harman, Marc Nieper-Wißkirchen, Matthew Flatt, Matthias Felleisen, Mike Sperber, Noah Ma, owaddell-ib, Philippe Meunier, Robby Findler, Ryan Culpepper, Ryan Ficklin, Sam Phillips, Sam Tobin-Hochstadt, Shu-Hung You, sogaiu, Sorawee Porncharoenwase, Stephen De Gabrielle, Vincent Lee, and Wing Hei Chan.
Racket
is a community developed open source project and we welcome new contributors. See
racket/README.md
to learn how you can be a part of this amazing project.
Feedback Welcome
Questions and discussion welcome at the Racket community on
Discourse
or
Discord
Please share
If you can - please help get the word out to users and platform specific repo packagers
Racket - the Language-Oriented Programming Language - version 8.17 is now available from https://download.racket-lang.org

See https://blog.racket-lang.org/2025/05/racket-v8-17.html for the release announcement and highlights.
more →
02 Mar 2025
Racket v8.16
posted by Stephen De Gabrielle
We are pleased to announce Racket v8.16 is now available from
As of this release:
Racket has expanded support for immutable and mutable treelists:
A variety of new treelist utility functions are available:
treelist-filter
treelist-flatten
, et cetera.
The
mutable-treelist-prepend!
function allows prepending to mutable treelists.
Mutable treelists
are
serializable
The
serialize-structs
module allows the minimization of dependencies by providing only a handful of core forms.
The
flbit-field
function allows access to the binary representation of IEEE floating-point numbers.
The top-left search box in the
documentation
works once more.
The
XML reader
is 2–3x faster on inputs with long CDATA and comments, and avoids some internal contract checks to obtain a 25% speedup on large documents generally.
The
pregexp syntax includes "\X" to match a grapheme cluster
, following Perl and PCRE.
The
read-json*
and
write-json*
functions allow customization of the Racket representation of JSON elements, eliminating the need for a separate “translation” pass.
Racket has new port I/O functions:
The
open-input-nowhere
function creates an empty input port.
The
pipe-port?
function makes it possible to determine whether a port is created by
make-pipe
The
port-file-stat
function allows gathering information about the file that is the source or target of a file-stream port.
revised representation
of pointers improves the performance of foreign function calls. As a result,
ptr-ref
and
ptr-set!
are substantially faster.
In anticipation of the fifteenth
RacketCon
, the
fifteenth
function returns the fifteenth element of a list.
Racket has an improved multi-line convention for error messages.
The
db
library
allows
prepare
on virtual statements.
The
student-t
distribution
is part of the
math/distributions
library
Expeditor
supports customizing the prompt, using the
#:prompt
keyword argument to
call-with-expeditor
There is a
guide to adding internationalization for a new (human) language.
Optimizations to racket/profile improve asymptotic speed for very large call graphs.
The
#lang htdp/asl
language incorporates
Graphical Debugger
support.
There is lots of new documentation, and many defects repaired!
Thank you
The following people contributed to this release:
a11ce, Alex Knauth, Alexander Shopov, Alexis King, Andrew Mauer-Oats, Anthony Carrico, Bert De Ketelaere, Bob Burger, Bogdan Popa, D. Ben Knoble, David Van Horn, Gustavo Massaccesi, halfminami, Hao Zhang, Jacqueline Firth, Jinser Kafka, JJ, John Clements, Jörgen Brandt, Kraskaska, lafirest, Laurent Orseau, lukejianu, Marc Nieper-Wißkirchen, Matthew Flatt, Matthias Felleisen, mehbark, Mike Sperber, Noah Ma, Onorio Catenacci, Oscar Waddell, Pavel Panchekha, payneca, Robby Findler, Sam Phillips, Sam Tobin-Hochstadt, Shu-Hung You, Sorawee Porncharoenwase, Stephen De Gabrielle, Wing Hei Chan, Yi Cao, and ZhangHao.
Racket is a community developed open source project and we welcome new contributors. See
racket/README.md
to learn how you can be a part of this amazing project.
Feedback Welcome
Questions and discussion welcome at the Racket community
Discourse
or
Discord
Please share
If you can - please help get the word out to users and platform specific repo packagers
Racket - the Language-Oriented Programming Language - version 8.16 is now available from https://download.racket-lang.org

See https://blog.racket-lang.org/2024/08/racket-v8-16.html for the release announcement and highlights.
more →
05 Nov 2024
Racket v8.15
posted by Stephen De Gabrielle
We are pleased to announce Racket v8.15 is now available from
As of this release:
Documentation search results are ordered, with visual cues indicating what their source is (core, main-distribution, etc.). These results are also grouped by language family (Racket, Rhombus, etc.). Search e.g.
second
to see an example.
DrRacket offers to restore previously open files when starting, which can be made the default.
In DrRacket, Images in editing panels can be saved by right-clicking, including those generated by the functional picture libraries
pict
and
2htdp/image
raco pkg
introduces the
uninstall
command as the opposite of
install
. The
remove
name for this functionality is retained for compatibility. (See
Package Management in Racket – 3.3
raco pkg uninstall
.)
raco pkg
improves the handling of
--clone
and
--unclone
. (See
Package Management in Racket – 3.2
raco pkg update
.)
iOS is a compilation target, distinct from macOS. (See
Inside:Racket C API – 29 Cross-compiling Racket Sources for iOS
.)
Racket supports falling back to IPv4 during hostname resolution when IPv6 fails.
Memory allocated using the ffi/unsafe library can be initially zeroed, using the
'zeroed-atomic
and
'zeroed-atomic-interior
flags. (See
The Racket Foreign Interface – 4.2 Memory Management
malloc
mode
'zeroed-atomic
and
'zeroed-atomic-interior
.)
Many other bugs are fixed and documentation has been improved!
Thank you
The following people contributed to this release:
Alec Mills, Alex Knauth, Alexander Shopov, Ashlynn Anderson, Ashton Wiersdorf, Ben Greenman, Benjamin Yeung, Bob Burger, Bogdan Popa, Breck Yunits, Carl Gay, Claes Wallin (韋嘉誠), CooperCorad, Crystal Jacobs, D. Ben Knoble, Dexter Santucci, Eduardo Cavazos, Emil Szpakowski, evelynmitchell, Greg Hendershott, Gunnar Ahlberg, Gwen Weinholt, Idiomdrottning, Ikko Eltociear Ashimine, Jacqueline Firth, Jarhmander, Jay McCarthy, Jens Axel Søgaard, Jimmy McNutt, jinser, Jinser Kafka, John Clements, lukejianu, Marc Nieper-Wißkirchen, Matej Fandl, Matthew Flatt, Matthias Felleisen, Michael Ballantyne, Mike Sperber, olopierpa, Paul Morris, Phil Nguyen, Philip McGrath, Robby Findler, Ronald Garcia, Ryan Culpepper, Sam Phillips, Sam Tobin-Hochstadt, Siddhartha Kasivajhula, Sorawee Porncharoenwase, Stephen De Gabrielle, Syntacticlosure, Taylor Allred, Tomas Fabrizio Orsi, Wing Hei Chan, and Yafei Yang.
Racket is a community developed open source project and we welcome new contributors. See
racket/README.md
to learn how you can be a part of this amazing project.
Feedback Welcome
Questions and discussion welcome at the Racket community
Discourse announcement
join
) or on the
Racket Discord
Please share
If you can - please help get the word out to users and platform specific repo packagers
Racket - the Language-Oriented Programming Language - version 8.15 is now available from https://download.racket-lang.org

See https://blog.racket-lang.org/2024/08/racket-v8-15.html for the release announcement and highlights.
more →
20 Aug 2024
Racket v8.14
posted by Stephen De Gabrielle
We are pleased to announce Racket v8.14 is now available from
As of this release:
64-bit ARM Windows is one of the standard pre-built downloads.
The
compiler/demod
language integrates demodularization into the program rather than an external tool. Using the language approach cooperates with other Racket tools and allows demodularization to be used on libraries. Additionally, demodularization handles submodules and can prune definitions, significantly shrinking the size of some programs. (
#lang compiler/demod
The
contract-in
form enables contracts to be specified in an importing module. (
8.6 Attaching Contracts to Values
The
#%declare
form supports the
#:flatten-requires
and
#:unlimited-compile
keywords (
#%declare
Identifiers such as
case-λ
match-λ
and
are equivalent to their Latin-alphabet equivalents (
case-lambda
match-lambda
, and
lambda
) in more contexts, including uses of
match
The
hash-filter
function allows the use of a predicate to select a sub-table of a hash table. (
hash-filter
The module browser can perform filtering on submodules.
The
raco test
command-line form respects the
current-test-invocation-directory
parameter, and shows well-formed module paths in its output. (
current-test-invocation-directory
Racket CS allows the use of in-memory boot files.
The
raco/testing
collection brings together a variety of testing- related functions and forms. (
raco/testing
This release also includes many bug-fixes and documentation updates!
NOTE: This release (and version 8.13) have a known build problem that affects the builtpkgs source bundle on Windows. In order to avoid this problem, use a pre-built bundle or build using a source bundle other than the “builtpkgs” one. Nightly builds do not suffer from this problem.
Thank you
The following people contributed to this release:
Alex Knauth, Alexander Shopov, Ben Greenman, Bert De Ketelaere, Bob Burger, Bogdan Popa, Cadence Ember, Carl Gay, D. Ben Knoble, Gregory Rosenblatt, Gustavo Massaccesi, John Clements, John Sullivan, Jordan Johnson, luistung, Matthew Flatt, Matthias Felleisen, Noah Ma, Philip McGrath, Robby Findler, Ryan Culpepper, Sam Tobin-Hochstadt, Sergey Fedorov, Sorawee Porncharoenwase, Wing Hei Chan, and ZhangHao.
Racket is a community developed open source project and we welcome new contributors. See
racket/README.md
to learn how you can be a part of this amazing project.
Feedback Welcome
Questions and discussion welcome at the Racket community
Discourse
or
Discord
Please share
If you can - please help get the word out to users and platform specific repo packagers
Racket - the Language-Oriented Programming Language - version 8.14 is now available from https://download.racket-lang.org

See https://blog.racket-lang.org/2024/08/racket-v8-14.html for the release announcement and highlights.
more →
16 May 2024
Racket v8.13
posted by Stephen De Gabrielle
We are pleased to announce Racket v8.13 is now available from
As of this release:
The racket/treelist and racket/mutable-treelist libraries provide list-like containers that support many operations in effectively constant time, including appending and extracting sub-lists without mutating the given list. Treelists are implemented as RRB Vectors, invented by Stucki, Riompf, Ureche, and Bagwell. (see
4.16 Treelists
and
RRB vector: a practical general purpose immutable sequence, ICFP 2015
The
hash-filter-keys
and
hash-filter-values
functions allow users to filter hashes using a predicate on either keys or values. (see
4.15 Hash Tables:
hash-filter-keys
hash-filter-values
The
vector-extend
and
vector*-extend
functions provide a way to pre-populate the prefix of a newly allocated vector using the elements of an existing vector. (see
4.12 Vectors:
vector-extend
Command-line raco setup, package update, and package installation use terminal control (when available) to show what they are working on more compactly and with a progress bar.
Racket v8.13 uses Unicode 15.1 for character and string operations.
Machine-specific cross-module optimization allows improved support for static generation of foreign-function bindings.
The scribble/acmart language uses v2.01, which avoids errors concerning the hyperref package in some latex installations.
Thank you
The following people contributed to this release:
Alec Mills, Ben Greenman, Bob Burger, Bogdan Popa, dr-neptune, Fred Fu, Gustavo Massaccesi, Jason Hemann, Jay McCarthy, John Clements, Jordan Johnson, Justin Dhillon, Mao Yifu, Matias Eyzaguirre, Matthew Flatt, Matthias Felleisen, Mike Sperber, olopierpa, Oscar Waddell, Pavel Panchekha, Philip McGrath, Robby Findler, Sam Phillips, Sam Tobin-Hochstadt, Siddhartha Kasivajhula, Sorawee Porncharoenwase, Stephen De Gabrielle, Tim Standen, William E. Byrd, and Wing Hei Chan.
Racket is a community developed open source project and we welcome new contributors. See
racket/README.md
to learn how you can be a part of this amazing project.
Feedback Welcome
Questions and discussion welcome at the Racket community
Discourse
or
Discord
Please share
If you can - please help get the word out to users and platform specific repo packagers
Racket - the Language-Oriented Programming Language - version 8.13 is now available from https://download.racket-lang.org

See https://blog.racket-lang.org/2024/05/racket-v8-13.html for the release announcement and highlights.
more →
08 Feb 2024
Racket v8.12
posted by Stephen De Gabrielle
8.12cat|277x123
We are pleased to announce Racket v8.12 is now available from
As of this release:
The “Die Macht der Abstraktion” language levels are no longer present, replaced by the “Schreibe dein Programm” language levels which have been available for several years. (see
DeinProgramm - Schreibe Dein Programm!
The release fixes a problem with the binding structure of the
for/fold
form in the rare situation when an iteration clause identifier shadowed an accumulator identifier. This change may break code that depends on the old binding structure. (see
3.18 Iterations and Comprehensions: for, for/list, …
Racket automatically sets the close-on-exec flag when opening a file, on systems where this is available. This change lowers the cost of avoiding problems that can occur when file descriptors become accidentally shared between processes. (see
13.1.5 File Ports
Match includes
hash
and
hash*
patterns. (see
9 Pattern Matching
The
vector-set/copy
function allows creation of a new vector that differs at only one index. This change also adds
vector-append
and
vector-copy
primitives. (see
4.12 Vectors
The
pregexp-quote
function brings the functionality of
regexp-quote
to pregexps. (see
4.8 Regular Expressions
The C FFI convention-based converter supports
PascalCase
and
camelCase
in addition to an underscore-based convention. (see
5.6 Defining Bindings
The
racket/case
library allows
case
-like forms that use different equality comparisons, such as
eq?
and
equal-always?
. (see
3.13 Dispatch: case
Scribble rendering to HTML adds linking and information buttons when hovering over heading titles.
image|690x196
image|690x98
The
interval-map
data structure supports iterator functions in the style of
gen:ordered-dict
. (see
3 Orders and Ordered Dictionaries
This release also includes many other documentation improvements, optimizations, and bug fixes!
Thank you
Thank you to the people who contributed to this release:
Alex Harsányi, Alex Knauth, Alex Muscar, Alexis King, Ben Greenman, Bert De Ketelaere, Bob Burger, Bogdan Popa, Chris Payne, Fred Fu, J. Ryan Stinnett, Jamie Taylor, Jared Forsyth, Jarhmander, Jens Axel Søgaard, Joel Dueck, John Clements, Jordan Johnson, Ken Harris, Laurent Orseau, Mao Yifu, Marc Nieper-Wißkirchen, Matteo d’Addio, Matthew Flatt, Matthias Felleisen, Micah Cantor, Mike Sperber, naveen srinivasan, Oscar Waddell, Philip McGrath, Philippe Meunier, Robby Findler, Rocketnia, Sam Phillips, Sam Tobin-Hochstadt, Sarthak Shah, Shu-Hung You, Sorawee Porncharoenwase, Stephen De Gabrielle, Tom Price, ur4t, Wing Hei Chan, and ZhangHao
Feedback Welcome
Questions and discussion welcome at the Racket community
Discourse
or
Discord
Please share
If you can - please help get the word out to users and platform specific repo packagers
Racket - the Language-Oriented Programming Language - version 8.12 is now available from https://download.racket-lang.org

See https://racket.discourse.group/t/racket-v8-12-is-now-available/2709 for the release announcement and highlights.

Thank you to the many people who contributed to this release!

Feedback Welcome
more →
Made with
Frog
, a static-blog generator written in Racket.
Source code
for this blog.