Softpedia >Windows >Programming >Other Programming Files >Racket >  Changelog

Racket Changelog

What's new in Racket 8.12

Feb 8, 2024
  • Change `open-input-file`, `open-output-file`, and `subprocess` on variants of Unix and Mac OS where O_CLOEXEC is supported to open files with that flag and to refrain from closing all file descriptors (without O_CLOEXEC) in `subprocess`
  • Add support for `hash` and `hash*` patterns in `match`
  • Add `vector-set/copy` to `racket/vector`
  • Add `pregexp-quote`
  • Add `convention:hyphen->{Pascal,camel}Case` FFI conventions
  • Add `racket/case` with `case/equal-always` and related forms
  • Add configured build stamp to `banner` result
  • Change treatment of shadowing for a `for/fold` accumulator variable by an iteration clause
  • Change `PLT_LINKLET_SHOW` and variants to write to error port, and adjusted the output format
  • Add partial support for static generation of foreign-function bindings

New in Racket 8.11.1 (Nov 30, 2023)

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

New in Racket 8.11 (Nov 14, 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#%28mod-path._racket%2Fmutability%29)
  • Redex adds judgment-form->rule-names (cf. https://docs.racket-lang.org/redex/reference.html#%28def._%28%28lib._redex%2Freduction-semantics..rkt%29._judgment-form-~3erule-names%29%29)
  • 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#%28idx._%28gentag.55.%28lib._scribblings%2Ftools%2Ftools..scrbl%29%29%29)
  • 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 (Aug 16, 2023)

  • As of this release:
  • 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#%28part._beginner-abbr-signatures%29)
  • 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#%28mod-path._racket%2Fhash-code%29)
  • 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#%28part._configure-expand%29)
  • stream-cons supports multiple values. (cf. https://docs.racket-lang.org/reference/streams.html#%28form._%28%28lib._racket%2Fstream..rkt%29._stream-cons%29%29)
  • 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#%28form._%28%28lib._racket%2Funit..rkt%29._unit%2Fc%29%29)
  • 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#%28def._%28%28lib._racket%2Fprivate%2Fclass-internal..rkt%29._dynamic-instantiate%29%29)
  • TCP output block buffering implies TCP_NODELAY. (cf. https://docs.racket-lang.org/reference/tcp.html#%28def._%28%28lib._racket%2Ftcp..rkt%29._tcp-connect%29%29)
  • 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 (May 10, 2023)

  • As of this release:
  • 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#%28form._%28%28lib.racket%2Fcontract%2Fbase..rkt%29.-~3ei%29%29 )
  • The copy-file library function supports permission-management arguments. (See: https://docs.racket-lang.org/reference/Filesystem.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._copy-file%29%29 )
  • Pressing <SHIFT>-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.6 (Nov 14, 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#%28def.%28%28quote.~23~25kernel%29._equal-always~3f%29%29
  • 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#%28form._%28%28lib._redex%2Freduction-semantics..rkt%29._substitute%29%29
  • 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#%28part._safety-limits%29
  • 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#%28def._%28%28lib._db%2Futil%2Fpostgresql..rkt%29._pg-custom-type%29%29
  • The release includes many other repairs and changes!

New in Racket 8.5 (May 1, 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 9, 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!

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 5, 2021)

  • Racket version 8.1 is now available from https://racket-lang.org/:
  • 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.
  • The following people contributed to this release:
  • Alex Harsányi, Alex Knauth, Alexander Shopov, Alexis King, Andrew Mauer-Oats, Anish Athalye, Ben Greenman, Bert De Ketelaere, Bob Burger, Bogdan Popa, Brian Adkins, Cameron Moy, David Van Horn, Dexter Lagan, Dominik Pantůček, Fred Fu, Greg Hendershott, Gustavo Massaccesi, Hazel Levine, Ismael Luceno, Jack Firth, Jarhmander, John Clements, Jörgen Brandt, Laurent Orseau, Lazerbeak12345, Matthew Flatt, Matthias Felleisen, Micah Cantor, Mike Sperber, Noah Ma, Patrick McCarty, Paulo Matos, Pavel Panchekha, Philip McGrath, Philippe Meunier, R. Kent Dybvig, Robby Findler, Ryan Culpepper, Ryan Kramer, Sam Tobin-Hochstadt, Sergiu Ivanov, Shu-Hung You, Sorawee Porncharoenwase, Stephen De Gabrielle, William J. Bowman, bmitc, xxyzz, yjqww6, and ymdarake.

New in Racket 8.0 (Feb 14, 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.

New in Racket 7.8 (Aug 3, 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](https://github.com/racket/web-server/pull/94/).
  • 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 2, 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.
  • The call-with-current-language form 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 (Feb 14, 2020)

  • 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 (Nov 20, 2019)

  • Disabled single-flonum reading by default and added `read-single-flonum` and `single-flonum-available?`
  • Bug repairs and other changes noted in the documentation

New in Racket 7.3 (Aug 9, 2019)

  • Bug repairs and other changes noted in the documentation

New in Racket 7.2 (Jan 31, 2019)

  • Bug repairs and other changes noted in the documentation

New in Racket 6.12 (Jul 28, 2018)

  • Bug repairs and other changes noted in the documentation

New in Racket 6.11 (Jan 27, 2018)

  • Bug repairs and other changes noted in the documentation

New in Racket 6.10.1 (Sep 29, 2017)

  • Extract OS adapters to the "rktio" library

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.
  • 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.
  • edu: big-bang supports a display-mode clause so that world programs can take over the entire screen.

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 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 Dvor(á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)

  • Changed use-before-definition to be an error instead of producing an # value
  • Removed the mzlib/class100 library

New in Racket 6.0 (Feb 27, 2014)

  • Packages & collections:
  • Reorganized collections into packages
  • Added 'config-dir mode for find-system-path
  • Added PLTCONFIGDIR environment variable and -G/--config flag
  • Removed -C/--links command-line flag
  • Added links-file and links-search-dirs to config, enabling a search path of installation-wide link files, as well as pkgs-dir and pkgs-search-dirs
  • Changed link-file handling to separate "user" and "shared" modes;
  • removed 'links-file mode for find-system-path, PLTLINKSFILE environment variable, and -C command-line argument
  • Removed "shared" links and package scope
  • Add current-library-collection-links, find-library-collection-links
  • Changed module search to use current-library-collection-paths before collection link files by default
  • Changed use-user-specific-search-paths and use-collection-link-paths to affect only find-library-collection-paths and find-library-collection-links
  • Added "share" directory, moved "pkgs" there
  • Base user directoy paths on an installation name instead of the Racket version string
  • Runtime:
  • Added ARM support to JIT
  • Added #% declare
  • Cross-phase persistent modules must be declared with (#% declare #:cross-phase-persistent)
  • Add configure-runtime submodule support, and changed racket/base to introduce a configure-runtime submodule
  • Removed memq, memv, and member from #%kernel
  • Filesystem and environment variables:
  • Changed initialization of current-directory to use PWD
  • Added current-environment-variables, environment-variables-ref, environment-variables-set!, environment-variables-names, environment-variables-copy, bytes-environment-variables-name?, string-environment-variables-name?, environment-variables?, and make-environment-variables
  • Added current-directory-for-user, srcloc->string
  • Added filesystem-change-evt, filesystem-change-evt?, and filesystem-change-evt-cancel
  • Added 'fs-change mode to system-type
  • Move explode-path from racket/path to racket/base
  • Changed read-on-demand-source to support #t
  • Added current-module-path-for-load, exn:fail:syntax:missing-module, exn:fail:filesystem:missing-module, prop:exn:missing-module, exn:missing-module?, and exn:missing-module-accessor
  • Changed string->path-element and bytes->path-element to raise an exception for an empty [byte-]string argument
  • Changed path-replace-suffix to raise an excpetion when a path element would be made empty
  • Changed syntax-local-lift-context to distinguish top-level environments
  • Datatypes:
  • Added hash-clear, hash-copy-clear, hash-clear!, and hash-empty?
  • Allow hash table chaperones and impersonators to support efficient hash-clear and hash-clear!
  • Added path

New in Racket 5.3.6 (Aug 12, 2013)

  • Racket v5.3.6 is a 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.
  • 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.
  • 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).
  • 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)

  • This is a 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)

  • 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.
  • 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.
  • 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 have also been removed

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

New in Racket 5.0.2 (Nov 8, 2010)

  • Typed Racket's optimizer is now turned on by default; error messages have been simplified and clarified.
  • Contracts: contracts on mutable containers allow functions or other higher order values, and contracts are checked when updating or dereferencing the containers. The new contracts are slower than the old ones, so the old check-once functionality is still available.
  • A new dependent function contract combinator, ->i, properly assigns blame for contracts that violate themselves and the generated wrappers are more efficient than ->d. (Although it does more checking so your contracts may be faster or slower).
  • See the docs for box/c, hash/c, vector/c, vectorof and ->i for more details.
  • The when, unless, cond, case, and match forms (in racket/base and derived languages) now allow immediate internal definitions.
  • Web server: the formlets library provides more HTML form elements; make-xexpr-response supports a preamble for DTD declarations; serve/servlet supports stateless servlets.
  • New WebSocket implementation, see net/websocket for details.
  • The new data collection contains implementations of several data structures, including growable vectors and order-based dictionaries.
  • racket/match is now significantly faster.
  • The Racket documentations are built in parallel by default.
  • The stepper is now compatible with programs using the Universe teachpack.
  • 2htdp/image: pinholes are now supported in the library (if you don't use pinhole primitives you will not see them); a number of new triangle functions added; supports conversion of images to color lists and back. Also, cropping has been improved for scenes; see the documentation section on the nitty-gritty of pixels for details.
  • Signatures have been moved to ASL, BSL, BSL+, ISL, and ISL+ (HtDP teaching languages) no longer support checked signatures.
  • Student languages: one-armed check-error in all levels; ASL is extended with hash operations, and define-datatype.
  • DMdA languages: Checking for parametric signatures is now eager. This catches errors earlier, but retains the asymptotic complexity properties; signatures for record types now have generators; list-of and any signatures are now provided.

New in Racket 5.0.1 (Aug 4, 2010)

  • Datalog is a lightweight deductive database system with Racket integration. It is now available in the datalog collection and with #lang datalog.
  • Racklog provides Prolog-style logic programming in Racket, adapted from Dorai Sitaram's Schelog package. It is available in the racklog collection and now as #lang racklog.
  • By default make install and raco setup compile collections in parallel on all available processors. (Use raco setup -j 1 to disable, if necessary.)
  • Changes (as part of 5.0) in the racket language compared to the scheme language: constructor-style printing, a struct alternative to define-struct that fits more naturally with match and constructor-style printing, bytecode-dependency management via SHA-1 hashes instead of just timestamps (where the openssl/sha1 library provides the SHA-1 hash function), a reorganization of scheme/foreign into ffi/unsafe and associated libraries, and new printing functions eprintf and displayln. Also, a generator from racket/generator is required to have the form (generator () body ...), which supports a planned extension to let a generator accept arguments.
  • Changes to the racket language (since 5.0): internal-definition positions allow mixing expressions with definitions, full continuations can escape past a continuation barrier, custodians can attempt to terminate subprocesses and subprocess groups (see current-subprocess-custodian-mode, subprocess-group-enabled), the JIT supports additional unboxing flonum operations and unsafe variants, ffi/unsafe provides an asychronous-call mechanism to deal with foreign threads, a new "." modifier for format string directives (e.g., "~.s" and "~.a") limits the respective output to (error-print-width) characters.
  • The core type system of Typed Racket has been substantially revised. In particular, Typed Racket can now follow significantly more sophisticated reasoning about the relationships between predicates. Additionally, Typed Racket now allows variable arity types in more places, allowing programmers to specify variable-arity lists.
  • We are working on an optimizing version of Typed Racket that takes advantage of type information for certain classes of programs. This project is a work in progress. For those interested, see the documentation for #:optimized.
  • The web-server/formlets library adds a formlet* form that allows dynamic formlet construction, as opposed to formlet which requires syntactic Xexprs and static formlets. Several new library formlets are added.
  • The syntax/parse library has new support for matching literals at different phases using the #:phase argument for literals and literal sets.
  • RackUnit now includes a GUI test runner as rackunit/gui.
  • The 2htdp/image library now includes flip-vertical and flip-horizontal operations that mirror images (vertically and horizontally).

New in Racket 4.2.5 (Apr 6, 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

New in Racket 4.2.4 (Jan 29, 2010)

  • the 2htdp/image library changed:
  • changed how equality works (it is now based on how the
  • images draw, instead of on an underlying algebra
  • of images)
  • added cropping and curves
  • overlay, beside, and above now line things up on
  • centers, rather than upper lefts
  • added scene-related funtions (place-image, scene+line, etc)
  • added support for drawing with various kinds of pens

New in Racket 4.2.3 (Dec 1, 2009)

  • minor bug fixes

New in Racket 4.2.2 (Oct 5, 2009)

  • DrScheme now (by default) automatically compiles your source files, saving them in the compiled/drscheme/ subdirectory.
  • Syntax coloring now works for languages using the @-reader ie, Scribble)
  • The yellow message in the interactions window is now moved to be part of the DrScheme frame.
  • The module browser now shows the phases that each given module is invoked in.
  • Check Syntax colors set!'d variables in dark red.

New in Racket 4.2.1 (Jul 30, 2009)

  • The module browser used to treat any non-string require as "libraries", where they can all be hidden or not. Now this does not include requires from the same "package", where a package is defined as a toplevel collection or a planet collection. This means that requiring a file from your own collection is just as convenient to do (wrt the module browser) using the normal symbolic form.

New in Racket 4.2 (Jun 2, 2009)

  • Minor bug fixes

New in Racket 4.1.5 (Mar 22, 2009)

  • Web Server:
  • new URL-based dispatching library `web-server/dispatch',
  • customizable continuation serialization policies for the stateless web language `web-server / stuffers',
  • abstraction of serve/servlet to build simpler dispatchers `web-server/servlet-env',
  • HTTP Digest authentication support `web-server / http / digest-auth',
  • built-in cookie support in `web-server / http / cookie' and `web-server / http / cookie-parse',
  • highlighting and pretty-printing of errors in Xexpr constructions,
  • load control dispatcher for limit concurrent sessions `web-server / dispatchers / limit'.
  • Scribble:
  • Literate programming is now available using the new `scribble/lp' language.
  • A new `at-exp' language makes it convenient to use the scribble reader's @-expressions for general code.
  • The `scribble/text' preprocessor language has been extended to deal with indentation and other formatting issues.
  • The "scribble" command-line tool accepts a `--pdf' flag to render PDFs (via pdflatex).
  • DrScheme now provides feedback when PLaneT downloads and installs new packages.
  • Units & Contracts:
  • Elements of unit signatures can now be associated with contracts via the `contracted' signature form.
  • A contract combinator for units, `unit/c', has been added.
  • The new `with-contract' form provides a nestable submodule contract boundary, protecting a group of definitions from the surrounding code with contracts.
  • The `define/contract' form has been reworked and new define forms have been added: `define-struct/contract' and `define-unit/contract'.
  • Language levels and teachpacks
  • Misc:
  • Typed Scheme now comes with several more pre-wrapped libraries, found in the `typed' collection.
  • The `xml' and `html' collections are now contracted.
  • Binding parsing in net/cgi now interacts with `net/uri-codec's configuration parameters.
  • DrScheme captures logging output.
  • Check syntax: it is now possible to tack arrows crossing the currently selected text.
  • New `bitwise-bit-field' function.
  • The usual pile of bugfixes. (Notable: `scheme/package' works,`deflate' compression fixed, DrScheme language dialog issue resolved, `match' fixes, Windows networking, and much more.)

New in Racket 4.1.4 (Jan 21, 2009)

  • got rid of drscheme:debug:profiling-enabled in favor of errortrace/errortrace-lib's profiling-enabled
  • minor bug fixes

New in Racket 4.1.3 (Nov 21, 2008)

  • Documentation rewritten to separate servlet APIs and server extension APIs
  • HTTPS supported on the "plt-web-server" command-line with
  • "--ssl'option
  • Stateless servlets supported in default configuration through "stateless interface-version`web-server/servlet-env" supports top-level servlets through #:servlet-path
  • Servlets are served from anywhere in the htdocs directory by default
  • A template system based on the Scribble syntax has been added, see web-server/templates in the documentation