Softpedia >Mac >Developer Tools >Racket >  Changelog

Racket Changelog

What's new in Racket 8.11.1

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

New in Racket 8.11 (Nov 15, 2023)

  • Match clauses can include a #:do option to allow evaluation of code and bindings before a following #:when clause. Cf. https://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))
  • JSON Serialization supports indentation with an #:indent option to write-json. Cf. https://docs.racket-lang.org/json/index.html#(def._((lib._json/main..rkt)._write-json))
  • An initiate-sequence function simplifies the creation of sequences. Cf. https://docs.racket-lang.org/reference/sequences.html#(def._((lib._racket/sequence..rkt)._initiate-sequence))
  • The :do-in form allows an inner definition sequence. Cf. https://docs.racket-lang.org/reference/for.html#(form._((lib.racket/private/base..rkt).~3ado-in))
  • The redex-define form allows pattern-matching in PLT Redex using a define-like syntax. Cf. https://docs.racket-lang.org/redex/reference.html#(form._((lib._redex/reduction-semantics..rkt)._redex-define))
  • Racket and Chez Scheme use Robert L. Smith’s “Algorithm 116” for division of complex numbers. Cf. https://dl.acm.org/doi/10.1145/368637.368661
  • DrRacket has indentation guides that provide visual cues indicating how code is indented and grouped, accessible by using (-shift-i).
  • “Comment-out” menu items can be specific to the #lang used by the current file. Cf. https://docs.racket-lang.org/framework/Text.html#(def._((lib._framework/main..rkt)._text~3aindent-guides~3c~25~3e))
  • Unused identifiers have a tooltip indicating that they have no bound occurrences.
  • Quickscript includes a new form of scripting in the form of “hook” functions that can be attached to existing events. Cf. https://docs.racket-lang.org/quickscript/index.html#(part._.Hooks)
  • Plots include plot-inset and plot-legend-padding parameters to control the amount of space left unused around the plot edge and plot legend. Cf. https://docs.racket-lang.org/plot/params.html#(def._((lib._plot/main..rkt)._plot-inset))
  • There are many other documentation improvements, optimizations, and bug fixes!

New in Racket 8.10 (Aug 16, 2023)

  • syntax/parse no longer always compiles its patterns; this release includes an interpreter which is used to reduce code size
  • Racket includes primitives [im]mutable-string?, [im]mutable-bytes?, [im]mutable-vector?, [im]mutable-box?, and [im]mutable-hash? (cf. https://docs.racket-lang.org/reference/booleans.html#(mod-path._racket/mutability))
  • Redex adds judgment-form->rule-names (cf. https://docs.racket-lang.org/redex/reference.html#(def._((lib._redex/reduction-semantics..rkt)._judgment-form-~3erule-names)))
  • Fasl and compiled code allow fxvectors and flvectors
  • DrRacket allows #lang-specific customization of the definition navigation popdown (cf. https://docs.racket-lang.org/tools/drracket_language.html#(idx._(gentag.55.(lib._scribblings/tools/tools..scrbl))))
  • Racket and DrRacket include Finnish internationalization
  • Check Syntax binding arrows are drawn for names bound with define-local-member-name
  • Many other improvements and bug fixes are included, including to the scribble and plot packages

New in Racket 8.9 (May 12, 2023)

  • The HtDP student languages come with checked signatures. Programmers can express signatures in a formal notation, and these signatures are checked at run-time (in a performance-neutral manner). The addition of this formal language associates meaning with several names that had no meaning before. — This feature is experimental, and we may amend or retract it later. (cf. https://docs.racket-lang.org/htdp-langs/beginner-abbr.html?q=signatures#(part._beginner-abbr-signatures))
  • Switching into and out of dark mode is handled better on Mac OS and Linux.
  • Racket uses Unicode 15.0 for character and string operations.
  • The racket/hash-code library provides support for combining hash codes. (cf. https://docs.racket-lang.org/reference/Equality.html#(mod-path._racket/hash-code))
  • A language module can have a configure-expand submodule that is dynamically required to configure a parameterization before expansion of another module. (cf. https://docs.racket-lang.org/reference/running-sa.html#(part._configure-expand))
  • stream-cons supports multiple values. (cf. https://docs.racket-lang.org/reference/streams.html#(form._((lib._racket/stream..rkt)._stream-cons)))
  • unit/c subcontracts may depend on bindings from any imported or exported signature. Additionally, bindings’ contracts are enforced within subcontracts, and violations blame the contract itself (like ->i). (cf. https://docs.racket-lang.org/reference/unitcontracts.html#(form._((lib._racket/unit..rkt)._unit/c)))
  • racket/class provides the dynamic-instantiate procedure for instantiating a class with a dynamic list of by-name initialization arguments. (cf. https://docs.racket-lang.org/reference/objcreation.html#(def._((lib._racket/private/class-internal..rkt)._dynamic-instantiate)))
  • TCP output block buffering implies TCP_NODELAY. (cf. https://docs.racket-lang.org/reference/tcp.html#(def._((lib._racket/tcp..rkt)._tcp-connect)))
  • Submodules and Check Syntax require arrows work better together.
  • Typed Racket’s shallow check generation is improved.
  • Many other improvements and bug fixes are included!

New in Racket 8.8 (Feb 8, 2023)

  • The dependent contract form, ->i, supports a #:param element that specifies dependencies for parameter values that are set during the dynamic extent of the function call. (See: https://docs.racket-lang.org/reference/function-contracts.html#(form._((lib.racket/contract/base..rkt).-~3ei)) )
  • The copy-file library function supports permission-management arguments. (See: https://docs.racket-lang.org/reference/Filesystem.html#(def._((lib._racket/private/base..rkt)._copy-file)) )
  • Pressing -return in DrRacket’s interactions window makes it easier to edit and enter expressions without sending them to be evaluated.
  • The numeric comparison operators (=, etc.) require at least two arguments in the “How To Design Programs” teaching languages.
  • Redex has improved typesetting when customized renders are used in certain multi-line situations.
  • We have fixed many bugs, and written lots of documentation.

New in Racket 8.7 (Nov 15, 2022)

  • Typed Racket offers Shallow and Optional modes for its gradual types. These modes lower the cost of interacting with untyped code, but provide less protection against buggy interactions. (see https://docs.racket-lang.org/ts-reference/behavior-of-types.html )
  • Racket uses Unicode 14.0 for character and string operations, and includes grapheme operations. DrRacket supports emojis. (see https://docs.racket-lang.org/gui/editor-overview.html#(part._graphemes) )
  • Racket supports RV64G (RISC-V).
  • Programmers can disable definition shadowing using (#�clare #:require=define). (see https://docs.racket-lang.org/reference/module.html#(form.((quote.~23~25kernel)._~23~25declare)) )
  • The module dependency graphs available using raco dependencies-graph and DrRacket’s Module browser are faster and have new package filtering support. (see https://docs.racket-lang.org/drracket/module-browser.html#(idx._(gentag.39.(lib._scribblings/drracket/drracket..scrbl))) )
  • DrRacket is more responsive when killing programs that produce a lot of output.
  • Plot 3D allows negative altitude values (e.g., looking at the plot from “below”). (see https://docs.racket-lang.org/plot/plotting.html#(def._((lib._plot/main..rkt)._plot3d)) )
  • The scriblib/bibtex and scriblib/autobib libraries support DOIs. (see https://docs.racket-lang.org/scriblib/autobib.html#(def._((lib._scriblib/autobib..rkt)._make-bib)) )
  • There are many other repairs and improvements!

New in Racket 8.6 (Nov 15, 2022)

  • Racket has an “equal-always?” primitive that equates values that will stay the same even if mutated. See https://docs.racket-lang.org/reference/Equality.html#(def.((quote.~23~25kernel)._equal-always~3f))
  • This release uses a new build system, Zuo, which is implemented as a little language, in accordance with the ideas of Language Oriented Programming (LOP). The implementation has a single C file (plus libraries implemented in Zuo), so it compiles easily. The zuo/build library is modeled on make and Shake for tracking dependencies and build steps. See https://docs.racket-lang.org/zuo/index.html and https://racket.discourse.group/t/new-build-system-pushed-to-git-repo/873
  • Racket supports stencil vectors, which associate a virtual bitmask with a vector, enabling certain mask-equipped update operations. See https://docs.racket-lang.org/reference/stencil_vectors.html
  • Racket supports Arm64 machines running Windows.
  • Redex has support for simultaneous substitutions. See https://docs.racket-lang.org/redex/reference.html#(form._((lib._redex/reduction-semantics..rkt)._substitute))
  • The Web Server provides control over the maximum number of concurrent connections via its “safety limits” construct. See https://docs.racket-lang.org/web-server-internal/dispatch-server-unit.html#(part._safety-limits)
  • The Web Server has improved logging performance and improved request parsing performance, reducing tail latencies.
  • The Web Server supports logging response status code via web-server/dispatchers/dispatch-logresp. See https://docs.racket-lang.org/web-server-internal/dispatch-logresp.html
  • The db library supports custom types for PostgreSQL connections; see pg-custom-type for details. See https://docs.racket-lang.org/db/util.html#(def._((lib._db/util/postgresql..rkt)._pg-custom-type))
  • The release includes many other repairs and changes!

New in Racket 8.5 (May 3, 2022)

  • Racket’s new -y flag automatically keeps compiled files up to date, reducing subsequent load times.
  • Error-message realms allow Racket-hosted languages to adapt and rewrite error messages to make sense in a particular context.
  • Nonprivileged users can control package installation scope using an “other-version” directory in the addon-dir.
  • Racket CS runs on platforms where native-code generation is not currently supported (e.g., s390x or ppc64). See “README.txt” in the source distribution for more information on the —enable-pb flag to configure.
  • DrRacket’s new ‘Reopen Closed Tab’ file menu item will open previously closed tabs.
  • Typed Racket has support for the xml library; use typed/xml.
  • Rackunit reports source locations for failed test cases in the Typed Racket language.
  • Plot has violin plots and improved box-and-whisker plots.
  • Boxes are supported alongside lists, vectors etc. in place-channel messages.
  • Those who manually configure Racket CS to use Zlib compression for compiled code should be aware of CVE–2018–25032; the next release and the current snapshot builds use a newer, safer version of zlib.
  • The release includes many other repairs and changes!

New in Racket 8.4 (Feb 10, 2022)

  • Command-line Racket provides a new expression editor by default for its read-eval-print loop (REPL). The new REPL is based on the Chez Scheme expression editor, but extended to use the same language-sensitive syntax coloring and indentation tools as DrRacket.
  • Typed Racket adds a kind system, preventing programmers from writing nonsensical type expressions. It checks whether type constructors are correctly applied to arguments, and separates type constructors from polymorphic types. The :kind form enables checking the kind of a type expression at the REPL. The new system also correctly rejects some ill-formed recursive types.
  • Racket has a file-or-directory-stat for unified information about file-system objects.
  • DrRacket shows the region affected by an #; S-expression comment by fading the commented-out region.
  • Racket on Chez has faster multiplication and division for some numbers.
  • Web server: The files dispatcher supports all standard caching-related HTTP response headers (e.g., Cache-Control).
  • Web server: A new dispatcher captures the common pattern of processing HTTP requests and responses in a layered fashion.
  • The Web Server supports use of the Cache-Control header, and includes a new wrapping dispatcher.
  • Expander: add “portal” syntax to support new forms of syntax object binding.
  • Documentation search is improved.
  • Some hash operations support an optional try-order? argument.
  • The plot-metrics interface has documentation.
  • Fonts support OpenType feature settings.
  • The Gui library has improved support for Wayland.
  • The computation of quadratic roots is further improved.
  • The set/c contract adds support for random generation.
  • DrRacket’s interactions window supports #lang-specific coloring and indentation.
  • DrRacket’s parenthesis-based keyboard shortcuts change based on the parentheses that each different #lang uses.
  • The release includes many other bug repairs and other improvements!
  • Support for comment fading in DrRacket requires an increment to the “WXME” format version so files with non-text content written by DrRacket v8.4 will open only in v8.4 and later. This does not affect files that consist only of unicode text.
  • The addition of the kind system to Typed Racket means that certain mild abuses of the type system no longer type check, most notably the ‘application’ of a polymorphic type.

New in Racket 8.3 (Nov 7, 2021)

  • Racket removes syntax arming and disarming in favor of a simpler system of protected syntax operations, along with other updates to the syntax system.
  • DrRacket has improved support for custom #lang languages.
  • Typed Racket improves precision for type-checking of non-polymorphic structures, existential types, and certain binding forms.
  • Scribble HTML output gains a button to show / hide the table of contents on mobile platforms.
  • Redex’s stepper’s GUI shows IO-judgment form rule names.
  • Many bug fixes!

New in Racket 8.2 (Jul 19, 2021)

  • Racket CS improved the performance of large-integer arithmetic.
  • Racket has improved support for layered and tethered installation.
  • Racket CS supports nonatomic allocation via ffi/unsafe.
  • Cross-compilation works fully with the raco cross tool, which is distributed separately as the “raco-cross” package.
  • DrRacket has performance improvements when editing files with picts containing large bitmaps.
  • Typed Racket more consistently refines field types of non-polymorphic structs.
  • Printing of values is unified across the teaching language implementations and the stepper.

New in Racket 8.1 (May 6, 2021)

  • DrRacket tabs can be dragged, and have new close buttons.
  • Racket CS supports cross-compilation using raco exe.
  • Racket CS supports Android on 32-bit and 64-bit ARM processors.
  • The database library supports running queries in OS threads.
  • Check-Syntax arrows correctly identify the definition site of identifiers with contracts.
  • Racket CS performance has improved for structure predicates and accessors
  • Racket CS is faster at multiplying extremely large numbers and dividing large integers.
  • Racket CS allows callbacks to raise exceptions if they are annotated with #:callback-exns?.
  • New ephemeron hash tables simplify the implementation of tables where keys can refer to values.
  • Typed Racket supports for/foldr.
  • The stepper works for #lang htdp/*sl.
  • Struct signatures work for the ASL teaching language.

New in Racket 8.0 (Feb 15, 2021)

  • Racket 8.0 marks the first release where Racket CS is the default implementation. Creating, polishing, and adopting Racket CS has been a 4-year effort involving the entire Racket community. At this point, Racket CS is faster, easier to maintain and develop, and compatible with existing Racket programs. Racket CS will continue to improve, but at this point it is ready to be the primary variant of Racket for all Racketeers. More details about the current state of Racket CS are available in the recent blog post.
  • Other notable changes:
  • Racket CS has better parallel garbage collection, a 10%–30% reduction in the size of generated code, and various targeted optimizations.
  • A rewrite of the test-engine package allows the #lang versions of teaching languages to produce linked test-failure messages.
  • The release comes with a new mark-up DSL for composing text to appear in the REPL (simple-tree-text-markup).
  • Redex has an added define-overriding-judgment form and improved error source location reporting.
  • Windows scrolling speed reflects the system preference.
  • The db package uses the utf8mb4 charset for MySQL connections.

New in Racket 7.9 (Nov 3, 2020)

  • Racket CS may become the default Racket implementation in the next release. If, between this release and the next, no bugs are discovered in Racket CS that are more serious than those typically discovered in Racket BC, then Racket CS will become the default for the next release. (Serious Racket CS bugs were found since the v7.8 release, but they’re ever fewer and farther between.)
  • Various improvements to Check Syntax arrows and renaming, thanks to Sorawee Porncharoenwase.
  • Full support for struct type properties in Typed Racket, developed by Fred Fu.
  • Racket CS now supports parallel garbage collection, along with improvements for place-local-allocation and incremental promotion.
  • Unix platforms now use the XDG filesystem conventions for the locations of per-user configuration and library files by default, but legacy paths are still used where they exist already.
  • Scribble improvements by Sorawee Porncharoenwase, William Bowman, and Shu-Hung You.
  • Improvements to the plot library from Alex Harsányi and Bert De Ketelaere.
  • The datum form from syntax/datum works with syntax pattern variables and syntax-parse attributes.
  • Unicode input works with recent versions of libedit in addition to libreadline. On Mac OS, a compatible version of libedit is included with Racket.

New in Racket 7.8 (Aug 4, 2020)

  • Racket CS may become the default Racket implementation in the next release. With the improvements in this release, Racket CS provides all of the functionality of Racket BC (the current default implementation). If, between this release and the next, no bugs are discovered in Racket CS that are more serious than those typically discovered in Racket BC, then Racket CS will become the default for the next release.
  • Racket CS supports AArch32 and AArch64, including places and futures. The implementation should be considered experimental in this initial release.
  • Racket CS supports an “incremental” garbage-collection mode that can eliminate long GC pauses for some applications, such as animations and interactive games.
  • Racket CS unboxes local floating-point arithmetic (like Racket BC).
  • DrRacket’s spell check features lower overhead and has fewer bugs.
  • Web Server performance under high concurrency is better by up to an order of magnitude. The Web Server is also more resistant to clients attempting to use unconstrained resources.
  • The math library includes the Kronecker product.
  • Windows supports finer granularity for sleep when sleeping for short periods of time, improving performance in animation.
  • The new prop:struct-field-info property provides static information about field names.
  • Debugging context in Racket CS is limited to 64,000 frames (approximately the same as Racket BC). This reduces the time taken to handle out-of-memory failures.
  • In plot, the legend font and the plot font can be controlled independently, and error-bars have an #:invert? option.
  • The plot and math libraries have new maintainers: Alex Harsányi for plot and Pavel Pancheka and Jens Axel Søgaard for math.

New in Racket 7.7 (May 4, 2020)

  • Racket CS remains ready for production use---thanks to those who have been putting it into practice to help iron out the remaining kinks---and it now supports a C API for embedding into other applications. See the "Inside: Racket" documentation for details.
  • Racket CS uses a new HAMT implementation, dramatically reducing the memory required for immutable hash tables.
  • Optimizations to the Racket CS compiler result in a code size savings of approximately 20%.
  • GC callbacks are reliably called on major collections in Racket CS. Also, Garbage collection is 10-20% faster.
  • DrRacket can recover much more quickly from errors involving large stack traces.
  • DrRacket now supports the use of the keyboard in the macOS Catalina "Open File" dialog.
  • The net/http-client collection supports the `deflate` content encoding.
  • The `call-in-continuation` function (like Marc Feeley's `continuation-graft`) simplifies certain `call/cc` patterns by calling a thunk in a restored continuation.
  • Call-with-current-language allows more reliable tests for language level code.
  • Use of the Cairo library can be multi-threaded.
  • Improved documentation!
  • Many bug fixes!

New in Racket 7.6 (Feb 14, 2020)

  • DrRacket’s scrolling has been made more responsive.
  • DrRacket’s dark mode support is improved for Mac OS and Unix.
  • Racket CS is ready for production use. We will work to further improve Racket CS before making it the default implementation, but it now consistently passes all of our integration tests and generally performs well. (Compiled code remains significantly larger compared to the default implementation.)
  • The Web Server provides fine-grained control over various aspects of handling client connections (timeouts, buffer sizes, maximum header counts, etc.) via the new “safety limits” construct.
  • Using this new construct, we have decreased the web server’s default level of trust in client connections and made it detect additional, maliciously constructed requests. Resource-intensive applications may need to adjust the default limits (for example, to accept large file uploads). In trusted settings, they can be disabled completely by starting the web server with #:safety-limits (make-unlimited-safety-limits).
  • The Web Server’s handling of large files is improved, and its latency for long-running request handlers is reduced.
  • The Macro Stepper has a new macro hiding algorithm that tracks term identity through syntax protection (see syntax-arm), making macro hiding work more reliably. Its UI indicates protected and tainted syntax.
  • The Racket documentation includes a “building and contributing” guide.

New in Racket 7.5 (Nov 20, 2019)

  • Almost all of Racket version 7.5 is distributed under a new, less-restrictive license: either the Apache 2.0 license or the MIT license. See https://blog.racket-lang.org/2019/11/completing-racket-s-relicensing-effort.html for more details.
  • Racket CS remains “beta” quality for the v7.5 release, but its compatibility and performance continue to improve. We expect that it will be ready for production use by the next release. We encourage you to check how well the v7.5 CS release works for your programs, and help push the project forward by reporting any problems that you find.
  • The Web Server provides a standard JSON MIME type, including a response/jsexpr form for HTTP responses bearing JSON.
  • GNU MPFR operations run about 3x faster.
  • Typed Racket supports definitions of new struct type properties and type checks uses of existing struct type properties in struct definitions. Previously, these uses were ignored by the type checker, so type errors there may have been hidden.
  • The performance bug in v7.4’s big-bang has been repaired.
  • DrRacket supports Dark Mode for interface elements.
  • Plot can display parametric 3d surfaces.
  • Redex supports modeless judgment forms.
  • MacOS 10.15 (Catalina) includes a new requirement that executables be “notarized”, to give Apple the ability to prevent certain kinds of malware. In this release, all of the disk images (.dmg’s) are notarized, along with the applications that they contain (.app’s). Many users may not notice any difference, but two groups of Catalina users will be affected: those that use the “racket” binary directly, and those that download the ".tgz" bundles. In both cases, the operating system is likely to inform you that the given executable is not trusted, or that the developer can’t be verified. Fortunately, both groups of users are probably also running commands at in a shell, and the solution for both groups is the same: you can disable the quarantine flag using the xattr command, e.g.
  • xattr -d com.apple.quarantine /path/to/racket
  • TL;DR: Everything is fine. Read this note again if you run into problems.

New in Racket 7.4 (Aug 9, 2019)

  • With this 7.4 release, we are making Racket CS available, a beta version of the Racket on Chez Scheme implementation. Racket CS is “beta” quality for the v7.4 release. It works well enough to be worth trying, but there are likely too many lingering problems for a project to switch to Racket CS for production use at this time. We encourage you to kick the tires of the new CS releases, and to help push this project forward by reporting any problems that you find.
  • Racket CS is available as a download option. To download Racket CS, select “CS” instead of “Regular” from the “Variant” popup menu.
  • Single-precision floating-point literals, a.k.a. single-flonums, are no longer supported by default.
  • This is a backward-incompatible change, but the use of single-flonums appears to be rare. Since Racket CS does not support single-flonums, disabling single-flonums by default smooths the transition from regular Racket and Racket CS.
  • The read-single-flonum parameter can be set to #t to enable reading single-flonum literals, but a better strategy in most cases is to use real->single-flonum when single-flonum-available? reports #t or when single-flonum? reports #t for a value (which implies that single-flonums must be supported). Where single-flonums are supported, Racket’s compiler will fold a call of real->single-flonum on a literal number to a constant single-flonum value.
  • New compilation flags including —disable-generations and —enable-ubsan provide better support for alternative architectures.
  • The 2htdp/universe teachpack supports an event log window for big-bang. With this option, students can inspect the events that big-bang handled, plus their payload. The event log includes messages from external sources.
  • The following people contributed to this release: Alex Knauth, Alexander B. McLin, Alexis King, Andreas Düring, Asumu Takikawa, Atharva Raykar, Ben Greenman, Benjamin Yeung, Dmitry Moskowski, Fred Fu, Gustavo Massaccesi, Ilnar Salimzianov, Jason Hemann, Jay McCarthy, Jesse A. Tov, Jesse Alama, John Clements, Leif Andersen, Lukas Lazarek, Matthew Flatt, Matthias Felleisen, Mike Sperber, Morgan Lemmer-Webber, Noah W M, Paulo Matos, Philip McGrath, Robby Findler, Rodrigo, Roman Klochkov, Ryan Culpepper, Sam Tobin-Hochstadt, Simon ‘Sze’ L. Schlee, Sorawee Porncharoenwase, Spencer Florence, Stephan Renatus, Stephen Chang, Stephen De Gabrielle, Thomas Dickerson, Vincent St-Amour, yjqww6

New in Racket 7.3 (May 16, 2019)

  • There is a new set of teaching languages for the upcoming German-language textbook “Schreibe Dein Programm!” (https://www.deinprogramm.de/).
  • Racket’s IO system has been refactored to improve performance and simplify internal design.
  • Racket’s JSON reader is dramatically faster.
  • The plot library includes color map support for renderers.
  • The Racket web library has improved support for 307 redirects.
  • The Racket web server provides better response messages by default for common status codes.
  • The pict library includes a shear function.

New in Racket 7.2 (Jan 31, 2019)

  • The contract system supports collapsible contracts, which avoid repeated wrappers in certain pathological situations. Thanks to Daniel Feltey.
  • Quickscript, a scripting tool for DrRacket, has become part of the standard distribution. Thanks to Laurent Orseau.
  • The web server’s built-in configuration for serving static files recognizes the ".mjs" extension for JavaScript modules.
  • The data/enumerate library supports an additional form of subtraction via but-not/e, following Yorgey and Foner’s ICFP’18 paper. Thanks to Max New.
  • The letrec.rkt example model in Redex has been changed to more closely match Racket, which led to some bug fixes in Racket’s implementation of letrec and set!.
  • The racklog library has seen a number of improvements, including fixes to logic variable binding, logic variables containing predicates being applicable, and the introduction of an %andmap higher-order predicate.

New in Racket 7.1 (Nov 2, 2018)

  • Although it is still not part of this release, the development of Racket on Chez Scheme continues. We still hope and expect that Racket-on-Chez will be ready for production use later in the v7.x series, perhaps mid–2019.
  • Trackpad scrolling works in more reliably in some Windows and Linux/Unix environments.
  • New users of DrRacket will open files into new tabs (by default).
  • The teaching languages support the unicode character for lambda. The teaching unit test framework no longer stops testing when a tested expression signals an error.
  • A refinement to error reporting for compile-time code helps clarify when an syntax error is likely due to an earlier unbound identifier (because the unbound-identifier error otherwise must be delayed, in case a definition appears later).
  • A ++lang flag for raco exe simplifies the creation of executables that dynamically load #lang modules at run time.
  • Typed Racket adds types for mutable and immutable vectors: (Mutable-Vectorof T), (Immutable-Vectorof T), (Immutable-Vector T), and (Mutable-Vector T). The new types are subtypes of the existing Vectorof and Vector types. The return types of a few standard vector functions use the new, more specific, types. When an immutable vector flows from untyped code to typed code, Typed Racket may be able to check the vector with a flat contract.
  • The hashing functions sha1-bytes, sha224-bytes, and sha256-bytes are added to racket/base.
  • curry from racket/function supports currying functions with keyword arguments, and procedure-arity and procedure-keywords return the correct result when applied to curried functions.
  • Slideshow supports widescreen mode (finally!). Implement widescreen slides using slideshow/widescreen or provide the --widescreen command-line flag to Slideshow. Combine --widescreen with --save-aspect to make widescreen mode the default in your installation.
  • Racket supports FreeBSD/aarch64.
  • Various improvements and additions were made to the DeinProgramm teaching languages and their documentation.

New in Racket 7.0 (Jul 28, 2018)

  • The syntax (#') form supports new template subforms: ~@ for splicing and ~? for choosing between subtemplates based on whether pattern variables have “absent” value (from an ~optional pattern in syntax-parse, for example). The syntax/parse/experimental/template library, where these features originated, re-exports the new forms under old names for compatibility.
  • Typed Racket’s support for prefab structs is significantly improved. This supports using prefab structs more polymorphically, and fixes significant bugs in the current implementation. Programs which currently use predicates for prefab structs on unknown data may need to be revised, since previous versions of Typed Racket allowed potentially buggy programs to type check. See Typed Racket RFC 1 and this blog post for more details on this change and on how to fix programs affected by it.
  • Typed Racket supports #:rest-star in the ->* type constructor, which allows function types to specify rest arguments with more complex patterns of types, such as the hash function.
  • Interactive overlays can be added to plots produced by plot-snip. This allows constructing interactive plots or displaying additional information when the mouse hovers over the plot area.
  • racket/plot provides procedures for displaying candlestick charts for use in financial time series analysis.
  • Added contract-equivalent?, a way check if two contracts are mutually stronger than each other without the exponential slowdown that two calls to contract-stronger? brings.
  • Lazy Racket supports functions with keyword arguments.

New in Racket 6.12 (Jan 27, 2018)

  • Changed the way some unsafe operations are exposed via ffi/unsafe libraries to help smooth a future transition to a new runtime system.
  • The syntax-parse form supports unwinding side-effects when it backtracks, both explicitly with ~undo patterns and implicitly with the built-in managed state (using syntax-parse-state-ref, etc).
  • The db library supports SCRAM-SHA–256 authentication for backends running PostgreSQL 10 or later. Client support for SCRAM and other SASL mechanisms is provided by the new sasl library.
  • The lazy-require-syntax form supports lazy loading of macro transformers. Note that the macros must obey certain implementation constraints (see the lazy-require-syntax documentation).
  • Typed Racket no longer enforces types like (U String (Boxof String)) with the any/c contract. This fixes a type soundness issue, but may affect performance. Please submit a bug report if you find a program that runs significantly slower on v6.12 than earlier versions.
  • Typed Racket’s type instantiation (inst) uses Any for omitted type arguments, allowing APIs to add additional type variables to functions without breaking existing programs.
  • for/fold users can customize the final result of a loop’s computation using the #:result keyword.
  • The --deps option to raco test tests the packages the argument packages depends on, in addition to testing the packages themselves. For example, raco test -p --deps pkg1 pkg2 tests all files from pkg1, pkg2, and all of their dependencies.

New in Racket 6.11 (Oct 31, 2017)

  • A bug preventing OneDrive users on Windows 10 Fall Creators update from opening files has been fixed.
  • Typed Racket supports refinement types and dependent function types. Previously an experimental feature, refinement types allow types to describe more interesting properties of values, especially integers. For example, this type shows that the max function always produces a number at least as big as its inputs: (-> [x : Integer] [y : Integer] (Refine [z : Integer] (and (>= z x) (>= z y))))
  • DrRacket’s Program Contour is significantly more efficient; using it no longer hurts DrRacket’s interactivity.
  • The web-server/formlets library produces formlets that are serializable, facilitating dynamic uses of formlets in stateless #lang web-server servlets. The new web-server/formlets/stateless and web-server/formlets/unsafe libraries provide additional support with the same API.
  • The db library supports the Cassandra database.

New in Racket 6.10.1 (Sep 14, 2017)

  • Corrects the peer-side results from tcp-addresses.

New in Racket 6.10 (Aug 1, 2017)

  • Internally, Racket’s intermediate compatibility layer over operating-system facilities has been moved into its own library, “rktio”, so it can be used in future Racket implementations. This change should be transparent, but the refactoring moves code that has many compiler and OS dependencies, so we expect a new glitch or two in less-common build and execution environments. Please report problems at https://github.com/racket/racket/issues.
  • Racket supports cross-compilation of executables in more cases, including executables that depend on packages for foreign libraries.
  • The struct form supports an #:authentic annotation to declare that chaperones and impersonators are never allowed on instances of the declared structure type. This annotation is intended for use on a library’s internal data structures, where it won’t interfere with contracts or other forms of extension at a library’s interface. It can sometimes provide a small performance boost.
  • RackUnit adds nested-info and string-info to grant custom checks more control over the display and layout of check failure info.
  • The raco test command provides the ++arg and ++args flags to pass arguments to tested programs.
  • Typed Racket has types for immutable, mutable, and weak hashtables; in other words the type (HashTable K V) is a union (U (Immutable-HashTable K V) (Mutable-HashTable K V) (Weak-HashTable K V)). Standard library functions may have more specific return types. For example, hash-set has type (-> (HashTable K V) K V (Immutable-HashTable K V)). When an immutable hashtable flows from untyped code to typed code, Typed Racket may use a flat contract to verify its type (provided the table’s key and value types are flat).
  • The Typed Racket Optimizer is disabled in untrusted contexts (e.g., sandboxes). This prevents unsoundness in the Typed Racket type system from being used to get access to unsafe operations.
  • Racket’s internal runtime adds a scheme_atexit procedure with identical behavior as atexit defined in libc.

New in Racket 6.9 (Apr 28, 2017)

  • A security vulnerability in the racket/sandbox library and Typed Racket allowed malicious Typed Racket code to escape the sandbox. This vulnerability has been fixed in Racket version 6.9. Anyone using racket/sandbox to execute untrustworthy code with access to Typed Racket should upgrade to version 6.9 immediately.
  • While this known vulnerability has been eliminated, it is possible that similar errors in other installed collections could also be exploited, although we are not currently aware of any existing vulnerabilities. We recommend that if you use the Racket sandbox to execute untrustworthy Racket code, you should also employ additional operating system or virtual machine level protections. The documentation for racket/sandbox has been updated to list recommended security practices for using the library.
  • The official package catalog Web site is revised to have a new user experience.
  • The Northwestern snapshot site keeps weekly snapshots going up to 12 weeks into the past. Those provide a middle ground for users who want access to new features earlier than stable releases, but want less churn than nightly builds.
  • DrRacket provides a refactoring tool to remove unused requires in modules.
  • DrRacket’s #lang-line customization support works better with buggy (i.e., in development) languages.
  • The web server’s cookie libraries, including “id cookie” authentication, support RFC 6265.
  • The db library supports PostgreSQL’s UUID type.
  • The raco command lists matching commands when passed an ambiguous command prefix.
  • The bytecode compiler detects more optimization opportunities for structure operations.
  • Scribble can produce output via XeLaTeX as an alternative to LaTeX.
  • Scribble supports the acmart LaTeX style, for use with ACM publications.
  • Scribble supports the use of CJK characters in tags.

New in Racket 6.8 (Jan 25, 2017)

  • Racket sports a new logo, courtesy of Matthew Butterick.
  • MacBook Pro laptops with touch bars are supported.
  • Support for FreeBSD on PowerPC.
  • Initial support for GTK3 on Wayland is available. GL contexts, GC blits, and dialog placement currently do not work.
  • The macro stepper provides a command-line interface via the raco macro-stepper command.
  • Typed Racket more efficiently represents and computes types and propositions, resulting in faster type checking for many programs. For more details, see this blog post by Andrew Kent.
  • The bytecode optimizer can reduce more expressions of the form (equal? x y) to (eqv? x y) or (eq? x y) when the type of x or y is known.
  • The bytecode optimizer avoids dropping stack frames in some reductions. This provides better stack traces for errors when errotrace is enabled.
  • The bytecode compiler detects more optimization opportunities, including when variables always hold a boolean value. In particular in expressions like (or (symbol? x) (something)), the optimizations avoid the creation of an intermediate variable to store the result of (symbol? x).
  • The syntax form preserves syntax properties on all template pieces.
  • The scribble/html/extra module provides renderers for HTML elements that are part of the WHATWG HTML standard but not part of the scribble/html language by default (e.g., map, time, video).
  • The DeinProgramm teaching languages support pattern matching using the match form.
  • In the DeinProgramm languages, define-record-procedures supports specifying signatures as part of the form, instantly enabling properties quantifying over such records.

New in Racket 6.7 (Oct 27, 2016)

  • Racket supports building graphical applications on Android through the racket-android project: https://github.com/jeapostrophe/racket-android
  • The Racket REPL comes with line-editing, command and result history, and various meta-commands out of the box, via the racket/interactive module. See the racket/interactive and xrepl documentation for details.
  • The package system supports authentication when installing packages from git, using the raco pkg config git-checkout-credentials configuration option.
  • HTTP libraries, as well as raco pkg, support proxying via HTTP CONNECT.
  • Typed Racket provides typed versions of racket/os and racket/db/sqlite.
  • The PLT_COMPILED_FILE_CHECK environment variable provides more fine-grained control over when .zo files are consulted.
  • The documentation search supports searching for #langs and #readers via the "L:" and "R:" search prefixes.
  • The file/glob module implements globbing for path-strings.
  • Optimizations in the bytecode compiler improve performance for structure, list, string, and byte-string operations.

New in Racket 6.6 (Jul 24, 2016)

  • The new Macro Profiler command-line tool (`raco macro-profiler`) shows how macros contribute to the final expanded code size of a program.
  • Typed Racket supports intersection types. This allows the type system to track more information, and for programmers to express more precise types.
  • Typed Racket produces up to 4x smaller compiled files compared with Racket 6.5, reducing the size of the Racket distribution by 50M.
  • Typed Racket issues warnings in cases where the contract generated for Any was not strict enough in the past. These warnings will become errors in a future release. Warnings are enabled via View -> Show Log in DrRacket, and shown by default on command-line Racket.
  • Typed Racket enforces uses of cast more correctly, by checking both the "casted-to" and "casted-from" types. Previously, only the former were checked. In some cases, this will produce contract errors in programs that did not have errors before.
  • syntax-parse raises an error when an ellipsis pattern has an empty match rather than diverging, and it logs a warning when it statically detects a nullable pattern, such as ((~seq) ...). In the next version of Racket, it will reject the pattern instead, and it will remove special handling that currently makes some uses of such patterns terminate.
  • htdp/dir: The create-dir function delivers data information for files in a new field. The domain of its functions are backwards compatible.

New in Racket 6.5 (Apr 28, 2016)

  • Typed Racket and the racket/contract library generate code with lower overhead, speeding up typed/untyped interaction in a number of gradual typing programs we studied.
  • Macros written using syntax-parse automatically emit more accurate error messages.
  • The contract profiler captures costs from more contract combinators, including all those in the main distribution.
  • Hash table and set iteration, via both existing and new non-generic sequences, is more performant, up to twice as fast on microbenchmarks.
  • The Racket optimizer detects many more optimization opportunities, including when variables always hold numbers.
  • The db library supports single-result CALL statements in MySQL.
  • The net/dns library supports SRV records.
  • The racket/unix-socket library supports listen and accept operations.

New in Racket 6.4 (Feb 9, 2016)

  • We fixed a security vulnerability in the web server. The existing web server is vulnerable to a navigation attack if it is also enabled to serve files statically; that is, any file readable by the web server is accessible remotely. For more information, see this post.
  • DrRacket's scrolling is faster.
  • Incremental garbage-collection mode can eliminate long pauses in a program. For example, incremental mode is useful for avoiding pauses in games and animations.
  • Programs must specifically request incremental mode with (collect-garbage 'incremental), but libraries such as 2htdp/universe include the request as part of the library's implementation.
  • The default package catalog is an HTTPS address instead of HTTP, and package operations properly validate server certificates when using HTTPS.
  • Documentation may define their own categories for the manual top-level page by using strings, rather than only symbols that name pre-defined categories.
  • The Racket cheat sheet is included in the main distribution.
  • DrRacket is available in Bulgarian, thanks to Alexander Shopov.
  • The contract Typed Racket generates for the Any type is more permissive, allowing more typed/untyped programs to work without contract errors.
  • Redex supports binding specifications; describe which variables bind in which expressions and your metafunctions and reduction relations automatically become scope-sensitive. Thanks to Paul Stansifer for this improvement.
  • All pict functions accept pict-convertibles. This allows for transparent interoperability between pict and libraries like 2htdp/image.
  • The raco profile and raco contract-profile commands provide easy access to profiling tools, without requiring program modifications.

New in Racket 6.3 (Nov 24, 2015)

  • Racket's macro expander uses a new representation of binding called "set of scopes". The new binding model provides a simpler explanation of how macros preserve binding, especially across module boundaries and in hygiene-bending expansions. The new expander is mostly compatible with existing Racket macros, but there are some incompatibilities. For the formally inclined, a research paper on this macro system will appear at POPL next year: http://www.cs.utah.edu/plt/scope-sets/
  • Racket's GUI library now uses Gtk+ 3 when available, instead of Gtk+ 2. Set the PLT_GTK2 environment variable to select Gtk+ 2.
  • Added a new Redex tutorial based on a week-long workshop in SLC.
  • Better syntax error checking for Redex patterns that do not use holes correctly.
  • The blueboxes are more agressive about finding names to look up in the docs, meaning they are useful much more often.
  • Submodules are now fully supported in Typed Racket. Previously, some uses of submodules would produce internal errors, making it hard to module+ test and module+ main effectively in Typed Racket. The switch to the set-of-scopes expander fixed these problems, and submodules are now happily at home in Typed Racket.
  • The typed/racket/unsafe library provides import and export forms that circumvent contract generation. This improves performance for typed-untyped interaction at the cost of safety and debuggability.
  • Typed Racket provides experimental support for units (from racket/unit).
  • The experimental define-new-subtype form allows overlaying finer distinctions between otherwise identical types, similar to Haskell's new type.
  • The Promise type constructor changes in a backwards-incompatible way to exclude promises created with promise/name.
  • The unstable-* packages are out of the main distribution. Most of their contents have been either merged with established Racket libraries or spun off as their own packages. This change is backwards compatible for packages that properly list their dependencies. Full details: http://blog.racket-lang.org/2015/10/retiring-unstable.html
  • edu: big-bang supports a display-mode clause so that world programs can take over the entire screen.

New in Racket 6.2.1 (Aug 11, 2015)

  • Version 6.2.1 patches the recent v6.2 release in three small ways:
  • For the How to Design Programs teaching languages, DrRacket offers an option to use the old style for printing the constants true, false, and empty instead of #true, #false, and '().
  • The teaching languages come with some additional functions to match the August 2015 stable release of HtDP 2nd edition.
  • A repair to the compiler avoids an infinite loop at compile time for certain expressions that should loop forever at run time.

New in Racket 6.2 (Jun 20, 2015)

  • core repo:
  • The package manager supports a direct references to Git repositories via "git://[...]", "http://[...].git", and "https://[...].git" URLs. (Previously, only references to GitHub were supported.)
  • A --clone option for raco pkg install or raco pkg update facilitates Git-based package development. If a package X has a Git repository source, installing and updating the package pulls from the repository in a read-only mode. Using raco pkg update --clone X switches the local installation to a repository checkout that is suitable for modifying the package implementation, issuing pull requests, pushing changes, and so on.
  • Using raco pkg update --lookup X switches the package back to the default installation mode.
  • drracket:
  • Its on-line check syntax works with graphical content.
  • Increased availability of DrRacket's blueboxes, including method and constructor information.
  • The "Open Require Path" menu item supports ".." in relative pathnames.
  • data:
  • Added data/enumerate, a library that supports efficient enumeration of data structures
  • redex:
  • Its redex-check facility uses data (in addition to random) enumeration to try to find counter-examples.
  • Its generate-term function accepts additional arguments to return the "i"-th member of a pattern using data/enumerate (meaning it efficiently supports very large values of "i").
  • The examples collection includes Launchbury's 1993 big-step lazy semantics.
  • htdp:
  • 2htdp/image's polygon may be built out of bezier curves instead of just straight lines (see the docs for pulled-point).
  • 2htdp/abstraction is a teachpack for instructors and students who wish to use for/* loops, match, define-type and type-cases in ISL and ISL+.
  • 2htdp/universe programs can be exported using DrRacket's executable creation mechanism and they behave properly when run independently.
  • typed-racket:
  • Typed Racket in DrRacket displays tooltips that show the types of expressions. Tooltips are also displayed for type errors.
  • Typed Racket loads generated contracts only when needed. This reduces memory use and startup time for Typed Racket programs.
  • Typed Racket has improved support for prefab structures, future semaphores, and async channels.
  • Typed Racket understands when two different variables refer to the same thing, and updates types accordingly. This particularly improves the type checking of macros such as match.

New in Racket 6.1.1 (Nov 5, 2014)

  • The Mac OS X Yosemite compatibility problems are fixed. We bundled a patched Pango text-drawing library with Racket.
  • The Windows [32-bit] releases fixes the window-update crashes. We bundled a patched Cairo drawing library with Racket.
  • Typed Racket closes two safety holes in the exception system. The revised type system restricts raise to send only instances of the exn structure type and flat data to handlers. It also checks exception handlers properly. Note: Previously well-typed programs may fail to typecheck.
  • Typed Racket's typed regions support casts and predicates.
  • 2htdp/image's notion of equality ignores an image's baseline.
  • The package manager supports a binary library installation mode, which allows users to install packages without source or documentation. Use the --binary-lib option with raco pkg install.
  • The new drracket-tool-lib package factors out parts of DrRacket's IDE so that they can be reused with other editors, such as Emacs.
  • The compiler's use-before-defined analysis has been repaired for certain forms of nested letrec, some let forms, and some uses of set! or with-continuation-mark.
  • The compiler performs additional bytecode optimizations. Thanks to Gustavo Massaccesi.
  • The CML library comes with a new replace-evt event constructor. Thanks to Jan Dvořák.
  • Redex's benchmark suite comes with a description of the benchmark programs.
  • Redex's metafunctions can be typeset using the "large left brace" notation for conditionals.
  • The contract library comes with an improved contract-stronger?. Its error messages note that the contract itself might be wrong.
  • The GUI library is DPI-aware on Windows.
  • The openssl library supports Server Name Indication for servers. Thanks to Jay Kominek.
  • The syntax/parse library allows the definition of new pattern forms via pattern expanders, similar to match expanders. Thanks to Alex Knauth.
  • OpenGL on Linux no longer depends on libgtkgl, and core profiles are supported (see set-legacy?).
  • The teaching languages' unit test framework supports check-satisfied, a construct for checking whether a result satisfies a predicate, e.g.:
  • (check-satisfied (sort l) sorted?)

New in Racket 6.1 (Aug 4, 2014)

  • The major innovation concerns local recursive variable definitions. Instead of initializing variables with an undefined value, Racket raises an exception when such a variable is used before its definition.
  • Changes:
  • Plumbers generalize the flush-on-exit capability of primitive output ports to enable arbitrary flushing actions and to give programmers control over the timing of flushes (i.e., a composable atexit). New functions include current-plumber, plumber-add-flush!, and plumber-flush-all.
  • Contracts: the contract system's random testing facility has been strengthened so that it can easily find simple mistakes in contracted data structure implementations (e.g. an accidental reverse of a conditional in a heap invariant check).
  • Redex: the semantics of mis-match patterns (variables followed by _!_) inside ellipses has changed in a backwards-incompatible way. This change simplifies the patterns' semantics and increases the usefulness of these patterns.
  • Teaching languages: check-random is an addition to the preferred unit testing framework in the teaching languages. It enables the testing of students' functions that use random-number generation. (Thanks to David Van Horn (UMaryland) for proposing this idea.)
  • Upgraded and normalized versions of graphics libraries and dependencies (Pango, Cairo, GLib, etc.) that are bundled with Racket on Windows and Mac OS X. For example, FreeType support is consistently enabled.
  • Typed Racket: its standard library includes contracted exports from the Racket standard library, such as the formatting combinators of racket/format. It also supports Racket's asynchronous channels; see the typed/racket/async-channel library.
  • SSL: The openssl library supports forward secrecy via DHE and ECDHE cipher suites (thanks to Edward Lee) and Server Name Indication (thanks to Jay Kominek).
  • The mzlib/class100 library has been removed. Use racket/class instead.

New in Racket 6.0.1 (May 9, 2014)

  • A new racket/undefined library exports undefined as the value currently produced by (letrec ([x x]) x). This library anticipates a future where that expression will raise an exception. The racket/undefined library will continue to offer the undefined value as a bridge between versions and as a last resort.
  • The drawing and GUI libraries provide improved support for high-resolution bitmaps and their use on Retina displays. For example, read-bitmap includes a #:try-@2x? option to trigger substitutions through the usual "@2x" naming convention.
  • Check Syntax cooperates with Typed Racket to show arrows and other Check Syntax highlighting even when there is a type error.
  • Functions provided via contract-out that have first-order contracts perform better.
  • The contract boundary between typed/untyped modules is much less expensive. Typed Racket now avoids generating contracts for places where contracts failures cannot happen.
  • Occurrence typing now works better with when/unless.
  • Types in Typed Racket are now pretty-printed.
  • Function types can now be written in prefix style, which is now preferred and is used for printing. Infix function types are still accepted for backwards compatibility.
  • A new ->* type constructor is used for writing types for functions with optional and keyword arguments. The notation is similar to the matching contract combinator.
  • Typed Racket forms do not have a : suffix by default now. For example, the struct form replaces struct:. The suffixed versions are all provided for backwards compatibility.
  • Typed Racket now has preliminary support for classes and objects. However, it is still experimental and the APIs are subject to change.
  • Type aliases in Typed Racket now support recursion and mutual recursion. For example, (define-type (MyList X) (U Null (Pair X (MyList X)))) is now a valid type alias.
  • Plot correctly renders intersecting 3D graphs and non-grid-aligned 3D rectangles.
  • Elements in plots output in PDF/PS format have the same relative scale as in other formats. In particular, it is not necessary to adjust plot-font-size to make PDF plots look the same as PNG

New in Racket 6.0 (Mar 3, 2014)

  • Has a new package system, including a catalog of hundreds of already-available packages.
  • Incorporates many improvements suggested by preliminary experiences in those versions:
  • A package is treated as a single collection by default, so it is even easier to use a GitHub repository as a package. Get started quickly: http://docs.racket-lang.org/pkg/getting-started.html
  • DrRacket includes a new package manager GUI, available via the File|Package Manager ... menu item. The GUI is also available as a stand-alone program via the "gui-pkg-manager" package.
  • The main Racket distribution has been separated into about 200 packages. The Racket installer combines the core system with bundled versions of these packages.
  • Alternatively, you may now install a Minimal Racket distribution --- which is about 1/10 the size of the main distribution --- and add only those packages that you need.
  • Package installation supports pre-built packages that include compiled byte code and rendered documentation, meaning packages can be installed quickly when built versions are available. All packages in the main distribution are available in pre-built form.
  • The recent 5.92 and 5.93 releases served as release candidates for 6.0, and 6.0 includes a few additional repairs related to the package system.
  • Further improvements to the package system are in the works, notably
  • including package documentation on the package-catalog web site.
  • COMPATIBILITY NOTE: PLaneT, the previous Racket package system, will remain in place for the foreseeable future, but we expect all package work to shift to the new system.
  • Beyond the package system, this release brings a number of other changes:
  • Racket's HTML documentation has a new and improved look, thanks to Matthew Butterick.
  • The documentation includes a style guide, "How to Program Racket" http://docs.racket-lang.org/style/
  • Racket's JIT compiler supports the ARM architecture.
  • Racket supports the Mac's Retina display mode.
  • The performance of the Typed Racket compiler improved by 50% on some typed programs; e.g., see http://bit.ly/1d0Ye4z
  • The profiler provides a new mode that uses the errortrace library to produce fine-grained profiles.
  • A new contract profiler reports how much time programs spend checking contracts, and which contracts are most expensive.
  • The math/flonum library exports fast 105-bit precision operations.
  • Check Syntax handles generated identifiers, especially those introduced by struct (e.g. field selectors) and Redex (e.g., e_1, e_2)
  • 2htdp/batch-io includes functions for dealing with html/xml in files and web sites as X-expressions plus conveniences for web-based graph traversals.
  • The `gen:set' generic interface extends set operations to work on user-defined types that implement set methods, as well as on other set-like built-in types, such as lists.
  • Picts support conversion to SVG format.
  • Under unix, Racket provides desktop entries (.desktop files) for its graphical executables.

New in Racket 5.3.6 (Aug 12, 2013)

  • Bug-fix release. It eliminates errors from v5.3.5 that people have found over the summer.

New in Racket 5.3.5 (Jun 18, 2013)

  • This is a special-purpose release to match the arrival of “Realm of Racket” in bookstores. Racket v5.3.5 adds a single realm collection to the v5.3.4 release. The new collection contains the source code that readers of Realm may wish to use for experiments.

New in Racket 5.3.4 (May 9, 2013)

  • Extflonums (80-bit floating-point numbers) are supported on some x86/x86_64 platforms — including Windows, and including platforms where Racket is compiled to use SSE instructions for flonum arithmetic. Thanks to Michael Filonenko.
  • OS X: DrRacket and all of the other apps are now signed with an official key.
  • Tally Maze: a new game based an enumeration of 2d mazes.
  • The Optimization Coach, a DrRacket plugin, has been moved from the Racket distribution to the Racket package repository. Install it with: raco pkg install optimization-coach.
  • Redex: define-union-language now merges productions when languages define the same nonterminals. Thanks to William Bowman.
  • The srfi/19 library is now compatible with the date structure type exported by racket/base.

New in Racket 5.3.3 (Feb 16, 2013)

  • This is a bug-fix release to address a flaw in DrRacket v5.3.2 concerning interactions between the contour window and the syntax coloring.

New in Racket 5.3.2 (Feb 1, 2013)

  • Core Libraries:
  • The new math library provides functions and data structures for working with numbers and collections of numbers. Functions include non-elementary (such as gamma, zeta, Lambert's W), number-theoretic (factorization, modular arithmetic), linear algebra (arithmetic, decompositions), and statistical (expected values, order statistics, binning). Data structures include arbitrary-precision bigfloats, probability distributions, and multidimensional arrays.
  • The new file/untar, file/untgz, and file/unzip libraries support unpacking widely used archive formats.
  • The new lazy-require form allows programs to delay the loading and instantiation of helper modules until they are needed.
  • The new data/bit-vector library provides an implementation of bit vectors (a mutable sequence of booleans) supporting popcount.
  • The racket/generic library allows the specification of default method implementations for core datatypes.
  • The openssl library can verify hostnames and use the operating system's certificate store to verify certificates.
  • Package System:
  • A new package system is in beta release. This system will become Planet's successor. It differs significantly from the latter. For details, please read the documentation at http://docs.racket-lang.org/planet2/ and list your packages on the new index at https://pkg.racket-lang.org/.
  • The raco test command supports testing by collection and package, in addition to by directory and file, with the -c and -p options.
  • Teaching Libraries:
  • batch-io: the read and write functions work on Unix-style standard input and output.
  • DrRacket:
  • DrRacket's GUI is more responsive.
  • The automatic parenthesis insertion mode is improved.
  • Scribble:
  • Scribble renders Markdown format files via the --markdown command-line flag. Example use case: Generate documentation hosted on GitHub or BitBucket.
  • Documentation cross-reference information is stored in an SQLite3 database, which means that SQLite3 is required for building Racket documentation on Unix/Linux machines (but SQLite3 is included in Racket distributions for Windows and Mac OS X).
  • Using a database for cross-reference information significantly reduces the initial footprint of DrRacket, since DrRacket no longer needs to load all cross-reference information.
  • Typed Racket:
  • Typed Racket programs can require plot/typed to draw plots. List- and vector-accepting functions accept general sequences.
  • Typed Racket supports Racket's delimited continuation and continuation mark operators.
  • Redex:
  • Added more support for define-judgment-form, including random generation for well-formed judgments and visualization of judgments.
  • Deprecation:
  • The following have been removed in this release: the planet command-line tool; use raco planet instead.
  • The following has been deprecated and will be removed in the August 2013 release: the mzlib/class100 library; use racket/class instead.

New in Racket 5.3.1 (Nov 8, 2012)

  • Racket:
  • The case form dispatches on characters, fixnums, symbols, and keywords in logarithmic time. (Thanks to Jon Zeppieri.)
  • The new racket/format library provides new and improved string-formatting functions.
  • Logging tools include improved filtering support based on the name of a logger. A new define-logger form simplifies the use of named loggers. Forms such as log-debug now support string formatting.
  • The for forms now support #:break and #:final clauses.
  • The new PLTCOMPILEDROOTS environment variable configures the search path for compiled bytecode.
  • DrRacket:
  • Check Syntax now summarizes the documentation (i.e., the blue boxes) for the identifier at the insertion point in the top-right corner of the definitions window.
  • Check Syntax now runs continuously for programs that declare their language within the source. This mode has been available for several of the past releases, but now enabled by default.
  • DrRacket can spell-check string constants (enable this in the Edit menu).
  • Typed Racket:
  • Typed Racket interprets the Any type as a different contract. This may signal dynamic errors in some existing mixed typed/untyped programs. The normal fix is to replace a use of Any with a more specific types.
  • NaN is included in all of Typed Racket's floating-point types, which makes precise floating-point types easier to use.
  • Typed Racket supports a cast operation with support for higher-order types.
  • Typed Racket provides the :query-type/args and :query-type/result utilities to explore types at the REPL.
  • Miscellaneous:
  • The compatibility collection provides features from Racket relatives, such as defmacro and mutable lists. These features are provided to ease porting code to Racket. Avoid them in modern Racket code.
  • Screenshots of the widgets provided by the Racket GUI library are included in the documentation. (Thanks to Diogo F. S. Ramos.)
  • FrTime was ported to racket #lang. (Thanks to Patrick Mahoney.)
  • Deprecation:
  • The following has been deprecated and will be removed in the January 2013 release: the planet command-line tool; use raco planet instead.
  • The following has been deprecated and will be removed in the August 2013 release: the mzlib/class100 library; use racket/class instead.

New in Racket 5.3 (Aug 7, 2012)

  • Submodules are nested module declarations that can be loaded and run independently from the enclosing module. See also the overview of submodules.
  • The futures visualizer is a graphical profiling tool for parallel programs using futures. The tool shows a detailed execution timeline depicting the migration of futures between threads, and gives detailed information about each runtime synchronization that occurred during program execution. In addition, would-be-future is a special type of future that always executes sequentially and records all potential barricades a regular future would encounter.
  • Optimization Coach (formerly Performance Report) reports information about Racket's inlining optimizations. Optimization Coach can be launched in any language through the View menu.
  • The new images/flomap library defines floating-point bitmaps and fast image processing operations on them. It is written in Typed Racket, so Typed Racket code may use it without the cost of contract checks.
  • The new json library supports parsing and generating JSON. (Originally based on Dave Herman's planet library.)
  • racket/string is extended with a set of simplified string manipulation functions that are more convenient than using regexps. regexp-match* and friends can now be used with new keyword arguments to return specific matched regexp group/s and gaps between matches.
  • The new racket/generic library allows generic function definitions, which dispatch to methods added to a structure type via the new #:methods keyword.
  • The class form supports declaring a method abstract. An abstract method prevents a class from being instantiated unless it is overridden.
  • The contract library comes with support for interfaces, generics, prompts, continuation-marks, and structs.
  • Most error messages use a new multi-line format that is more consistent with contract errors and accommodates more information.
  • Typed Racket supports function definitions with keyword arguments; the startup time of Typed Racket programs has been sharply reduced.
  • The new ffi/com library replaces MysterX; a compatibility mysterx library remains, but without ActiveX support. The new ffi/unsafe/com library offers a more primitive and direct way to use COM classes and methods.
  • There is now a very complete completion code for zsh. It is not included in the distribution though; get it at http://goo.gl/DU8JK (This script and the bash completions will be included in the standard installers in future versions.)

New in Racket 5.2.1 (Feb 3, 2012)

  • Performance improvements include the use of epoll()/kqueue() instead of select() for the Racket thread scheduler, cross-module inlining of small functions, and the use of SSE instead of x87 for JIT-compiled floating-point operations on platforms where SSE is always available (including x86_64 platforms). A related change is the interning of literal numbers, strings, byte strings, characters, and regexps that appear in code and syntax objects.
  • DrRacket uses a set of composable ray-traced icons available from the new `images' library collection.
  • Typed Racket's `typecheck-fail' form allows macro creators to customize the error messages that Typed Racket produces. This is especially useful when creating pattern matching macros.
  • The performance of Redex's matcher has been substantially improved; depending on the model you should see improvements between 2x and 50x in the time it takes to reduce terms.
  • Plots look nicer and are more correct at very small and very large scales. New features include customizable dual axis ticks and transforms (e.g., log axes, date and currency ticks, axis interval collapse and stretch), stacked histograms, and 3D vector fields. The legacy `fit' function and libfit have been removed.
  • The `2htdp/universe' library's `big-bang' form supports an experimental game pad key handler.
  • The `db' library now supports nested transactions and PostgreSQL arrays. Bugs involving MySQL authentication and memory corruption in the SQLite bindings have been fixed.
  • The Macro Stepper tool in DrRacket no longer executes a program after expanding it.
  • In the DMdA teaching languages, infinite recursive signatures ("streams", for example) with no intervening `mixed' are now supported, and the signatures of record definitions without fields now have generators for use with `property'.
  • MysterX's ActiveX support is deprecated and will be removed in the next release. MysterX's core COM functionality will become deprecated in the next release, but COM functionality will be supported for the foreseeable future as a compatibility layer over a forthcoming `ffi/com' library.

New in Racket 5.2 (Nov 10, 2011)

  • DrRacket comes with an experimental, on-line check syntax tool, although this new tool is disabled default. See below for more information.
  • The new db library offers a high-level, functional interface to popular relational database systems, including PostgreSQL, MySQL, and SQLite, as well as other systems via ODBC.
  • A new XREPL collection provides convenient commands for a plain racket REPL. It is particularly convenient for people who prefer console-based work and alternative editors. See also the new chapter on command-line tools and other editors at the end of the Racket Guide.
  • The plot collection has been reimplemented in Racket. It now offers PDF output, log axes, histograms, and more. Some code that uses plot will still work, and some will need light porting. The plot/compat module offers expedient backward compatibility.
  • DrRacket uses more conventional key bindings: C-t creates a new tab, C-w closes the current one, and C-r runs the definitions. On Mac OS X, the Command key is used. See “Defining Custom Shortcuts” in the DrRacket manual for an example that uses the old key bindings.
  • The new raco link command registers a directory as a collection, which allows the collection directory to reside outside the “collects” tree and without changing the PLTCOLLECTS environment variable.
  • Typed Racket:
  • Typed Racket provides static performance debugging support to show which code gets optimized and point out code that does not. Use the “Performance Report” button in DrRacket.
  • More intuitive types in printouts in the REPL and in error messages. Use :query-result-type to explore types, or :print-type for a full printout.
  • Typed Racket now supports defining function with optional arguments using the same syntax as Racket.
  • Redex now supports specifying (and testing and automatically typesetting) judgment forms including type systems and SOS-style operational semantics.
  • Fixed several GUI problems, including problems on Ubuntu 11.10 (GTK+ 3) and 64-bit Mac OS X.
  • Internal-definition expansion has changed to use let* semantics for sequences that contain no back references. This change removes a performance penalty for using internal definitions instead of let in common cases, and it only changes the meaning of programs that capture continuations in internal definitions. Internal definitions are now considered preferable in style to let.
  • Support for begin-for-syntax has been generalized; modules may now define and export both value bindings and syntax bindings (macros) at phase 1 and higher. Due to a bug, phase 1 syntax (or higher) is not available in DrRacket's #lang-based REPL. A simple workaround is to disable debugging in DrRacket (see “no debugging” radio button in detailed language dialog).
  • Additional Items:
  • The racket/gui library (and Slideshow) provides more support for multiple-screen displays.
  • DrRacket remembers whether an opened file used LF or CRLF line endings, and will continue using the same. When creating a new file, a preference determines how it is saved.
  • net/url can now follow HTTP redirections.
  • The LNCS and JFP class files are no longer distributed with Racket. Instead, they are downloaded on demand.
  • The Algol language implementation is now available as a plain language using #lang algol60.
  • The Racket-to-C compiler (as accessed via raco ctool or mzc) has been removed; Racket's JIT has long provided better performance, and the FFI provides better access to C libraries.
  • Contracts can be applied to exports with the new contract-out form within provide, instead of a separate provide/contract form. (The new contract-out form is implemented as a new kind of “provide pre-transformer”.)
  • The date* structure type is an extension of date with nanosecond and time-zone-name fields.
  • New looping constructs: for/sum and for/product.
  • Direct calls to keyword-accepting functions are now optimized to eliminate the overhead of keywords. In addition, the compiler detects and logs warnings for keyword-argument mismatches.
  • The libfit interface is available from plot/deprecated/fit, and will be removed in the near future.
  • The Unix installer has been re-done, and it is now more robust.
  • The built-in reader and printer support for Honu is removed. (This functionality is re-implemented in Racket.)

New in Racket 5.1.3 (Aug 16, 2011)

  • Bugfix release, resolving the DrRacket issue with the contour view.
  • In addition, two tex files with problematic licensing were removed.

New in Racket 5.1.2 (Aug 4, 2011)

  • The download page includes 64-bit installers for Mac OS X, Windows, and two Debian flavors. Racket now supports OS X Lion.
  • Racket now includes a new racket/place library to support parallelism, complementing racket/future. Racket's parallel build process is now based on places instead of multiple OS processes.
  • Places support share-nothing parallelism and message-passing communication. Compared to futures, places are heavyweight, but they have a simpler performance model.
  • The syntax-certificate system has been replaced by a syntax-taint system. Both certificates and taints were designed to protect otherwise inaccessible bindings from abuse when they appear in macro expansions. Taints are simpler and lighter, and the switch closes known holes in the certificate system. Macros that are not implemented with syntax-rules or define-syntax-rule, however, must explicitly use syntax-protect to protect their expansions from abuse.
  • The net/url library supports HTTPS connections, but beware that by default all sites are accepted (equivalent to ignoring a browser's warnings about untrusted certificates).
  • Error messages in the student languages use a simplified vocabulary and consistent phrasings. If you maintain curriculum material or teachpacks then please consider updating. See the “Error Message Composition Guidelines” section in the documentation for details.
  • Typed Racket: almost all core Racket data structures and operations are now accessible in Typed Racket (most of this work is due to prolific contributor Eric Dobson). The performance of the typechecker has been significantly improved.
  • The scriblib/bibtex library supports BibTeX-formatted citation databases in Scribble documents. BibTeX can be tricky to parse, so please report failed entries as bug reports.
  • The for forms now support an #:unless clause, and a nonnegative integer can be used as a sequence. The new compose1 function creates single-valued composition functions. The racket/function library now provides identity, thunk, and thunk*.
  • The license has been clarified: we now use LGPLv2.1 uniformly. (The license file used to specify LGPLv2, contrary to the download pages.)

New in Racket 5.1.1 (May 12, 2011)

  • The new racket/stream library provides stream-first, stream-rest, a lazy stream-cons, and so on. Streams are a subtype of sequences, so they work in for forms. Some sequence generators, such as in-range, now produce streams. A racket/sequence library replaces the old racket/stream library.
  • The new racket/syntax library contains facilities useful for writing macros. The new syntax/srcloc and syntax/location libraries provide support for manipulating source locations.
  • The racket/gui library now supports multi-column list boxes and scrolling panels.
  • The new ffi/file library is useful for writing foreign library bindings that cooperate with Racket's security guard mechanism.
  • Generators from the racket/generator library can now have formal arguments that are used when the generator is fired up.
  • Single-precision floating-point support is now enabled by default. Single-precision floats print differently from their default double-precision counterparts, new primitives convert between the two precisions, and new reader syntax supports single-precision literals.
  • JIT improvements include a small change to aid x86 branch prediction on function-call returns, which can speed up some programs significantly.
  • The Stepper can now step through Lazy Racket programs.
  • The racket/future library includes fsemaphore values, the future primitive no longer freezes futures (so a future can spawn new futures), and future log messages are more informative.
  • PLaneT development links are now version-specific.
  • The 2htdp/image library now includes overlay/align, underlay/align, overlay/align/offset and underlay/align/offset.
  • The network protocol for universes in 2htdp/universe has changed, so that v5.1.1 is incompatible with earlier versions.
  • The "DrScheme" application (which simply ran DrRacket in the last few releases) has been removed. The "MrEd" GUI executables for Windows and Mac OS X have also been removed, although the "mred" console executable remains for Unix and Mac OS X to support old scripts.
  • Typed Racket:
  • The numeric tower has been entirely overhauled. TR programs can now use more precise types than before, and check more numeric properties, such as sign or range properties.
  • Fixnum optimizations have been improved and should apply more broadly.
  • The performance of the typechecker has been improved. In particular, dispatch on large union types should typecheck much faster than before.

New in Racket 5.1 (Feb 15, 2011)

  • The racket/draw library—which implements the drawing half the GUI toolkit—can be used independent of the racket/gui/base library and without a graphics display (e.g., without an X11 connection). The new library has one small incompatibility with the old GUI toolbox: 'xor drawing is no longer supported. The new library has many additional features: rotation and general affine transformations, PDF and SVG drawing contexts, gradients, and alpha-channel bitmaps.
  • The GRacket executable is no longer strictly necessary for running GUI programs, because the racket/gui/base library can be used from Racket. To the degree that a platform distinguishes GUI and console applications, however, the GRacket executable still offers some additional GUI-specific functionality (e.g., single-instance support). The new racket/gui/base library includes small incompatibilities with the old GUI toolbox: the send-event, current-ps-afm-file-paths, and current-ps-cmap-file-paths functions have been removed. The racket/gui/base library re-exports racket/draw, so it includes the same drawing functionality as before (except for 'xor drawing).
  • The new racket/snip library can be used independently of racket/gui/base to work with graphical editor content (e.g., images in student programs). Like racket/draw, the racket/snip library is re-exported by racket/gui/base.
  • The Web Server includes a backwards incompatible change that prevents X-expressions and lists of bytes from being directly returned from servlets. This change will increase performance for those types of responses and allow easier experimentation with response types. Please see "collects/web-server/compat/0/README" in the installation to learn about porting your servlets forward. Don't worry. It's easy.
  • The new raco demodularize tool collapses a module's dependencies into a single module comprising the whole program. This transformation currently provides no performance improvement, but is the basis for cross-module optimization and dead-code elimination tools to come. The transformation is currently useful for static analysis of whole Racket programs.
  • The picturing-programs teachpack, formerly installed via PLaneT, is now bundled with the standard distribution. Use the teachpack with (require picturing-programs) instead of (require installed-teachpacks/picturing-programs). The old PLaneT-based installation procedure still works, but it now merely installs a stub that invokes the bundled version.
  • Slideshow picts, racket/draw bitmaps, and images created with 2htdp/image can now be used directly in Scribble documents. More generally, the new file/convertible protocol enables any value that is convertible to a PNG and/or PDF stream to be used as an image in a Scribble document.
  • The Same game sports a new look and an improved scoring system. (The current known high score is 12,429; can you beat that?)

New in Racket 4.2.5 (Apr 22, 2010)

  • a few more improvements to 2htdp/image
  • new language dialog, designed to encourage people to use the module language
  • the module browser shows the phases in which each module is invoked (in a new "long name" mode)
  • added alt-1 thru alt-9 as shortcuts to swap around between tabs