RKT file format: History and versions

The release notes that Racket ships (the file HISTORY.txt of the Release Notes) record every version from MzScheme 0.27 in September 1995 to Racket 9.3. This page follows them. Dates are those of the notes: the release notes give 9.3 as July 2026, while the download page says August 2026.

The eras

Period	Name and numbers	What happened
1995 to 1999	MzScheme 0.27 to 0.x	The notes begin in September 1995 with a Scheme interpreter and an object system with multiple inheritance, `load-extension` for Windows DLLs, `quasiquote` re-implemented as a macro, and the `#%` names for core forms. The 0.41 release (April 1996) revised the class syntax and added the exception system. `hash-table-map`, regexps and `call-with-values` arrive in this period.
1999 to 2007	MzScheme and PLT Scheme, versions 100 to 372	100 (August 1999), 200 (June 2002), 299.x and 300 (2005), 350 to 372 (2006 to 2007); the notes record steady additions to the language and libraries. Version 370 (May 2007) made 3m the default memory manager and added `call-with-exception-handler` and `#%top-interaction`; 371 (August 2007) turned `#!` followed by a space or `/` into a general comment form; version 372 (December 2007) added `#lang`, with `require-for-label` and related forms.
2008 to 2010	PLT Scheme 4.0 to 4.2.5	The notes for 4.0 (June 2008) are in a separate file that I did not read. 4.1 added logging, structure type property inheritance and `in-value`.
May 2010	Racket 5.0	PLT Scheme is renamed Racket. The core executable changes from `mzscheme` to `racket`, paths such as the preferences file use `racket`, the default printer uses `quasiquote` style, and the language of the main module may set run-time configuration. Chaperones are added, and `regexp-match*` and other functions are changed so that `^` is relative to the whole input.
2011 to 2013	Racket 5.1 to 5.3.4	5.3 (August 2012) adds submodules (`module*`), `raise-argument-error` and its relatives, and a new format of error messages.
January 2014	Racket 6.0	Collections are reorganised into packages (`raco pkg`), with a new links file and package search path, `#%declare` added, and `racket/base` introduces a `configure-runtime` submodule. 6.1 (July 2014) made use before definition an error instead of producing `#<undefined>`, and removed `mzlib/class100`. 6.3 (October 2015) made substantial changes to the macro expander; 6.4 (January 2016) added incremental garbage collection; 6.10 (July 2017) split out the OS adapters as `rktio`.
July 2018	Racket 7.0	The macro expander is replaced by a new one written in Racket, and an initial implementation of Racket on Chez Scheme (Racket CS) appears in the source distribution.
2019 to 2020	Racket 7.1 to 7.9	7.4 disabled reading of single flonums by default (`read-single-flonum`, `single-flonum-available?`); 7.5 (November 2019) re-licensed Racket and most C code under permissive licences; 7.7 added embedding of Racket CS and switched its immutable hash tables to hash array mapped tries; 7.8 added unboxed flonum arithmetic in CS and AArch32 and AArch64 support, with places and futures (not in BC).
January 2021	Racket 8.0	Racket CS becomes the default variant. Support for Apple Silicon was added, `#%declare #:unsafe`, the `'os*` and `'arch` modes of `system-type` and the wraparound fixnum operations.
2021 to 2025	Racket 8.1 to 8.18	See the table below.
October 2025 on	Racket 9.0 to 9.3	See the table below.

Racket CS and Racket BC

Racket has two implementations, called variants. (system-type 'vm) says which: it produces 'racket for BC (the Reference says so in its text on single flonums), and another symbol, which I believe is 'chez-scheme, for CS.

Racket BC ("Before Chez", also called 3m, with an older conservative-collector build called CGC) is the original C implementation with its own bytecode compiler and a JIT. It was the only variant until 7.0 and the default until 8.0, and it is still maintained: the release notes of 9.1 list a BC change to intern all characters.
Racket CS ("Chez Scheme") runs on Chez Scheme: the Racket macro expander (itself written in Racket since 7.0) and much of the runtime are compiled to machine code by the Chez Scheme compiler. It was started as an experiment in 7.0, became the default in 8.0, and is the one that new work targets. Compiled .zo files are machine-code linklets, so they are specific to a platform; the Unix-style installation puts them in lib and not share since 8.1.

Difference	BC	CS
Single flonums (`1.0f0`)	supported (reading them is off by default since 7.4)	not supported: `(single-flonum-available?)` is false
Extflonums (`1.0t0`)	depends on the platform	as far as I know, not supported (from memory)
Futures and places	futures on Windows, Linux and macOS on x86; places by default on x86 platforms	futures and places on all platforms that CS supports (including AArch32 and AArch64)
Parallel threads (`thread #:pool`, from 9.0)	do not run in parallel	run in parallel
Fixnum size	the Reference gives 30 or 31 bits on a 32-bit platform and 61 or 63 bits on a 64-bit one, depending on the variant, without saying which variant has which
Characters	all characters are interned since 9.1, so `eqv?` implies `eq?`	the notes name this only as a BC change

Programs written for one variant almost always run on the other; the differences matter for code that relies on single flonums, extflonums, the exact fixnum range or the speed of particular operations, and for foreign-function code. The viewer treats both the same.

Racket 8 and 9, release by release

Each entry gives the changes that the release notes name; "other bug repairs" are left out. The versions are on a quarterly schedule: January, April, July, October.

Version	Date	Changes to language, libraries and tools
8.0	Jan 2021	Racket CS the default; Apple Silicon; `#:unsafe` for `#%declare`; `fx+/wraparound` and similar; parallel GC and other CS improvements
8.1	Apr 2021	ephemeron hash tables; `git+https://` package sources, and the default branch for Git packages; cross-compilation support in `raco exe` for CS
8.2	Jul 2021	`most-positive-fixnum` and `most-negative-fixnum`; layered and tethered installations; faster exact rational arithmetic in CS
8.3	Oct 2021	expander: `require` and `provide` support binding spaces; syntax arming and disarming replaced by protected syntax operations; internal-definition contexts track their own use-site scopes; `error-syntax->string-handler`
8.4	Jan 2022	`file-or-directory-stat`; "portal" syntax; the `#%terminal` primitive module, with `xrepl` and `expeditor` giving an improved REPL by default; `set/c` supports random generation
8.5	Apr 2022	`-y`/`--make` flag to compile as needed; error-message realms; `read-syntax-accept-graph`; `#:splice` clauses in `for`; keyword arguments for `make-temporary-file`; the `pb` back end
8.6	Jul 2022	`equal-always?`; stencil vectors; the build uses Zuo; Arm64 Windows
8.7	Oct 2022	Unicode 14.0; grapheme operations (`string-grapheme-count`); `(#%declare #:require=define)`; RISC-V
8.8	Jan 2023	`#:param` option for `->i`; permission arguments for `copy-file`
8.9	Apr 2023	Unicode 15.0; `racket/hash-code`; `configure-expand` submodules; multiple values in `stream-cons`; results clause for `define-values/invoke-unit`
8.10	Jul 2023	`immutable-string?`, `mutable-string?` and the like for bytes, vectors, boxes and hashes; fxvectors and flvectors allowed in `fasl` and compiled code; `syntax-parse` interprets patterns outside syntax classes
8.11	Oct 2023	`#:do` option in `match` clauses; `#:indent` for `write-json`
8.12	Jan 2024	`hash` and `hash*` patterns in `match`; `racket/case` (`case/equal-always` and relatives); `vector-set/copy`; `pregexp-quote`
8.13	Apr 2024	`racket/treelist` and `racket/mutable-treelist`; `contract-in`; `hash-filter-keys` and `hash-filter-values`; `vector-extend`; Unicode 15.1
8.14	Jul 2024	`case-λ` and `match-λ`; `λ` made `free-identifier=?` to `lambda`; the `compiler/demod` language; `hash-filter`; `#:flatten-requires` and `#:unlimited-compile` for `#%declare`; `raco/testing`
8.15	Oct 2024	"language family" in documents, with search filters; `'ios` as a compilation target; `raco pkg uninstall` preferred to `remove`
8.16	Jan 2025	more treelist functions; `\X` (grapheme cluster) in `pregexp`; `port-file-stat`; `pipe-port?`; `open-input-nowhere`; `read-json` and `write-json`; `racket/serialize-structs`
8.17	Apr 2025	`bitwise-first-bit-set`; a syntax-thunk argument for `dynamic-require`; `error-module-path->string-handler`; the package manager accepts a file URL with no checksum file
8.18	Jul 2025	`struct` supports `#:properties`; Unicode 16.0; faster `expt` on a flonum to a large exact power; container builds for all platforms
9.0	Oct 2025	CS: parallel threads through `thread`'s `#:pool` argument, results kept by `#:keep`, more primitives allowed in futures; `black-box`; `decompile-linklet`; AArch64 package support
9.1	Jan 2026	language-family navigation in the documentation; `exn-classify-errno`; `#:on-length-mismatch` in `for`; `make-struct-type` accepts `'current` as its inspector; `openssl/legacy`
9.2	Apr 2026	`match` rejects non-linear patterns with mismatched ellipsis depth; the `#%foreign-inline` core form; faster `object/c`; Unicode 17.0; several `racket/private` modules reorganised and `member`, `when`, `unless`, `let/ec` and `cond` rewritten on `racket/kernel` syntax
9.3	Jul 2026	`racket/base` simplified to fewer internal modules; `raco pkg install` flags `--adjacent-deps`, `--destdir`, `--attach`; `error-syntax->srcloc-handler`; `ffi/unsafe/runtime-lib`; configurable compression in `file/zip`

Language changes that matter for source files

#lang exists since version 372 (December 2007); before it a module began (module name lang …). The notes of 5.3 say that for most languages #lang can no longer be nested.
Keywords (#:key) were in the language by 371, which added keyword<? and make-derived-parameter.
.ss was the module extension of PLT Scheme; Racket reads a .ss suffix in a require path as .rkt, and uses .rkt for its own files. The r5rs and r6rs languages use mutable pairs.
Use before definition is an error since 6.1; before it gave #<undefined>.
#%declare is from 6.0; #:unsafe from 8.0, #:require=define from 8.7, #:flatten-requires and #:unlimited-compile from 8.14.
Printing. From 5.0 the default printer uses quasiquote style.
Reading. \X in regexps from 8.16; hash patterns in match from 8.12; #:splice in for from 8.5; case-λ from 8.14.

Not described

Known, not yet covered

Reference: the release notes were read in full for the dates and one-line changes above; the details of each change are in the documentation's history notes, which were not read. Releases before 5.0 are summarised, not listed. The table of Racket CS and BC differences is limited to what the notes and the Reference state; the memory model, the performance profile, and the JIT and the compilation modes of each variant (machine-code, interpretable, PLT_CS_COMPILE_LIMIT and the rest) are not described.
Reference: the claim that Racket CS does not support extflonums is from memory, as the cell above says. The name 'chez-scheme for the CS value of (system-type 'vm) is also from memory.
Reference: the Racket 4.0 and earlier notes live in other files (MzScheme_4.txt and older) that were not downloaded; only the main HISTORY file was read.

.RKT File Format – History and versions