64 Colors

9.3

Racket

64 Colors🔗ℹ

package: animate

animate/colors provides literal colors plus immutable palette, role, categorical-series, mix, and alpha specifications. A palette or role token is a description of a color to resolve under an explicit immutable theme; it is not a drawing color. Existing literal color strings such as "teal" and "crimson" keep their literal meaning. Animate recognizes names from its own fixed, case-insensitive X11-style table; it never asks the host drawing backend to interpret a name. Use a hexadecimal literal or rgb-color when you need a color that is not in that table.

procedure
(literal-color-spec? value) → boolean?
value : any/c

Returns #t for an rgba-color or a supported literal color string. It does not treat a palette key string as a token.

procedure
(rgb-color red green blue) → rgba-color?
  red : (and/c finite-real? (>=/c 0) (<=/c 255))
  green : (and/c finite-real? (>=/c 0) (<=/c 255))
  blue : (and/c finite-real? (>=/c 0) (<=/c 255))

Creates an opaque literal sRGB color. It is a fixed color rather than a palette or theme reference, so it resolves identically in every theme.

procedure
(palette-color key) → color-token?
key : symbol?

Constructs an immutable reference to a canonical lowercase, hyphenated palette key. The family and neutral aliases documented below normalize to their canonical entries. A custom canonical key is allowed; the selected theme validates whether it has a supplied swatch. The key must be a nonempty interned symbol; uninterned and unreadable symbols are rejected because their identity cannot survive a theme-file or worker boundary.

procedure
(role-color key) → color-token?
key : symbol?

Constructs an immutable reference to a nonempty semantic role key. Use it for a custom role; the theme-... bindings below are the standard roles. The key must be a nonempty interned symbol for the same portable-data reason as a palette key.

procedure
(series-color index) → color-token?
index : exact-nonnegative-integer?

Constructs a stable zero-based categorical-series reference. It does not use a mutable “next color” counter. At resolution, the selected theme’s nonempty series is indexed with explicit wraparound, so (series-color 8) has the same category as (series-color 0) for the built-in eight-color series. Use a stable dataset/category order to choose indexes.

procedure
(color-token? value) → boolean?
value : any/c

Recognizes a palette, semantic-role, or categorical-series color token.

procedure
(color-token-kind token) → (or/c 'palette 'role 'series)
token : color-token?

Returns the token namespace.

procedure
(color-token-key token) → symbol?
token : color-token?

Returns the token’s normalized palette key or semantic-role key. Passing a categorical-series token raises an argument error; use series-color-index for that kind.

procedure
(series-color? value) → boolean?
value : any/c

Recognizes a categorical-series token.

procedure
(series-color-index token) → exact-nonnegative-integer?
token : series-color?

Returns the original authored index, before resolution applies the selected theme’s explicit wraparound.

procedure
(color-expression? value) → boolean?
value : any/c

Recognizes an unresolved color mix or alpha expression.

procedure
(color-mix from
to
amount
[ #:space space
#:alpha-mode alpha-mode]) → color-spec?
  from : color-spec?
  to : color-spec?
  amount : (and/c finite-real? (>=/c 0) (<=/c 1))
  space : (or/c 'srgb 'srgb-linear 'oklab) = 'srgb-linear
  alpha-mode : (or/c 'premultiplied 'straight) = 'premultiplied

Builds an unresolved mix. At amount zero or one it returns the exact normalized endpoint. At interior values it retains palette and role tokens for an explicit theme resolver. 'srgb is encoded-component interpolation; 'srgb-linear, the default, is linear-light interpolation. Both honor the selected alpha policy. 'oklab uses Oklab conversion and, when needed, a deterministic fixed-lightness/fixed-hue chroma reduction into sRGB. rgba-color-lerp remains the existing explicit componentwise numerical helper.

procedure
(color-with-alpha color alpha) → color-spec?
color : color-spec?
alpha : (and/c finite-real? (>=/c 0) (<=/c 1))

Builds an unresolved expression that replaces the resolved color’s alpha, or folds an all-literal result immediately.

procedure
(color-opacity color factor) → color-spec?
color : color-spec?
factor : (and/c finite-real? (>=/c 0) (<=/c 1))

Builds an unresolved expression that multiplies the resolved color’s alpha. An identity multiplier returns the normalized source directly.

64.1 Color Scales🔗ℹ

procedure
(color-scale #:stops stops
[ #:space space
#:outside outside]) → color-scale?
  stops : list?
  space : (or/c 'srgb 'srgb-linear 'oklab) = 'srgb-linear
  outside : (or/c 'clamp 'error) = 'clamp

Creates an immutable map from an already normalized finite scalar coordinate to a color specification. A scale does not inspect plot data or establish a data domain. Its stops must be ordered and use offsets in 0 through 1. Equal adjacent offsets are a hard discontinuity; querying that offset selects the final stop at the offset. This release supports clamp and error policies for a coordinate outside the stop domain.

procedure
(color-scale? value) → boolean?
value : any/c

Recognizes a color scale.

procedure
(color-scale-stops scale) → vector?
scale : color-scale?

Returns normalized stops in authored order.

procedure
(color-scale-space scale) → symbol?
scale : color-scale?

Returns the declared interpolation space.

procedure
(color-scale-outside scale) → symbol?
scale : color-scale?

Returns its outside-domain policy.

procedure
(color-scale-at scale coordinate) → color-spec?
scale : color-scale?
coordinate : finite-real?

Samples a scale while retaining a token or color expression until an explicit theme resolves it. At an exact endpoint it returns that normalized stop color. Lookup uses a logarithmic upper-bound search, so the final member of a run of equal offsets wins without changing hard-stop semantics.

procedure
(sequential-color-scale #:minimum minimum
#:maximum maximum
[ #:low low
#:high high
#:missing missing
#:space space
#:outside outside])
→ scientific-color-scale?
  minimum : finite-real?
  maximum : finite-real?
  low : color-spec? = aqua-d
  high : color-spec? = gold-d
  missing : color-spec? = theme-muted
  space : (or/c 'srgb 'srgb-linear 'oklab) = 'oklab
  outside : (or/c 'clamp 'error) = 'clamp

Creates a scalar scale with an explicit data domain, missing-data color, and out-of-domain policy. Low-to-high ordering is authored and does not reverse when a theme changes.

procedure
(diverging-color-scale #:minimum minimum
#:maximum maximum
#:midpoint midpoint
[ #:low low
#:middle middle
#:high high
#:missing missing
#:space space
#:outside outside])
→ scientific-color-scale?
  minimum : finite-real?
  maximum : finite-real?
  midpoint : finite-real?
  low : color-spec? = aqua-d
  middle : color-spec? = gray-b
  high : color-spec? = red-d
  missing : color-spec? = theme-muted
  space : (or/c 'srgb 'srgb-linear 'oklab) = 'oklab
  outside : (or/c 'clamp 'error) = 'clamp

Creates a three-stop scalar scale. midpoint must be within the declared domain and has data meaning; use this form only when that center is meaningful.

procedure
(scientific-color-scale? value) → boolean?
value : any/c

Recognizes a scalar scale with an explicit domain policy.

procedure
(scientific-color-scale-kind scale)
→ (or/c 'sequential 'diverging)
scale : scientific-color-scale?

Returns the recipe kind.

procedure
(scientific-color-scale-minimum scale) → finite-real?
scale : scientific-color-scale?

Returns the declared data minimum.

procedure
(scientific-color-scale-maximum scale) → finite-real?
scale : scientific-color-scale?

Returns the declared data maximum.

procedure
(scientific-color-scale-midpoint scale)
→ (or/c #f finite-real?)
scale : scientific-color-scale?

Returns the meaningful center, or #f for a sequential scale.

procedure
(scientific-color-scale-missing scale) → color-spec?
scale : scientific-color-scale?

Returns the retained missing-data color.

procedure
(scientific-color-scale-outside scale) → (or/c 'clamp 'error)
scale : scientific-color-scale?

Returns the explicit out-of-domain policy.

procedure
(scientific-color-scale-at scale value) → color-spec?
scale : scientific-color-scale?
value : any/c

Maps a finite scalar from the declared domain. A non-finite value returns the recorded missing-data color rather than choosing an endpoint.

value
color-spec-schema-version : exact-positive-integer?

The version number carried by color-spec->datum values.

procedure
(color-spec->datum color) → any/c
color : color-spec?

Produces a readable, versioned datum. For example, a palette reference is written as '(animate-color-spec 1 (palette aqua-c)). Serialization uses finite output-node and atom-size budgets, so a shared expression graph cannot expand without bound into this tree-shaped external format.

procedure
(datum->color-spec datum
[ #:maximum-depth maximum-depth]) → color-spec?
datum : any/c
maximum-depth : exact-positive-integer? = 64

Reads one bounded versioned color datum without evaluating it. Malformed, unsupported-version, cyclic, and excessive-depth inputs raise an exception.

64.2 Palettes and Themes🔗ℹ

A palette is a complete immutable table from palette keys to literal RGBA swatches. A theme owns one complete palette snapshot and maps semantic role keys to authored color specifications. Both are pure values: resolution always takes a theme explicitly and no mutable process-wide current theme exists.

Every symbol that becomes portable color data—palette/theme IDs, palette and role keys, palette-group IDs, and symbol-valued provenance—must be a nonempty interned symbol. Process-local uninterned and unreadable symbols are rejected rather than silently interned, since distinct same-spelling keys could otherwise merge after a file or worker round trip. Strings remain supported for display names and provenance.

value
color-palette-schema-version : exact-positive-integer?

The version number used by palette data read and written by this release.

procedure
(color-palette #:id id
#:colors colors
[ #:extends parent
#:display-name display-name
#:version version
#:groups groups
#:provenance provenance]) → color-palette?
  id : symbol?
  colors : hash?
  parent : (or/c #f color-palette?) = #f
  display-name : string? = (symbol->string id)
  version : exact-positive-integer? = 1
  groups : (or/c #f list?) = #f
  provenance : (or/c #f symbol? string?) = #f

Creates a complete immutable palette. Palette values must be literal colors; tokens and expressions belong in themes. A root palette supplies every standard palette key. A child palette copies its parent snapshot, then overrides the given canonical keys. Fixed literal names such as white cannot be overridden through a palette.

procedure
(color-palette? value) → boolean?
value : any/c

Recognizes a palette.

procedure
(color-palette-id palette) → symbol?
palette : color-palette?

Returns its stable identifier.

procedure
(color-palette-display-name palette) → string?
palette : color-palette?

Returns its display metadata.

procedure
(color-palette-version palette) → exact-positive-integer?
palette : color-palette?

Returns its data version.

procedure
(color-palette-provenance palette) → (or/c #f symbol? string?)
palette : color-palette?

Returns non-appearance provenance metadata.

procedure
(palette-ref palette key) → rgba-color?
palette : color-palette?
key : symbol?

Returns the literal swatch for a canonical palette key or a documented alias. An unknown key raises an exception rather than choosing a fallback color.

procedure
(palette-keys palette) → (listof symbol?)
palette : color-palette?

Returns the complete deterministic key order: the standard catalog first, then custom keys in canonical symbol order. The order does not depend on the parent-extension history used to construct an otherwise equal palette.

procedure
(palette-groups palette) → list?
palette : color-palette?

Returns ordered (list group-id keys) metadata for swatch browsers.

procedure
(palette->datum palette) → any/c
palette : color-palette?

Produces a complete readable versioned palette datum. Output has the same finite node and atom-size limits used by complete theme export.

procedure
(datum->palette datum) → color-palette?
datum : any/c

Reads one complete palette datum without evaluating it. It rejects malformed schema versions and duplicate keys, including aliases that normalize to the same palette entry.

value
color-theme-schema-version : exact-positive-integer?

The version number used by complete theme data read and written by this release.

procedure
(color-theme #:id id
[ #:palette palette
#:roles roles
#:extends parent
#:display-name display-name
#:series series
#:provenance provenance]) → color-theme?
  id : symbol?
  palette : (or/c #f color-palette?) = #f
  roles : hash? = (hash)
  parent : (or/c #f color-theme?) = #f
  display-name : string? = (symbol->string id)
  series : (or/c #f list?) = #f
  provenance : (or/c #f symbol? string?) = #f

Creates a complete immutable theme snapshot. Standard roles are required for a root theme. A child copies its parent palette and roles, then applies supplied overrides. Role dependencies are resolved and validated at construction; direct or indirect cycles and missing role/token references are errors. Role and series definitions may refer to literals, palette tokens, roles, and expressions, but not series-color: a categorical series token becomes valid only after the complete theme series has been constructed. Theme definitions are bounded to 10,000 roles or series entries and expression depth 64. Validation and resolution memoize shared expression nodes within one operation and enforce a distinct-node budget, so invalid external data cannot create an unbounded dependency walk.

procedure
(color-theme? value) → boolean?
value : any/c

Recognizes a complete theme.

procedure
(color-theme-id theme) → symbol?
theme : color-theme?

Returns its stable identifier.

procedure
(color-theme-display-name theme) → string?
theme : color-theme?

Returns its display metadata.

procedure
(color-theme-palette theme) → color-palette?
theme : color-theme?

Returns its complete palette snapshot.

procedure
(color-theme-provenance theme) → (or/c #f symbol? string?)
theme : color-theme?

Returns non-appearance provenance metadata.

procedure
(theme-ref theme role-key) → color-spec?
theme : color-theme?
role-key : symbol?

Returns the normalized authored specification for a role, rather than its resolved value.

procedure
(theme-role-keys theme) → (listof symbol?)
theme : color-theme?

Returns role keys in deterministic order.

procedure
(theme-series theme) → (listof rgba-color?)
theme : color-theme?

Returns the resolved categorical series snapshot. The built-in themes contain eight entries. series-color resolves against this snapshot by explicit wraparound; a theme with an empty series can still be used for ordinary roles, but resolving a series token raises an error.

procedure
(color-theme-fingerprint theme) → bytes?
theme : color-theme?

Returns a deterministic appearance identity based on the complete palette, resolved roles, and resolved series. Display names and provenance do not alter this fingerprint. Equal appearances have equal fingerprints regardless of hash insertion order, palette-extension history, or ordinary printer preferences; series order remains significant.

procedure
(theme->datum theme) → any/c
theme : color-theme?

Produces a complete readable versioned theme datum. One shared finite budget covers the palette, group membership, role expressions, categorical series, and metadata atoms, so splitting a large declaration across those sections does not bypass the export limit.

procedure
(datum->theme datum) → color-theme?
datum : any/c

Reads one complete theme datum without evaluating it. It rejects malformed schema versions and duplicate role declarations before constructing a hash.

procedure
(resolve-color color theme) → rgba-color?
color : color-spec?
theme : color-theme?

Resolves a literal, palette token, role token, categorical-series token, or supported expression under the supplied immutable theme. It is the only COLOR-B operation that turns a themeable value into a concrete RGBA color.

64.3 Inspection and Diagnostics🔗ℹ

procedure
(inspect-color color
theme
[ #:owner-path owner-path
#:style-field style-field]) → immutable-hash?
  color : color-spec?
  theme : color-theme?
  owner-path : (or/c #f (listof symbol?)) = #f
  style-field : (or/c #f symbol?) = #f

Returns a pure explanation of one authored color under one explicit theme. Its keys include 'authored (a versioned color datum), 'kind, 'canonical-token, 'role-resolution-chain, 'resolved-hex, 'resolved-rgba, 'effective-alpha, 'theme-id, 'theme-fingerprint, 'interpolation-space, 'owner-path, and 'style-field. Palette aliases are normalized when a token is made, so the canonical token is retained and 'alias-used is #f.

The effective alpha belongs to the resolved color. It is distinct from a Visual’s separate opacity, and in three dimensions it is the material input to lighting rather than an observed lit pixel.

procedure
(color-inspection? value) → boolean?
value : any/c

Recognizes the immutable report returned by inspect-color.

procedure
(rgba-color->hex color) → string?
color : rgba-color?

Formats a resolved color as uppercase #RRGGBBAA. The alpha channel is always included so a copied literal is unambiguous.

procedure
(color-contrast-ratio foreground
background) → positive-real?
foreground : rgba-color?
background : rgba-color?

Computes pairwise relative-luminance contrast after compositing the foreground over an opaque background. A translucent background is rejected because this procedure has no canvas against which to composite it. This is a review aid, not a claim that every rendered video meets an accessibility standard.

procedure
(color-theme-diagnostics
theme
[ #:ordinary-text-pairs ordinary-text-pairs
#:graphic-pairs graphic-pairs
#:minimum-series-contrast minimum-series-contrast
#:canvas canvas])
→ (listof immutable-hash?)
  theme : color-theme?
   ordinary-text-pairs : (listof (cons/c symbol? symbol?))
= '((foreground . background))
   graphic-pairs : (listof (cons/c symbol? symbol?))
= '((axis . background) (accent . background))
  minimum-series-contrast : (and/c finite-real? positive?) = 3
  canvas : (or/c #f rgba-color?) = #f

Returns deterministic reports for requested role-pair contrast, nonmonotonic declared standard shade ramps, empty categorical series, and low-contrast category pairs. A custom five-item palette group is categorical metadata, not an implicit light-to-dark ramp declaration. Ordinary text is reviewed against a 4.5:1 target and meaningful graphics against 3:1. Missing palette entries, invalid aliases, cyclic roles, and expression-resolution failures are rejected when a palette, theme, or color datum is constructed; no renderer silently repairs them. A color that needs gamut mapping during Oklab interpolation remains deterministic, but the resolved value is always the value this API reports.

If a requested background or the theme background is translucent, a supplied opaque canvas gives the compositing basis. Without one, the valid theme still returns a 'contrast-undetermined report instead of being treated as malformed. Returned invalid-datum reports retain a bounded immutable summary of input, never the caller’s mutable datum. Categorical-series comparisons use a fixed review budget. Their warning rows are followed by a 'categorical-series-summary report containing possible and examined pair counts, found and retained warning counts, and a 'truncated? flag. An incomplete bounded review is a warning even when every examined pair passed; the omitted pairs have not been checked.

procedure
(color-theme-datum-diagnostics datum)
→ (listof immutable-hash?)
datum : any/c

Reads a complete external theme datum without evaluating it. A valid datum returns the ordinary theme diagnostics. A malformed declaration returns one error report, classifying missing entries, invalid palette-key spelling, and cyclic role declarations when the constructor can identify them.

procedure
(color-resolution-diagnostics color theme)
→ (listof immutable-hash?)
color : color-spec?
theme : color-theme?

Returns a pure success report or an error report for one authored field under one explicit theme. It is useful for reporting a failed token or expression resolution without trying to render a substitute color.

value
animate-palette : color-palette?
value
animate-palette-checksum : bytes?
value
animate-light-theme : color-theme?
value
animate-dark-theme : color-theme?

The built-in version-one numerical Animate palette, its deterministic SHA-1 review checksum, and complete light/dark role snapshots. The palette table is literal data; the two themes deliberately use explicit role assignments.

64.4 Palette Tokens🔗ℹ

The eight canonical hue ramps use a for the lightest and e for the darkest shade. The un-suffixed family names are aliases for their -c tokens.

value
blue-a : color-token?
value
blue-b : color-token?
value
blue-c : color-token?
value
blue-d : color-token?
value
blue-e : color-token?
value
blue : color-token?

Blue palette tokens.

value
aqua-a : color-token?
value
aqua-b : color-token?
value
aqua-c : color-token?
value
aqua-d : color-token?
value
aqua-e : color-token?
value
aqua : color-token?

Aqua palette tokens.

value
green-a : color-token?
value
green-b : color-token?
value
green-c : color-token?
value
green-d : color-token?
value
green-e : color-token?
value
green : color-token?

Green palette tokens.

value
yellow-a : color-token?
value
yellow-b : color-token?
value
yellow-c : color-token?
value
yellow-d : color-token?
value
yellow-e : color-token?
value
yellow : color-token?

Yellow palette tokens.

value
gold-a : color-token?
value
gold-b : color-token?
value
gold-c : color-token?
value
gold-d : color-token?
value
gold-e : color-token?
value
gold : color-token?

Gold palette tokens.

value
red-a : color-token?
value
red-b : color-token?
value
red-c : color-token?
value
red-d : color-token?
value
red-e : color-token?
value
red : color-token?

Red palette tokens.

value
maroon-a : color-token?
value
maroon-b : color-token?
value
maroon-c : color-token?
value
maroon-d : color-token?
value
maroon-e : color-token?
value
maroon : color-token?

Maroon palette tokens.

value
purple-a : color-token?
value
purple-b : color-token?
value
purple-c : color-token?
value
purple-d : color-token?
value
purple-e : color-token?
value
purple : color-token?

Purple palette tokens.

value
gray-a : color-token?
value
gray-b : color-token?
value
gray-c : color-token?
value
gray-d : color-token?
value
gray-e : color-token?
value
lighter-gray : color-token?
value
light-gray : color-token?
value
gray : color-token?
value
dark-gray : color-token?
value
darker-gray : color-token?

Neutral tokens. The five longer names are aliases for gray-a through gray-e, respectively.

value
pink : color-token?
value
light-pink : color-token?
value
orange : color-token?
value
light-brown : color-token?
value
dark-brown : color-token?
value
gray-brown : color-token?

Familiar auxiliary palette tokens.

value
blush : color-token?
value
peach : color-token?
value
apricot : color-token?
value
tan : color-token?
value
cocoa : color-token?
value
taupe : color-token?

Warm Naturals palette tokens.

64.5 Semantic Role Tokens🔗ℹ

value
theme-background : color-token?
value
theme-foreground : color-token?
value
theme-muted : color-token?
value
theme-axis : color-token?
value
theme-grid : color-token?
value
theme-surface : color-token?
value
theme-surface-edge : color-token?
value
theme-accent : color-token?
value
theme-highlight : color-token?
value
theme-selection : color-token?
value
theme-warning : color-token?
value
theme-success : color-token?
value
theme-error : color-token?

Standard semantic role references. Their safe theme- prefix avoids shadowing ordinary Racket bindings such as error.

64.6 Fixed Literal Endpoints🔗ℹ

value
black : rgba-color?
value
white : rgba-color?
value
pure-red : rgba-color?
value
pure-green : rgba-color?
value
pure-blue : rgba-color?
value
pure-cyan : rgba-color?
value
pure-magenta : rgba-color?
value
pure-yellow : rgba-color?

Opaque fixed sRGB endpoints. These are literals, not palette tokens, and are therefore never changed by a future theme.

I	Concepts
II	Cookbook
III	Guide
IV	Complete Example Programs
V	Reference

52	Find a task or a name
53	Modules to require
54	Scenes and sampling
55	Scene states
56	Animation requests
57	Native model details
58	Visuals
59	Geometry
60	Number Lines and Coordinate Decorations
61	Point Markers, Scatter Plots, and Filled Areas
62	Probability and Statistical Diagrams
63	Calculus lessons
64	Colors
65	Slides
66	Slide command-line tools
67	Source Programs and Authored Timelines
68	Interactive Preview and Inspection
69	Preview controls and diagnostics
70	Projects and Final Rendering
71	Project execution and cache details
72	Pict Renderer Protocol
73	3D reference map
74	3D: Objects, groups, and paths
75	3D: Cameras and projection
76	3D: Views inside a Scene
77	3D: Animating 3D objects
78	3D: Animating the 3D camera
79	3D: Cuts, caps, and section measurements
80	3D: Supplementary surface, section, and annotation bindings
81	3D: Cuts, sections, and numerical volume
82	3D: Vectors
83	3D: Linear maps and rotations
84	3D: Affine transforms
85	3D: Bounds, rays, and planes
86	3D: Spatial maps and homotopies
87	3D: Materials and lights
88	3D: Lighting inspection
89	3D: Shadow descriptors and stable bounds
90	3D: Finite-light animation
91	3D: Software finite-light evaluation
92	3D: Colour space and final output
93	3D: Relations and geometric annotations
94	3D: Projected labels
95	3D: Textured billboards
96	3D: Spatial curves and vector diagrams
97	3D: Spatial anchors and label layout
98	3D: Anchors and projected labels
99	3D: Parametric surfaces and calculus
100	3D: Adaptive, trimmed, and implicit surfaces
101	3D: Constructive solids
102	3D: Surface constructors and queries
103	3D: Meshes
104	3D: Triangle topology
105	3D: Polygonal faces
106	3D: Deterministic convex hulls
107	3D: Polyhedral duals
108	3D: Schlegel diagrams and polyhedral nets
109	3D: Conservative mesh correspondence
110	3D: Topology-safe mesh matching
111	3D: Checking and repairing mesh orientation
112	3D: Clipping, sections, and transparency
113	3D: Prepared spatial ODE trajectories and vector fields
114	3D: Seeds and streamline sets
115	3D: Poincare sections and return maps
116	3D: Equilibria and local linearization
117	3D: Flow maps and volume change
118	3D: Drawing and inspecting trajectories
119	3D: Reading prepared trajectories
120	3D: Drawing vector fields and particles
121	3D: Trajectory display
122	3D: Spatial inspection and exact picking
123	3D: Retained renderer backends
124	3D: Compiled geometry and instances
125	3D: Frame requests and results
126	3D: Software rendering and statistics
127	3D: Optional Racket/ Open GL backend
128	Experimental Derived Visuals
129	Source Package Hygiene

64.1	Color Scales
64.2	Palettes and Themes
64.3	Inspection and Diagnostics
64.4	Palette Tokens
64.5	Semantic Role Tokens
64.6	Fixed Literal Endpoints