Racket

Racket is a general-purpose, multi-paradigm programming language descended from Scheme, but it is best understood as something more ambitious than “another Lisp.” From the start its designers treated the act of making languages as the central activity, and Racket grew into a full platform for what its community calls language-oriented programming: writing each part of a program in whatever notation fits it best, even inventing a new language for the job. Combined with a polished IDE, a large standard library, and decades of use in education, this makes Racket one of the most distinctive members of the Lisp family.

History & Origins

Racket began in January 1995 as PLT Scheme, the work of Matthias Felleisen’s PLT research group (the name traces back to “Programming Language Team”). The group’s first goal was pedagogic: to build a friendly, novice-oriented programming environment based on Scheme. Matthew Flatt assembled the original runtime — MzScheme, the command-line engine — and MrEd, a graphical layer cobbled together from libscheme, the wxWidgets toolkit, and other free software. On top of these, a team that grew to include Flatt, Robby Findler, Shriram Krishnamurthi, Cormac Flanagan, and many others built DrScheme, an approachable IDE for students.

The educational mission produced one of the project’s most enduring artifacts: How to Design Programs (HtDP), published by MIT Press in 2001. Rather than teaching a particular language feature by feature, HtDP teaches a design recipe — a systematic process for going from a problem statement to tested, well-structured code — using a tower of progressively richer “student languages.” This philosophy still shapes Racket’s beginner-friendly tooling and its outreach curricula.

From PLT Scheme to Racket

By the late 2000s, PLT Scheme had accumulated so many features beyond standard Scheme — a module system, a class system, contracts, custom languages — that the “Scheme” label no longer fit. On 7 June 2010, coinciding with the Version 5.0 release, the project was renamed Racket, and DrScheme became DrRacket. The rename signaled a deliberate identity: Racket would be a language and platform in its own right, free to evolve past the constraints of Scheme standardization. Shortly afterward, the GUI backend was rewritten in Racket itself, replacing the original C++ implementation with native toolkits on each platform.

Design Philosophy

Language-Oriented Programming

Racket’s defining idea is that a programming language is just another library you can build, ship, and import. Every Racket source file begins with a #lang line declaring which language it is written in:

1
2

#lang racket
(displayln "Hello, World!")

But #lang is open-ended. The same toolchain runs #lang typed/racket (statically typed), #lang scribble/base (a documentation language), #lang datalog (a logic language), and countless community languages — each with its own syntax, semantics, and reader. Racket gives language authors the macro system, module system, and IDE support to make these new languages first-class citizens rather than awkward embedded DSLs.

Macros as Infrastructure

Like other Lisps, Racket treats code as data and offers powerful hygienic macros. What sets it apart is how thoroughly macros are woven into the platform: entire languages are implemented as macro expansions down to a small core. The result is that ordinary programmers can extend the language’s syntax safely, and ambitious ones can build whole new languages without leaving the ecosystem.

Batteries Included

In contrast to minimalist Scheme, Racket ships a large standard library and tooling out of the box:

• DrRacket, a beginner-friendly yet capable IDE
• raco, a command-line tool for building, packaging, testing, and documentation
• Scribble, a documentation language used to write Racket’s own extensive docs
• A package system and online catalog for sharing libraries
• GUI, web-server, plotting, and FFI libraries in the main distribution

Key Features

Contracts

Racket includes a rich system of higher-order software contracts, an idea influenced by Eiffel’s design-by-contract. Contracts specify and enforce the obligations between modules at their boundaries, and — crucially — they work for higher-order values like functions:

1
2
3
4
5
6
7
8

#lang racket

(define/contract (deposit amount)
  (-> positive? void?)
  (void))

(deposit 100)   ; ok
(deposit -5)    ; contract violation blamed on the caller

When something goes wrong, Racket’s contract system assigns blame to the party that broke the agreement, making errors far easier to localize.

Gradual Typing with Typed Racket

Typed Racket is a sister language that adds statically checked type annotations while remaining fully interoperable with ordinary, untyped Racket. The two halves can call each other freely; type soundness across the boundary is preserved by compiling types into runtime contracts. Typed Racket is one of the most studied real-world implementations of gradual typing.

1
2
3
4
5
6

#lang typed/racket

(: square (-> Real Real))
(define (square x) (* x x))

(square 9)  ; 81

Proper Tail Calls and Functional Core

As a member of the Scheme lineage, Racket guarantees proper tail calls, supports first-class continuations, and encourages a functional style built around recursion, higher-order functions, and immutable data — while still offering mutation, objects, and other paradigms when needed.

Evolution

Racket’s most consequential technical change since the rename was a re-engineering of its runtime. For most of its history Racket ran on a bespoke virtual machine (now called Racket BC, “before Chez”). Beginning in earnest in the late 2010s, the team rebuilt the implementation on top of Chez Scheme, a mature, high-performance Scheme compiler. With Racket 8.0 (February 2021), this Racket CS implementation became the default, giving the language a more maintainable and generally faster foundation.

Development has continued steadily since. Racket 9.0 (November 2025) introduced parallel threads, a shared-memory threading model that lets suitable programs use multiple CPU cores, and Racket 9.2 followed in May 2026. The platform also continues to grow new languages: Rhombus, a project to give Racket a more conventional, non-parenthetical surface syntax while preserving its macro power, reached its 1.0 release in June 2026.

Current Relevance

Racket occupies a particular and durable niche. It is not a mainstream industrial language, but it is influential and actively maintained, with strongholds in:

• Education — through HtDP, DrRacket’s student languages, and curricula like Bootstrap
• Programming-languages research — as a platform for prototyping type systems, semantics, and new languages
• Publishing and tooling — via Scribble and Matthew Butterick’s Pollen
• Hobbyist and indie projects — including Hacker News, which still runs on the Racket-hosted Arc

The community gathers at the annual RacketCon, shares libraries through the package catalog, and develops the system in the open on GitHub.

Why It Matters

Racket’s lasting contribution is a demonstration that language design can be incremental and democratic. Instead of treating “the language” as a fixed substrate handed down by a committee, Racket makes building languages a routine engineering activity, supported by real tooling. Its ideas about macros, contracts, gradual typing, and language-oriented programming have rippled outward — into research, into teaching, and into other languages such as Pyret and Rust that drew on its work. For anyone interested in how programming languages are made, Racket remains one of the most rewarding systems to study.