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:

Racket will find many square roots (tweak N 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:

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,

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, tho, 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 https://download.racket-lang.org.

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.

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.

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):

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.

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].

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.

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 6) and (hash-digs 7) 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.

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.

posted by Stephen De Gabrielle and John Clements

We are pleased to announce Racket v9.0 is now available from https://download.racket-lang.org/.

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.

posted by Stephen De Gabrielle

We are pleased to announce Racket v8.18 is now available from https://download.racket-lang.org/.

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.

posted by Stephen De Gabrielle

We are pleased to announce Racket v8.17 is now available from https://download.racket-lang.org/.

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.

posted by Stephen De Gabrielle

We are pleased to announce Racket v8.16 is now available from https://download.racket-lang.org/.

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.
• A 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.

posted by Stephen De Gabrielle

We are pleased to announce Racket v8.15 is now available from https://download.racket-lang.org/.

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.

posted by Stephen De Gabrielle

We are pleased to announce Racket v8.14 is now available from https://download.racket-lang.org/.

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.

posted by Stephen De Gabrielle

We are pleased to announce Racket v8.13 is now available from https://download.racket-lang.org/.

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.

posted by Stephen De Gabrielle

8.12cat|277x123

We are pleased to announce Racket v8.12 is now available from https://download.racket-lang.org/.

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

Racket version 8.11.1 is now available from https://racket-lang.org/

This bug-fix release repairs a problem with building from source when using the “builtpkgs” source distribution.

Feedback Welcome