Racket Documentation

Acknowledgements

9.0.0.6

contents

Racket Documentation🔗ℹ

This is an installation-specific listing. Running raco docs (or Racket Documentation on Windows or Mac OS) may open a different page with local and user-specific documentation, including documentation for installed packages. Searching or following a “top” link will go to a different starting point that includes user-specific information. [Go to user-specific start] [Forget user-specific start]

Getting Started

Racket Cheat Sheet

Tutorials

Quick: An Introduction to Racket with Pictures

Continue: Web Applications in Racket

More: Systems Programming with Racket

Racket Language and Core Libraries

The Racket Guide

The Racket Reference

Package Management in Racket

The Racket Drawing Toolkit

The Racket Graphical Interface Toolkit

The Racket Foreign Interface

Scribble: The Racket Documentation Tool

DrRacket: The Racket Programming Environment

raco: Racket Command-Line Tools

Building, Distributing, and Contributing to Racket

How to Program Racket: a Style Guide

Teaching

How to Design Programs

How to Design Programs Languages

How to Design Programs Teachpacks

Essentials of Programming Languages Language

Programming Languages: Application and Interpretation

Picturing Programs Teachpack

Sprachebenen und Material zu Schreibe Dein Programm!

Category Theory in Programming

Other Languages in the Racket Environment

The Typed Racket Guide

The Typed Racket Reference

Datalog: Deductive Database Programming

envlang: an experimental language with first-class environments

Esterel in Racket

The Heresy Programming Language

The Pie Reference

The Pie à-let-mode Reference

PLAI Typed Language

Plaitypus Language

ProfessorJ: Java in Racket

Qi: An Embeddable Flow-Oriented Language

Rash: The Reckless Racket Shell

Shplait Language

SICP Collections

Sketching
A Language for Creative Coding

Zuo: A Tiny Racket for Scripting

Русский язык программирования Ади́на

How to Design Classes Languages

Tools

Fast-Xml: Simplified XML Parsing and Writing

Pure-Crypto: a pure crypto implementation for racket

Simple-Barcode: Barcode reader and writer

simple-qr: QR-Code Writer and Reader

Simple-Xlsx: XLSX File Reading and Writing

Web Applications in Racket

AWS S3 Synchronization

Cover: A test coverage tool

Cross-Compilation and Multi-Version Manager: raco cross

dbg: debug applications remotely

Denxi Documentation

Fast 1-D Haar Wavelet Transform

Futures Visualizer

Markdown To Scribble

Molis Hai: Natural Language Password Generation

PLaneT: Automatic Package Distribution

Portaudio: Bindings for the Portaudio portable sound library

protoc-gen-racket: Generate Racket Code for Protocol Buffers

Racket-Portage-Admin

raco fc: Finding Collections

Redex: Practical Semantics Engineering

Rhombus Slideshow: Figure and Presentation Tools

Scribble as Preprocessor

Slideshow: Figure and Presentation Tools

Sonic Pi: WORK IN PROGRESS

Web Server: HTTP Server

DrRacket Plugins

GUI and Graphics Libraries

Framework: Racket GUI Application Framework

Pict Snip: Build Snips from Picts

Pict: Functional Pictures

(part ("(lib geofun/tamer/geofun.scrbl)" "top"))

Browser: Simple HTML Rendering

Cards: Virtual Playing Cards Library

charterm: Character-cell Terminal Interface

Embedded GUI: Widgets Within Editors

Games: Fun Examples

GL Board Game: 3-D Game Support

GL: 3-D Graphics

gui-easy: Declarative GUIs

icns: Apple Icon Files

libnotify: an FFI binding for libnotify

A message% with ellipsis (...) to the left or right

MrLib: Extra GUI Libraries

Package rml-neural.

A pane to arrange controls in columns

Pict3D: Functional 3D Scenes

Plot: Graph Plotting

Rhombus Pict: Functional Pictures

Rilouworld: Decentralized Game Universe

rkt-tree-widget

RSound: A Sound Engine for Racket

RSVG: an FFI binding for loading SVG images

Scratchy: A Scratch-like Toy

Simple-Svg: Scalable Vector Graphics

String Constants: GUI Internationalization

Syntax Color: Utilities

Turtle Graphics

Network Libraries

(part ("(lib asni/tamer/tASN1.scrbl)" "top"))

(part ("(lib ssh/tamer/tSSH.scrbl)" "top"))

csexp: S-expressions over the network

Distributed Places

html-writing: Writing HTML from SXML

http-easy: a high-level HTTP client

Mac OS Native SSL: Secure Communication

Net: Networking Libraries

OpenSSL: Secure Communication

OSC: Open Sound Control Byte String Conversion

SASL: Simple Authentication and Security Layer

Unix Domain Sockets

Windows Native SSL: Secure Communication

Parsing Libraries

(part ("(lib css/tamer/css.scrbl)" "top"))

(part ("(lib png/tamer/png.scrbl)" "top"))

(part ("(lib psd/tamer/psd.scrbl)" "top"))

(part ("(lib sgml/tamer/sgml.scrbl)" "top"))

(part ("(lib stdc/tamer/stdc.scrbl)" "top"))

(part ("(lib svg/tamer/svg.scrbl)" "top"))

avro: Apache Avro

Binary-class/mp3: parsing ID3v2.1 and ID3v2.2

Binary-class: parsing and saving binary data

binfmt: binary format parser generator

CommonMark: Standard Markdown

csv-reading: Comma-Separated Value (CSV) Parsing

Extracting binary data from bytestrings using match

File: Racket File and Format Libraries

gemtext: A text/gemini parser for Racket

html-parsing: Permissive Parsing of HTML to SXML

HTML: Parsing Library

json-parsing: JSON Parsing, Folding, and Conversion

Megaparsack: Practical Parser Combinators

Parser Tools: lex and yacc-style Parsing

Parser Tools: lex and yacc-style Parsing (BR edition)

Protocol Buffers

Racket MIDI reader

Resource Interchange File Format (RIFF)

Sparse: Test Generation for Simple S-expression Language Parsers

TOML Config: Configuration Languages for Racket

WAVE File Format (WAV)

XML: Namespaces

XML: Parsing and Writing

Tool Libraries

choose-lang: Pick #lang at read-time

Choose-out: Conditional Provide

Colorblind Palette

Denxi Reference

Dynext: Running a C Compiler/Linker

Errortrace: Debugging and Profiling

Expeditor: Terminal Expression Editor

GLPK: The Gnu Linear Programming Kit

Intercepted Logging

Interface to GNU Aspell

Macro Debugger: Inspecting Macro Expansion

Make: Dependency Manager

Readline: Terminal Interaction

Scribble Abbrevs

Scribble: include text

Trace: Instrumentation to Show Function Calls

Version: Racket Version Checking

XREPL: eXtended REPL

Low-Level APIs

Inside: Racket C API

Interoperability

Interoperability Macros for roos and racket/class

Java Native Interface

MzCOM: Racket as a Windows COM Object

Protocol Buffers: Portable Data Serialization

Rhombus and Racket Interoperability

DrRacket Plugins

Files-viewer: a file manager plugin for DrRacket

Quickscript, a scripting plugin for DrRacket

Audio

3s: positional audio and mixing

Taglib Bindings for Racket

Benchmarks

Chess

Compression and Decompression

Zstandard - Fast real-time compression algorithm

Concurrency

Racket Coroutines

Data Structures

Arguments Structures

Condition Variables

Data: Data Structures

Double Linked Ring

Functional Data Structures in Typed Racket

Functional generic interfaces

Immutable Hash Array Mapped Tries

M-vars: Synchronized Boxes

Priority Queues

Scapegoat Trees

Semi-persistent Matrices

Semi-persistent Vectors

Simple, Deterministic Dictionaries

Simple, Deterministic Sets

Database

Functional Relational Algebra

Databases

(part ("(lib schema/tamer/schema.scrbl)" "top"))

DB: Database Connectivity

deta: Functional Database Mapping

Neo4j – Library for accessing Neo4j database

north: Database Migrations

Date, Time, and Calendar Libraries

Digital Ricœur

Digital Ricœur TEI Library

pydrnlp: NLP Library for Digital Ricœur

TEI Encoding Guidelines for Digital Ricœur

DrRacket Plugins

drracket-cmdline-args: Accessible Command-Line Arguments for DrRacket

drracket-wakatime

DrRacket Quickscripts

Dexter’s QuickScripts

Qi-Quickscripts

Email

Examples

Scribble Cheatsheet

Syntax Parse Examples

Git

Libgit2: Bindings for the libgit2 Git Library

Graphics

mode-lambda: the best 2D graphics of the 90s, today!

Hardware

Localization and Internationalization

CLDR BCP47 Time Zone Data

CLDR Dates for Modern Locales

CLDR Locale Names for Modern Locales

CLDR Numbers for Modern Locales

Logic programming

MiniKanren: logic programming in Scheme

Racklog: Prolog-Style Logic Programming

Machine Learning

Racket Machine Learning — Core

Racket Machine Learning — Decision Trees

Racket Machine Learning — K-Nearest Neighbors

Math and Science

(part ("(lib colorspace/tamer/colorspace.scrbl)" "top"))

Flomat: Floating Point Matrices

Parallelism

pmap : Parallel map

Performance

live-free-or-die: Freedom from Typed Racket

require-typed-check

Performance Tools

Contract Profiling

Feature-Specific Profiling

Optimization Coach

Profile: Statistical Profiler

Presentations

puresuri: the king of presentations

Resource Management

Disposable Values

Rhombus

Getting Started with Rhombus

Rhombus Reference

Rhombus Metaprogramming Reference

Rhombus Language Model

Rhombus Metaprogramming Tutorial

Scribble Libraries

acmsmall support for Scribble

Hyper-literate programming

LIPIcs support for Scribble

A Scribble Document Style for NSF Proposals

Scribble Enhanced

Scribble themes

scribble-code-examples

scribble-rainbow-delimiters

Scriblib: Extra Scribble Libraries

Slideshow LaTeX

Scripting

Scripty: Distributable shell scripts with dependencies

Slideshow Libraries

Progressive Picts and Slides

slideshow-text-style: a small library to improve text formatting in slideshow

Syntax Extensions

Mark Parameters

More Syntax Classes

Static Renaming

struct-define: Short-hand accessors for struct fields

Syntax: Meta-Programming Helpers

Teaching

Regex Machine Language

Terminal

lux-charterm: amazing terminal programs

Testing

Expect: First Class Assertions

Mock RackUnit Checks

Overeasy: Racket Language Test Engine

rackcheck: Property-based Testing

RackUnit Abbrevs

rackunit-chk: a short hand for writing rackunit tests

RackUnit: Unit Testing

Test Fixtures for RackUnit

Text block

UI

DOS: Delimited-continuation-based Operating-system Simulator

lux: brilliant interactive programs

raart: Racket ASCII Art and Interfaces

Verification

Temporal Contracts: Explicit Contract Monitors

Web Development

crontab: cron-like scheduling

Forms: Web Form Validation

koyo: Web Development Toolkit

Sentry Middleware for Koyo

site generator

typed-racket

Pure functions and promises

Struct type properties for Typed/Racket

Trivial: type-tailored library functions

Type expander library

Type expander: Implementation

Type inference helper for map

Miscellaneous Libraries

SRFIs: Libraries

The #%namespaced hook

#lang lindenmayer, a language for L-Systems

#lang rokit-racket

(eighth RacketCon) Workshop: Web Programming

4chan API Client Library

(part ("(lib digimon/tamer/digimon.scrbl)" "top"))

(part ("(lib dispatch/main.scrbl)" "top"))

(part ("(lib vector-struct/scribblings/vector-struct.scrbl)" "top"))

_-exp: Configurable Scribble-like Syntax

Access Path for Racket

ACL2s Beginner Mode

Adapton: Composable, Demand-Driven Incremental Computation

Adjutor: A Helper Library

Advent of Code: solutions & explanations

agatha: Para Logica

Age of Empires 2 Random Map Scripting

al2-test-runner – Alternative way of running rackunit test suites

alexis/util: Filling in the Gaps

The Algebraic Racket Collection

Amazon Web Services

amb-parser: Parser generator for ambiguous grammars

amb: Ambiguous Operator

Anaphoric macros

Anarki: Community-Managed Arc Variant

Another JSON I/O for Racket

ANSI Terminal Escape Codes.

ANU-Web-Quantum-RNG

AP Computer Science Principles Pseudocode

Apollo Art PEx Power Control

Argo: JSON Schema Adventures

array: Generic and Dynamic Arrays

Auto Rename Transformers

Automata: Compiling State Machines

backport-template-pr1514

barrel: A stack language meant for lists

Base64 Encoding and Decoding

BCP-47 compliant language tag predicates

Beautiful Racket

Beeswax: a Pollen-friendly template language

Behavioral Models

bencode: BitTorrent Bencode Decoding

Bestfit: Lines of Best Fit

binaryio: Functions for Reading and Writing Binary Data

bluetooth-socket

BoincRPC - Thin abstraction for BOINC’s Client RPC

Bookcover: Generating PDFs for book covers

box-extra: box utilities

brag: a better Racket AST generator

brazilian-law-parser

Brush: Literate Programming Without Tangling

buid: universally unique lexicographically sortable identifiers

Building Distributions of Racket

C Metaprogramming Utilities

canonicalize-path: Filesystem Path Canonicalization

ccnum: Credit Card Number Utilities

Chaining module languages

check-sexp-equal

chk: a minimal tester

Circular-Layout Reference

cli: Simple Command Line Interfaces

colon-kw and kw-colon

colormaps – Additional Colormaps for the Racket Plot Package

colors-as-strings

Combining syntax classes together as multiple variants

Compact Annotations

Compiler Goodies

cond: what it should have been

Config - File based configuration parameters

Constraint-satisfaction problems (and how to solve them)

Contract Miscellanea

Cookies: HTTP State Management

Counting Source Lines of Code

country: ISO country database

cpu-affinity: an FFI binding for getting/setting CPU affinity

cpuinfo: CPU Information

Creating PLT-Style Web Pages

Crypto: Cryptographic Operations

cs2500f16-jsonlab

CSS-expressions

CueCore Lighting Control

custom-load: Cautious Bytecode Loaders

Dallas—Science & Commerce with the D database language

Data Pipes (Iteratees)

data-red-black: augmented red black tree structures

Database URL Parser

Datastar Racket SDK

Debuging scope-related issues

decentralized-internet

defensive-to-contracts

Deferred: a simple library for doing things later

define-assets-from

define-attributes

define-match-spread-out

Delimited Reading

Delimiter-Sensitive Application

Derpy: Presentation Room Control

Diagrama: A diagram drawing library

Documentation Coverage

Dotted identifiers and λ<arg>.code syntax

DrRacket Version Tool

drracket-restore-workspace: Restore workspace for DrRacket

DSSL2: Data Structures Student Language

DSSL: Data Structures Student Language

Dynamic multiple dispatch

EBML: A binary encoding format

Elementary Continued Fraction Arithmetic Package

Elliptic Curves

Emoji: emoji terminal output for Racket

Enforestation with Macro Expansion

Enumerating Haiku

Envy: An environment variable manager

Epson Projector Control

Etl: Expresson Transformation Language

exact-decimal-lang

Expressions rendered as both XML and JSON

Expressive Functional Reactive Programming (Kinda)

Extensible Command Line

Extensible Functions

Extra SRFI Libraries

Extra Utilities for match

Fancy App: Scala-Style Magic Lambdas

Fast-convert: fast and easy conversion from bytes to string

Fig: Simple and Extensible Configuration

Finalizer: trivial finalization

Finding Racket Paths

First-order logic saturation with atom rewriting

fmt: an extensible code formatter for Racket

formatted-string

Fourier-Motzkin Elimination for Integer Systems

fragments-first

Function Composition Syntax

The Function Design Recipe

Functional Multi-Valued Computations

Functional RegExp

gdbdump: GDB-based Native Thread Backtrace Dumps

Generator Utilities

Generic Collections

Generic Flonums

Generic Relations

Generic Syntax Expanders

geoid – Efficient storage and queriying of geographic data

Gillette—XPath for Racket

Glass: Composable Optics

global: Global variables with command-line interaction

Glossary of Racket concepts

GLS: Generic Little System

GMB’s Lambda Calculus

GMP: Multi-precision Arithmetic

GNU GSL Numerical Integration

GNU GSL Random Number Generation

GObject Introspection

Goblins: a transactional, distributed actor model environment

google-spreadsheet-api

Graphics Engine

Graphite: a guided tour

Graphite: A data visualization library

Gref: Generalized References for Racket

Gregor: Dates and Times

Guard Statements

GUI ".plt" Installer

gui-widget-mixins

Happy App: A Toolbox of Syntactic Shortcuts

hash-view: Struct-like Views of Hashes

Help and Documentation Utilities

helpful: providing suggestions on unbound identifier error.

Hermit’s Heresy: DQB2 Power Tools

hostname: Getting Hostname, FQDN, and IP Addresses

htdp-json: A JSON library for use with HtDP

HtDP/2e Teachpacks for Typed Racket

html-examples: Examples in HTML

html-template: HTML-Writing Template Language in SXML

HTTP CONNECT Proxy

http123: HTTP Client

Immutable Struct Updates

Implementing HtDP Teachpacks, Libraries, and Customized Teaching Languages

Indiana University pict

inexact-number-lang

Infix Expressions for Racket

infix-prefix: a library to convert prefix expressions to infix and vice versa

INI File Parser and Writer

Interactive Brokers API

Interactive Evaluation in Slideshow

Interconfection

Interface-Oriented Programming for Classes

Internet Media Types

An Introduction to Redex with Abstracting Abstract Machines (v0.6)

IRacket: Racket Kernel for Jupyter

IRC Client Library

IRC Client: High-Level IRC API

IrRegular Expressions

JavaScript Engine for Racket

JavaScript for PLT Scheme

The jen Library

Jobsched: Running jobs with multiple Racket instances

JSON Web Token (JWT) and JSON Web Signature (JWS)

json-api package

json-pointer: Referring to bits of JSON

jsonic: because JSON is boring

Karp: A Language for NP Reductions

Keybinding Base Language

keyring: a library for uniformly accessing secrets

Kill-Safe Actors

kitco: Precious Metals Market Info. Access

lambda-calculus

Language creation

Laramie—HTML5 for Racket

Lathe Morphisms

ldap-ffi: a Racket LDAP client built on top of libldap C API

Legacy Generic Collections

Legacy Persistent Vectors

Lenses for Generic Collections

Lenses for Generic Collections

levenshtein: Levenshtein Distance Metric

Levin Tree Search with Context Models

Lexer and yacc examples

Libquiche - Miscellaneous Racket libraries

libserial: Portable Serial Port Access

libtoxcore-racket

license-audit: audit package licenses

Lightweight Stripe API Library

Lightweight, Lazy Trees

Linea: line oriented reader

linear-regression

linear-regression

Literate programming in style

Liturgical Calendar

Loess: local polynomial regression

Logical Notations

Logical Student Language

loop: advanced named let

lti-freq-domain-toolbox

macrotypes-nonstx

Magenc Magnet URIs: Secure Object Permanence for the Web

Making reader extensions hygienic

Malt - A minimalist deep learning toolkit

The Margrave Tool for Policy Analysis

McGill-style citations for Pollen

measures-with-dimensions

mediafile: Media File Metadata Utilities

memo: Memoization with cache and finalization control

MessagePack-RPC Client for Racket

Minimal ZeroMQ Bindings

Miscellaneous Functions for Racket

Miscellaneous Utilities

Mischief: a Racketeer’s Toolkit

Modern Macros: a talk given at PADL 2023

Monitoring file system activity with file-watchers

Monocle: a small lens library

monotonic: monotonic clock for Racket

Moon Rat Gardener

multi-file-lang

Multicast Asynchronous Channels

Multipath Daemon API

Multiple and Keyword Return Values

mutable-match-lambda

my-cond/iffy with sweet-exp

Nanopass Framework

Neovim client for Racket

Net2: Evolved Networking Libraries

Neuron: Decentralized Software Organisms

no-vert-bar-lang

noise: Perlin/Simplex noise generators

numformat-old: Number Formatting

numspell: Spelling Numbers as English

One-time passwords

OpenAL: Bindings for the OpenAL sound library

OpenCage Geocoding Client for Racket

OpenGL Mathematics (GLM) for Racket

The OpenGL Shading Language 4.5 (GLSL)

Option Contracts

Package Analysis

Package codepoint

Package Dependency Graph Visualization

Package Management GUI Libraries

Package parquet.

Package racket-locale

Package racket-scaffold

Package simple-oauth2.

Package thrift.

Packrat: Simple Packrat Parsing

Parameter Utilities

Paren-shape Pattern Expanders

pareto-frontier

Parsec implementation in Racket

parted: Interface to GNU Parted Disk Partion Utility

Pattern Matching for Ports

pdf-read: Read and render PDF files

Peony Web Framework

Persistent Vectors

PGMP: Profile-Guided Meta-Programming

A picture showing all the languages used to implement Racket.

Pinyin: Convert Hanzi to Pinyin

Pkg-Build: Building and Testing All Racket Packages

Place TCP Listener

PLAI Typed S-Sxpression Matching

plot-container – Embed plot snips to GUI applications

PLT Service Monitor

png-image: Library to view and modify PNG chunks.

Pollen Component

Pollen sample project: Typography for Lawyers

Pollen-rock: a RESTful Pollen Server

Pollen: the book is a program

Polysemy: support for polysemic identifiers

Polyvalent identifiers with multi-id

postfix-dot-notation

postnet: USPS POSTNET Barcode Encoding

pprint-compact: a non-greedy pretty printer

PPrint: A Universal Pretty-Printer

Presentation Big Bang

Pretty Printing JSON

pretty-expressive: a pretty expressive printer

Pretty-Printing Library for Racket

Pretty-printing with format strings

Processing of todo.txt tasks

profile-flame-graph

progedit: Programmatic File Editing

protobj: Prototype-Delegation Object Model

Purely Functional Struct Updaters

Puzzler: A Language for 2D Puzzle Game Creation

Python itertools... in Racket!

python-tokenizer: a translation of Python’s tokenize.py library for Racket

qtOps: perform operations on things with qualities

Quad: document processor

Quickscript Extra

quickscript-test

R-cade Game Engine

R16 — Community-Driven Interactive Code Evaluation

Racket Assembler

Racket bindings for the Linux inotify API

Racket Binutils

A Racket client for the Maelstrom distributed systems test harness

Racket Dropbox SDK

Racket Generic Binding Forms

Racket Generic Graph Library

A Racket GUI Widget to display maps based on OpenStreetMap tiles

Racket Language Server

racket-cord: Racket discord library

racket-langserver

Racket-Libansilove

Racket-MacroKey

racket-route-match

racket-tree-sitter

The RacketScript Language and Compiler

RacketScript Universe

RacketUI: Automated Web UI Generator

rackonsole: Lightweight Operator Console for Server Processes

Rackpropagator: Reverse-mode automatic differentiation of Racket programs

RackUnit Spec: BDD interface for RackUnit

raco-invoke: invoke raco commands

raco-pkg-env: virtualenv like tool for Racket

Racquel: An Object/Relational Mapper for Racket

ragg: a Racket AST Generator Generator

Rakka: Actor Model for Racket

RaList: Purely Functional Random-Access Lists

randstr: Random String Generator

Ranked Programming

The Raqet Manual

RDF Core Data Model

RDF Dublin Core Vocabularies

Reactor: a synchronous reactive language

Reader Function Literal Shorthand

Reading Writing ".DS_Store" Files

Reconstruct-Template

recspecs: Expect Testing for Racket

Recursive Language

Redex Miscellanea

Redex Parameters

Remember: storage for macros which is persistant across compilations

Remote Shells and Virtual Machines

Repeated application

Retry: Retrying Arbitrary Computations

Reverse Polish Notation

rex: deterministic regular expressions

RFC 6455 WebSockets for Racket

rfc3339-old: RFC 3339 Timestamps

Rhombus Cookies: HTTP State Manegement

Rhombus HTTP Client

Rhombus Parser Generator Tools

Rhombus Scribble

Rhombus SSL: Secure Communication

Rhombus URL and Form Parsing

RifL: a playing card stack language

rika: A static site generator

Rince: Racket-INtegrated C Environment

Riposte—Scripting Language for JSON-based HTTP APIs

Rival: Real Computation via Interval Arithmetic

roomba: iRobot Roomba/Create Interface

rparallel : Racket in parallel

rs - the Racket Sequencer

rs-l : Loop and event library for rs

Ruckus: Procedural CAD For Weirdos

rws-html-template: Racket Web Server html-template Support

rx-tx-async-channel

SASS: Bindings to libsass

Sawzall: A grammar for chopping up data

scgi: Web Server HTTP SCGI and CGI

Scheme+ for Racket

scope-operations

scramble: Assorted Utility Libraries

Scribble + LaTeX utils

Scribble Examples Evaluator Forms

scribble-frog-helper

scribble-slideshow: Using Scribble to Make Slides

Scriblogify: Scribble Your Blogs

Script: Testing Bitcoin Riddles

Scripts from the Quickscript Competition July 2020

Sdraw: Cons-Cell Diagrams with Pict

Search Filesystem While Approaching Root Directory

Search-list-box

SECD: A reduced version.

semaphore-utils

Semi-Persistent Arrays

Semver: Semantic Versioning

Sendinblue API Client

Seq: A Sequence Library

Serializing Syntax Introducers

Set Expressions

Set: Purely Functional Sets

Sfont: play with fonts in Racket

Shell Pipeline Package

shlex for Racket: Simple lexical analysis

shootout: Expression Performance Comparison

Shrubbery Notation

Shrubbery Rendering

Simple Function Specifications

Simple Matrix Arithmetic

Simple Polynomials of One Variable

Simple Tree Text Markup: Simple Markup for Display as Text or in GUI

slack-archive-viewer

SLIB/Common Lisp format for Racket

Snappy: FFI bindings for fast compression

Social Contracts

SOCKS5 TCP Client in Racket

Some utility functions around gregor

soundex: Soundex Hashing

Soup: A library of useful routines

Splitflap: Atom and RSS Feeds

SQL: A Structured Notation for SQL Statements

Squicky: a quick wiki parser

SRFI-105 "Curly Infix" for Racket

SRFI-110 "Curly Infix,Neoteric and Sweet expressions" for Racket

stardate: compute the current TNG stardate

stencil-vector-utils

stockfighter-api

Stream Miscellanea

stretchable-snip

String Searching Algorithms

String to S-expression for Fundamentals I, 2016, Northeastern University

string-interpolation

Struct-type properties with a struct-like interface

sudo: Sudo Command Processes

Suffix trees with Ukkonen’s algorithm

superv - A Supervisor Program

Support for date text-field% in racket/gui

Support for markdown in racket/gui text%

Sweet: an alternative to s-expressions

SXML in Racket: Tools for XML and HTML

SXML Misc Utilities

SXML: S-Expression Representation of XML

Symbolic algebraic expressions

syncvar: a library of synchronous variables

synology-decrypt

Syntax Implicits

Syntax Warnings

syntax-extension

SystemD Support

T-Test: two popular functions

Template Macros

Tessellation via GLU

Text and Paths for Pict3D

Text-tree output.

Threading Macros

Todo List for DrRacket

Trace Contracts

Translate X-Expressions to Keyword Procedure Applications

try-catch-finally

try-catch-match

try-make-sarna-happy

TUI Terminal Support

TUI Universal Buffers

Tuplet - a slightly silly drum sequencer

Turing: A Turing Machine language

Turn-Based Games

The turnstile language

txexpr: Tagged X-expressions

Typed SRFI 136: Extensible Record Types with Variance Annotations

typed-racket-datatype

typed-racket-eff

Typed-Stack: A Typed Racket stack library

tzgeolookup – Lookup timezone names for geographic coordinates

udiff: Unix diff compact-mode parser

ulid: universally unique lexicographically sortable identifiers

Unicode Break Algorithms

Units and Measurements

uri-old: Web URI and URL

uri-template: A template language for URIs (IETF RFC 6570)

Useful Tacit function

Using AppVeyor with Racket Projects

Utilities for composing functions in Typed Racket

Utilities for Manipulating Directories

uuid: Universally Unique Identifiers

Variable-Length-Input Benchmarks

Vector Struct: Performant Fake Structs

Version String With Git Hash

version-case: conditionally compile code based on current version number

vlc: VideoLAN VLC Media Player Control

Voxel Programming

Vulkan API Integration

Wavenet TTS API Interface

Web IO for Fundamentals I, 2016, Northeastern University

webapi: Web APIs

webscraperhelper: Generating SXPath Queries from SXML Examples

While loops for Racket

while/until loops for Racket

Wordle solver: A simple greedy solver for Wordle

WordNet - A Lexical Database for English

Write Large CLIs Easily

X.509 Certificates

XDG Basedir Library

Xenomorph: binary encoding & decoding

XML Expression Path Lookup

XMPP Connection

XMPP Core Functions

XMPP Error Functions

XMPP IQ (Info/Query) Functions

XMPP Service Discovery (XEP-0030)

YAML Syntax for Racket Languages

ZeroMQ: Distributed Messaging

Zippers for Racket

Experimental Languages and Libraries

FrTime: A Language for Reactive Programs

CA-DSL: A DSL for designing and visualizing cellular automata

ee-lib: Library Support for DSL Macro Expanders

Hosted miniKanren

iPoe: interactive poetry editor

Marker: A language for links

McFly Runtime: Embedded Package Documentation for Racket

R-LINQ: .NET’s LINQ in Racket

The Rosette Guide

syntax-spec: A Metalanguage for Hosted DSLs

syntax-spec: A Metalanguage for Hosted DSLs

syntax-spec: A Metalanguage for Hosted DSLs

Unstable Flonums: May Change Without Warning

Unstable GUI: May Change Without Warning

Unstable Redex: May Change Without Warning

Unstable: May Change Without Warning

Legacy Languages and Libraries

R5RS: Legacy Scheme

Scheme: Compatibility Libraries and Executables

Combinator Parser

Compatibility: Features from Racket Relatives

Graphics: Legacy Library

Legacy Print Convert

MysterX: Legacy Support for Windows COM

MzLib: Legacy Libraries

mzpp and mztext: Preprocessors

MzScheme: Legacy Language

Nonfree SRFI Specification Documents

Other

Denxi White Paper

contents