Examples

Runnable examples grouped by topic and searchable by keyword. Run any script with:

uv run python py/examples/<path>.py

Keyword index

• 2D — 2D orthographic view via View2DConfig, 2D camera, axes, and grid basics, fixed screen-space axes + grid overlay in 2D, 2D fit-camera keeps the axes/grid undistorted, Auto-fit, explicit, and partial camera modes, Toggle one scene between a 2D and 3D view with a checkbox, 2D animated HTML export with a moving camera, Demo: Drag TWO 2D points interactively with ActPoint, 2D plots across a split view, one stretch mode per pane

• 30fps — Stream a programmatic camera feed at 30 Hz over MJPEG

• 3D — 3D projective camera via View3dConfig, Auto-fit, explicit, and partial camera modes, Toggle one scene between a 2D and 3D view with a checkbox, 3D animated HTML export with a moving camera, a plot on a tilted background plane in 3D

• A X = B — Solve the general multivector equation A X = B with expressions

• ActPoint — VisualizerApp with a sin/cos split view and draggable points, Demo: Drag a 3D point interactively with ActPoint, Demo: Drag TWO 3D points interactively with ActPoint, Demo: Drag TWO 2D points interactively with ActPoint

• ActRectangle2D — Add and drag rectangles on an image via a toolbar

• affine — Polynomial (repeated-variable) expressions and affine sums

• AffineExpression — Sum an AffineExpression over a batched variable, Solve a single-linear-map AffineExpression

• alert — Demonstrates every banner/dialog kind, Banners scoped to a named scene via VizSceneHandle

• Algebra — How pytanga builds C++ backends on the fly, Creating and configuring an Algebra, Integer GA with two different moduli (NTRU style), Integer GA with a single modulus (Path C)

• align — A tour of StackView/SplitView spacing, alignment, and flex

• align modes — Demo: Texture labels on planes with different align modes

• alignment — Four toolbars, one per alignment, stacked in a vertical split

• all types — All geometric entity types in one scene

• analyze — reconstruct a conic from 5 points and rotate it with a slider, degenerate quadric (plane pair) analysis + rendering, Q3 point tuples (1–7 points) in distinct colors, reconstruct a quadric from 9 points and rotate it, reconstruct a quadric from 9 points and ray-render it

• anchor — Declarative control groups: overlay + 3D-anchored, Declarative control groups on a single-scene page

• angle vs time — a swinging pendulum with a live angle-vs-time plot

• animate — Frame-by-frame animation at ~60 FPS, Animation

• animate_to — Keyframe timeline with fade-in and move

• animated — Animated HTML export with JS playback engine, 2D animated HTML export with a moving camera, 3D animated HTML export with a moving camera, Export an animated noise image stream

• animation — A chaotic double pendulum from nested VizGroups, Nested animation loops honoring Ctrl+C, Frame-by-frame animation at ~60 FPS, Moving point with a color-gradient trail, Keyframe timeline with fade-in and move, Gravitational two-body simulation using only, Animation, Drive a VizGroup transform from a BasisN3 Motor, SDF object groups with per-member CSG + independent animation, Animate a directional light around a sphere

• AnimationRecording — Export an animated noise image stream

• annotation — a real calibrated image (BOP T-LESS) + 3D overview, Title overlay and Markdown + LaTeX annotation, A menu bar with a File → Open… file dialog

• annotations — annotations in a CoordinateSystem's data frame

• app — VisualizerApp with a sin/cos split view and draggable points

• Arc — the visualization-only Cylinder and Arc entities

• arrowhead — isolate the SDF arrowhead (capped cone) placement

• auto reload — Load a custom theme and edit it live

• auto-fit — Auto-fit, explicit, and partial camera modes

• auto-save — Table auto-save: JSON load/save + CSV export

• auto_clear — Animation

• axes — fixed screen-space axes + grid overlay in 2D

• Axes2D — 2D camera, axes, and grid basics

• Axis — Custom axes and grid as explicit scene objects

• banner — Demonstrates every banner/dialog kind, Slider that triggers a blocking computation on release, Banners scoped to a named scene via VizSceneHandle

• bar — Menus: per-pane overlay, sub-menus, and sub-sub-menus

• basis — Creating and configuring an Algebra, BladeMask named bases (auto display basis, composed names, with_basis), get_tensor() (raw MVTensor) + get_array() (named bases)

• basis blades — Three ways to work with named basis blades

• BasisE3 — Euclidean 3D geometric algebra G(3, 0), Three ways to work with named basis blades

• BasisN3 — Null / conformal 3D algebra G(5, 0b10000), Drive a VizGroup transform from a BasisN3 Motor

• BasisP3 — Projective 3D geometric algebra G(4, 0)

• BasisPGA3 — Projective GA (PGA 3D)

• batched — Product tensor basics — compute the geometric product via tensor contraction

• bind — Bind a variable to a sub-expression (composition), Re-key variables so independent expressions merge

• binding — How pytanga builds C++ backends on the fly

• BladeMask — BladeMask named bases (auto display basis, composed names, with_basis), Project an N3 expression onto the Euclidean basis, get_tensor() (raw MVTensor) + get_array() (named bases), Recover a rotor from 3D point ↔ projection-ray matches

• BOP — a real calibrated image (BOP T-LESS) + 3D overview

• Box — the Disk, PartialDisk, Box, Ellipsoid, Ellipse, and

• button — Showcase every interactive control in one app, Controls styled from the extracted theme CSS files, A custom theme with a full button/checkbox override

• ButtonView — Declarative controls drive a sphere

• C++ backend — How pytanga builds C++ backends on the fly

• cache — How pytanga builds C++ backends on the fly

• calibration — a real calibrated image (BOP T-LESS) + 3D overview, a live-updated camera view + pane swap, a calibrated camera as a free orbit/pan/zoom view, calibrated camera view (image) + default 3D overview

• camera — 2D orthographic view via View2DConfig, 3D projective camera via View3dConfig, 2D camera, axes, and grid basics, fixed screen-space axes + grid overlay in 2D, Stream a programmatic camera feed at 30 Hz over MJPEG, 2D fit-camera keeps the axes/grid undistorted, Auto-fit, explicit, and partial camera modes, a real calibrated image (BOP T-LESS) + 3D overview, a live-updated camera view + pane swap, a calibrated camera as a free orbit/pan/zoom view, calibrated camera view (image) + default 3D overview, Toggle one scene between a 2D and 3D view with a checkbox, 2D animated HTML export with a moving camera, 3D animated HTML export with a moving camera

• capped cone — isolate the SDF arrowhead (capped cone) placement

• Cayley-Bacharach — Q3 point tuples (1–7 points) in distinct colors

• cdn — Compare the three HTML delivery modes

• cell editing — Editable table: column types, keyboard nav, undo/redo

• chaos — A chaotic double pendulum from nested VizGroups

• checkbox — Toggle one scene between a 2D and 3D view with a checkbox, Controls styled from the extracted theme CSS files, Hide/show a sphere and its controls from a split layout, A custom theme with a full button/checkbox override

• CheckboxView — Declarative controls drive a sphere

• Circle — Full conformal (N3) entities: Spheres, Circles, Point Pairs

• classification — classify a noisy quadric within a tolerance

• click — Demo: Drag TWO 2D points interactively with ActPoint

• code generation — How pytanga builds C++ backends on the fly

• codec — Display a 16-bit image over the lossless (zlib) transport, Display an 8-bit image over the default (JPEG) transport

• coefficients — The MV class: initialization, operators, and named methods

• column types — Editable table: column types, keyboard nav, undo/redo, A TableView with a column-fed enum and a backend-fed enum

• combine — per-object CSG combine modes

• comparison — every solid object as a mesh next to its SDF twin

• compilation — How pytanga builds C++ backends on the fly

• compile — Expression.compile() for fast repeated evaluation

• compose — Compose a detached scene subtree, then insert it

• Composed — Combine multiple SdfGroups (nesting + merging), Composed SDF objects + the primitive library

• composition — Bind a variable to a sub-expression (composition)

• cone — lift a 2D conic into a 3D cone through an apex, draw arbitrary quadrics via entities + GA translation, classify a noisy quadric within a tolerance

• confirm — Demonstrates every banner/dialog kind, Banners scoped to a named scene via VizSceneHandle

• conformal — Null / conformal 3D algebra G(5, 0b10000), BladeMask named bases (auto display basis, composed names, with_basis), Full conformal (N3) entities: Spheres, Circles, Point Pairs, Full conformal (N3) operators: Rotors, Motors, Inversions

• conic — lift a 2D conic into a 3D cone through an apex, reconstruct a conic from 5 points and rotate it with a slider, intersect two 2D conics (a point tuple), fit a conic/quadric from points with the GA primitives, intersect two 3D quadrics (Perwass pencil)

• conic_from_points — reconstruct a conic from 5 points and rotate it with a slider

• constraints — Demo: Drag a 3D point interactively with the mouse

• construction — Three ways to work with named basis blades

• context manager — Interactive Visualizer, Two named scenes, each shown in its own browser tab

• contraction — Expressions, variables, and DataArray bindings

• control group — Declarative control groups: overlay + 3D-anchored, Declarative control groups on a single-scene page

• control update — Settable label and markdown panes in a vertical split

• controls — Showcase every interactive control in one app, Controls styled from the extracted theme CSS files, Declarative controls drive a sphere, A file chooser with a backend-driven file browser, An editable tabular-data control driven by the backend, Editable table: column types, keyboard nav, undo/redo, A TableView with a column-fed enum and a backend-fed enum, Table auto-save: JSON load/save + CSV export, Switch the viewer theme at runtime without a reload

• CoordinateSystem — VisualizerApp with a sin/cos split view and draggable points, fixed screen-space axes + grid overlay in 2D, annotations in a CoordinateSystem's data frame, logarithmic plotting with CoordinateSystem, 2D plots across a split view, one stretch mode per pane

• counting axis — Sum an AffineExpression over a batched variable

• cp — Named GA product functions over variables

• CSG — per-object CSG combine modes, SDF object groups with per-member CSG + independent animation

• css — Controls styled from the extracted theme CSS files

• CSV — Table auto-save: JSON load/save + CSV export

• Ctrl+C — Nested animation loops honoring Ctrl+C

• cursor — Add and drag rectangles on an image via a toolbar

• curve — intersect two 3D quadrics (Perwass pencil)

• custom enum — A TableView with a column-fed enum and a backend-fed enum

• custom intervals — Custom axes and grid as explicit scene objects

• custom shader — Custom image shader that rotates RGB vectors

• custom theme — Load a custom theme and edit it live, A custom theme with a full button/checkbox override

• Cylinder — the visualization-only Cylinder and Arc entities

• cylinder — Compose a detached scene subtree, then insert it

• dark — Switch the viewer theme at runtime without a reload

• DataArray — Expressions, variables, and DataArray bindings, Sum an AffineExpression over a batched variable

• defaults — Global default styles and per-call overrides

• degenerate — degenerate quadric (plane pair) analysis + rendering

• delivery — Compare the three HTML delivery modes

• detached — Compose a detached scene subtree, then insert it

• dialog — Demonstrates every banner/dialog kind, A titled dialog whose body holds view-based controls, A file-selection view, embedded and in a dialog box

• Dilator — Full conformal (N3) operators: Rotors, Motors, Inversions, Rotor, Translator, Motor, Dilator visualization

• dimension — Creating and configuring an Algebra

• Direction — Projective 3D geometry: Points, Directions, Lines, Planes, Gravitational two-body simulation using only

• disable — Hide/show a sphere and its controls from a split layout

• Disk — the Disk, PartialDisk, Box, Ellipsoid, Ellipse, and

• display — Interactive Visualizer

• double pendulum — A chaotic double pendulum from nested VizGroups

• drag — VisualizerApp with a sin/cos split view and draggable points, Custom image shader that rotates RGB vectors, Add and drag rectangles on an image via a toolbar, Demo: Drag a 3D point interactively with ActPoint, Demo: Drag TWO 3D points interactively with ActPoint, Demo: Drag TWO 2D points interactively with ActPoint, Demo: Drag a 3D point interactively with the mouse

• dropdown — reconstruct a quadric from 9 points and rotate it, Two Spheres Intersection — Interactive Controls Demo (IPNS), Showcase every interactive control in one app, Four toolbars, one per alignment, stacked in a vertical split, Menus: per-pane overlay, sub-menus, and sub-sub-menus

• dtype — Creating and configuring an Algebra

• dual modulus — Integer GA with two different moduli (NTRU style)

• E3 — Euclidean 3D geometric algebra G(3, 0), Euclidean 3D geometry: Points, Planes, Reflections, Rotors, Product tensor basics — compute the geometric product via tensor contraction

• easing — Keyframe timeline with fade-in and move

• einsum — multilinear AffineExpression.get_tensor(), Product tensor basics — compute the geometric product via tensor contraction, Product tensor basics — compute the geometric product via tensor contraction, Product tensor basics — compute the geometric product via tensor contraction

• Ellipse — the Disk, PartialDisk, Box, Ellipsoid, Ellipse, and

• ellipsoid — reconstruct a quadric from 9 points and rotate it

• Ellipsoid — the Disk, PartialDisk, Box, Ellipsoid, Ellipse, and

• enable — Hide/show a sphere and its controls from a split layout

• entities — All geometric entity types in one scene, the Disk, PartialDisk, Box, Ellipsoid, Ellipse, and, MV input from PGA3 and N3, OPNS vs IPNS, Rotor, Translator, Motor, Dilator visualization, the visualization-only Cylinder and Arc entities, First vertical slice for the SDF viewer

• entity — Rotate a list of points with a variable rotor and variable points

• enum — A TableView with a column-fed enum and a backend-fed enum

• Euclidean — Euclidean 3D geometric algebra G(3, 0), Project an N3 expression onto the Euclidean basis

• explicit — Auto-fit, explicit, and partial camera modes

• export — Animated HTML export with JS playback engine, 2D animated HTML export with a moving camera, 3D animated HTML export with a moving camera, Export an animated noise image stream, Compare the three HTML delivery modes, Presentation figure export with FigureStyle, Self-contained HTML and glTF export, Export a programmatic image as HTML with JPEG compression, Programmatic PNG screenshot at custom resolution, Export

• expression — Expressions, variables, and DataArray bindings

• expressions — Sum an AffineExpression over a batched variable, Solve a single-linear-map AffineExpression, Bind a variable to a sub-expression (composition), Expression.compile() for fast repeated evaluation, Multi-variable linear equations with Variables, Least-squares line fitting in P3 with visualization, Named GA product functions over variables, Polynomial (repeated-variable) expressions and affine sums, Project an N3 expression onto the Euclidean basis, multilinear AffineExpression.get_tensor(), Re-key variables so independent expressions merge, Solve the general multivector equation A X = B with expressions, get_tensor() (raw MVTensor) + get_array() (named bases), Apply a fixed rotor to points with a Variable-backed expression, Rotate a list of points with a variable rotor and variable points

• figure — Presentation figure export with FigureStyle, Export

• FigureStyle — Presentation figure export with FigureStyle

• file browser — A file chooser with a backend-driven file browser

• file chooser — A file chooser with a backend-driven file browser, A file-selection view, embedded and in a dialog box

• file dialog — A menu bar with a File → Open… file dialog

• FileChooserDialog — A file-selection view, embedded and in a dialog box, A menu bar with a File → Open… file dialog

• FileChooserView — A file-selection view, embedded and in a dialog box

• first slice — First vertical slice for the SDF viewer

• fit camera — 2D fit-camera keeps the axes/grid undistorted

• fit_view2d — 2D plots across a split view, one stretch mode per pane

• fitting — fit a conic/quadric from points with the GA primitives

• fixed modulus — Integer GA with a single modulus (Path C)

• flex — A titled dialog whose body holds view-based controls, A tour of StackView/SplitView spacing, alignment, and flex

• fold — Group view chrome: leading icon, icon-only, borderless fold

• fr — A tour of StackView/SplitView spacing, alignment, and flex

• frame streaming — Frame-by-frame animation at ~60 FPS

• frustum — a real calibrated image (BOP T-LESS) + 3D overview, a live-updated camera view + pane swap, a calibrated camera as a free orbit/pan/zoom view, calibrated camera view (image) + default 3D overview

• G(3,0) — Euclidean 3D geometric algebra G(3, 0)

• G(3,1) — Core solver API: inverse and general solve

• G(4,0) — Projective 3D geometric algebra G(4, 0)

• G(5,0b10000) — Null / conformal 3D algebra G(5, 0b10000)

• gap — A tour of StackView/SplitView spacing, alignment, and flex

• general solve — Core solver API: inverse and general solve, Core solver API: inverse and general solve

• geometric algebra — Expressions, variables, and DataArray bindings

• geometric product — Product tensor basics — compute the geometric product via tensor contraction, Product tensor basics — compute the geometric product via tensor contraction

• geometry — Euclidean 3D geometry: Points, Planes, Reflections, Rotors

• Geometry — classify a noisy quadric within a tolerance

• get_array — multilinear AffineExpression.get_tensor(), get_tensor() (raw MVTensor) + get_array() (named bases)

• get_tensor — multilinear AffineExpression.get_tensor(), get_tensor() (raw MVTensor) + get_array() (named bases)

• GLSL — Custom image shader that rotates RGB vectors

• glTF — Self-contained HTML and glTF export, Export

• gp — Named GA product functions over variables

• gradient — Moving point with a color-gradient trail

• gravity — Gravitational two-body simulation using only

• Grid — 2D camera, axes, and grid basics, Custom axes and grid as explicit scene objects

• grid — fixed screen-space axes + grid overlay in 2D

• group — SDF object groups with per-member CSG + independent animation

• group view — Group view chrome: leading icon, icon-only, borderless fold

• GroupView — Declarative control groups: overlay + 3D-anchored, Declarative control groups on a single-scene page, Declarative controls drive a sphere

• Gunn/Dorst — Gunn/Dorst PGA 3D geometry with plane‑based representation

• heavy work — Slider that triggers a blocking computation on release

• hide — Hide/show a sphere and its controls from a split layout

• hierarchy — Demonstrate nested VizGroup hierarchies

• history — A live, auto-scrolling two-column log in a split pane

• homogeneous — Projective 3D geometry: Points, Directions, Lines, Planes, Least-squares homogeneous line fitting in P2

• HTML — Animated HTML export with JS playback engine, 2D animated HTML export with a moving camera, 3D animated HTML export with a moving camera, Compare the three HTML delivery modes, Self-contained HTML and glTF export, Export

• html — Export a programmatic image as HTML with JPEG compression

• hyperboloid — draw arbitrary quadrics via entities + GA translation

• icon — Add and drag rectangles on an image via a toolbar, Group view chrome: leading icon, icon-only, borderless fold, Four toolbars, one per alignment, stacked in a vertical split

• icon_only — Controls styled from the extracted theme CSS files, Group view chrome: leading icon, icon-only, borderless fold

• image — Export an animated noise image stream, Export a programmatic image as HTML with JPEG compression, Custom image shader that rotates RGB vectors, Display a large image as an on-demand tile pyramid, Display a numpy image and draw pixel-coordinate overlays, Display a 16-bit image over the lossless (zlib) transport, Add and drag rectangles on an image via a toolbar, Display an 8-bit image over the default (JPEG) transport

• image background — a real calibrated image (BOP T-LESS) + 3D overview, a live-updated camera view + pane swap, calibrated camera view (image) + default 3D overview

• ImageCanvas — Export a programmatic image as HTML with JPEG compression, Custom image shader that rotates RGB vectors, Display a numpy image and draw pixel-coordinate overlays, Display a 16-bit image over the lossless (zlib) transport, Display an 8-bit image over the default (JPEG) transport

• ImageData — Export a programmatic image as HTML with JPEG compression, Display a 16-bit image over the lossless (zlib) transport, Display an 8-bit image over the default (JPEG) transport

• initialization — The MV class: initialization, operators, and named methods

• inline — Compare the three HTML delivery modes

• integer — Integer GA with two different moduli (NTRU style), Integer GA with a single modulus (Path C)

• interaction — Demo: Drag a 3D point interactively with ActPoint, Demo: Drag TWO 3D points interactively with ActPoint, Demo: Drag TWO 2D points interactively with ActPoint, Demo: Drag a 3D point interactively with the mouse, Two Spheres Intersection — Interactive Controls Demo (IPNS)

• interactive — Interactive Visualizer

• intersection — intersect two 2D conics (a point tuple), intersect two 3D quadrics (Perwass pencil)

• inv — Solve a single-linear-map AffineExpression

• inverse — Core solver API: inverse and general solve, Core solver API: inverse and general solve

• Inversion — Full conformal (N3) operators: Rotors, Motors, Inversions

• IPNS — Euclidean 3D geometry: Points, Planes, Reflections, Rotors, Full conformal (N3) entities: Spheres, Circles, Point Pairs, MV input from PGA3 and N3, OPNS vs IPNS, Two Spheres Intersection — Interactive Controls Demo (IPNS)

• join — Q3 point tuples (1–7 points) in distinct colors, reconstruct a quadric from 9 points and rotate it, reconstruct a quadric from 9 points and ray-render it

• jpeg — Export an animated noise image stream, Export a programmatic image as HTML with JPEG compression, Display an 8-bit image over the default (JPEG) transport

• JSON — Table auto-save: JSON load/save + CSV export

• justify — A tour of StackView/SplitView spacing, alignment, and flex

• KaTeX — Demo: Texture labels on spheres using plain text and KaTeX formulas, Title overlay and Markdown + LaTeX annotation, Settable label and markdown panes in a vertical split

• keyboard navigation — Editable table: column types, keyboard nav, undo/redo

• keyframe — Keyframe timeline with fade-in and move

• label — Settable label and markdown panes in a vertical split

• labels — Labels with custom styling, dynamic update, and removal

• LabelStyle — Labels with custom styling, dynamic update, and removal

• large image — Display a large image as an on-demand tile pyramid

• LaTeX — Title overlay and Markdown + LaTeX annotation

• layout — Declarative control groups: overlay + 3D-anchored, Four toolbars, one per alignment, stacked in a vertical split, A tour of StackView/SplitView spacing, alignment, and flex, Three scenes side-by-side in one horizontal split, A single page showing multiple scenes in split panes, Menus: per-pane overlay, sub-menus, and sub-sub-menus, Settable label and markdown panes in a vertical split, A live, auto-scrolling two-column log in a split pane

• least-norm — Core solver API: inverse and general solve

• least-squares — Solve a single-linear-map AffineExpression, Least-squares line fitting in P3 with visualization, Least-squares homogeneous line fitting in P2, Recover a rotor from 3D point ↔ projection-ray matches, Best-fit rotor from point correspondences, Recover a rotor from point ↔ projection-ray matches

• lift — lift a 2D conic into a 3D cone through an apex

• light — Animate a directional light around a sphere, A custom theme with a full button/checkbox override, Switch the viewer theme at runtime without a reload

• Line — Projective 3D geometry: Points, Directions, Lines, Planes, All geometric entity types in one scene

• line fitting — Least-squares line fitting in P3 with visualization, Least-squares homogeneous line fitting in P2

• linear equations — Multi-variable linear equations with Variables

• linear system — Core solver API: inverse and general solve

• live plot — a swinging pendulum with a live angle-vs-time plot

• lock — calibrated camera view (image) + default 3D overview

• log — A live, auto-scrolling two-column log in a split pane

• log plot — logarithmic plotting with CoordinateSystem

• lossless — Display a 16-bit image over the lossless (zlib) transport

• low-level — Demo: Drag a 3D point interactively with the mouse

• Markdown — Title overlay and Markdown + LaTeX annotation

• markdown — Settable label and markdown panes in a vertical split

• menu — A menu bar with a File → Open… file dialog, Menus: per-pane overlay, sub-menus, and sub-sub-menus

• menu bar — A titled dialog whose body holds view-based controls, A menu bar with a File → Open… file dialog

• merge — Re-key variables so independent expressions merge, Combine multiple SdfGroups (nesting + merging)

• mesh — every solid object as a mesh next to its SDF twin

• meshes — Mix standard meshes with SDF-styled objects

• mjpeg — Stream a programmatic camera feed at 30 Hz over MJPEG

• modal — Slider that triggers a blocking computation on release, A titled dialog whose body holds view-based controls

• modes — Auto-fit, explicit, and partial camera modes

• modulus — Creating and configuring an Algebra, Integer GA with two different moduli (NTRU style), Integer GA with a single modulus (Path C)

• Motor — Full conformal (N3) operators: Rotors, Motors, Inversions, Gunn/Dorst PGA 3D geometry with plane‑based representation, Rotor, Translator, Motor, Dilator visualization, Drive a VizGroup transform from a BasisN3 Motor

• multi-pane — Three scenes side-by-side in one horizontal split

• multi-scene — Two named scenes, each shown in its own browser tab

• multilinear — multilinear AffineExpression.get_tensor()

• multivector — The MV class: initialization, operators, and named methods

• multivector equation — Solve the general multivector equation A X = B with expressions

• MV — The MV class: initialization, operators, and named methods, MV input from PGA3 and N3, OPNS vs IPNS

• MVTensor — Product tensor basics — compute the geometric product via tensor contraction

• N3 — Null / conformal 3D algebra G(5, 0b10000), BladeMask named bases (auto display basis, composed names, with_basis), Expression.compile() for fast repeated evaluation, Project an N3 expression onto the Euclidean basis, multilinear AffineExpression.get_tensor(), get_tensor() (raw MVTensor) + get_array() (named bases), Full conformal (N3) entities: Spheres, Circles, Point Pairs, Full conformal (N3) operators: Rotors, Motors, Inversions, MV input from PGA3 and N3, OPNS vs IPNS

• named blades — Euclidean 3D geometric algebra G(3, 0), Three ways to work with named basis blades

• nested — Demonstrate nested VizGroup hierarchies

• nested loops — Nested animation loops honoring Ctrl+C

• nesting — Combine multiple SdfGroups (nesting + merging)

• noise — Stream a programmatic camera feed at 30 Hz over MJPEG, Export an animated noise image stream, Display a large image as an on-demand tile pyramid

• notebook — Animation, Export, Interactive Visualizer

• NTRU — Integer GA with two different moduli (NTRU style)

• null vector — Null / conformal 3D algebra G(5, 0b10000), Projective GA (PGA 3D)

• nullity — fit a conic/quadric from points with the GA primitives

• object model — the unified SDF object model in the standard viewer

• offline — Compare the three HTML delivery modes

• on_close — A titled dialog whose body holds view-based controls

• on_release — Slider that triggers a blocking computation on release

• OpenCV — a real calibrated image (BOP T-LESS) + 3D overview

• operators — The MV class: initialization, operators, and named methods

• OPNS — MV input from PGA3 and N3, OPNS vs IPNS

• orbit — Frame-by-frame animation at ~60 FPS

• orthographic — 2D orthographic view via View2DConfig, 2D fit-camera keeps the axes/grid undistorted

• outer product — lift a 2D conic into a 3D cone through an apex, fit a conic/quadric from points with the GA primitives

• overlay — fixed screen-space axes + grid overlay in 2D, Display a numpy image and draw pixel-coordinate overlays, 2D plots across a split view, one stretch mode per pane, Declarative control groups: overlay + 3D-anchored, Declarative control groups on a single-scene page, Group view chrome: leading icon, icon-only, borderless fold, Menus: per-pane overlay, sub-menus, and sub-sub-menus

• override — Load a custom theme and edit it live, A custom theme with a full button/checkbox override

• overrides — Global default styles and per-call overrides

• P2 — Least-squares homogeneous line fitting in P2

• P3 — Projective 3D geometric algebra G(4, 0), Least-squares line fitting in P3 with visualization, Projective 3D geometry: Points, Directions, Lines, Planes, Recover a rotor from 3D point ↔ projection-ray matches, Recover a rotor from point ↔ projection-ray matches

• pane swap — a live-updated camera view + pane swap

• panes — 2D plots across a split view, one stretch mode per pane, Three scenes side-by-side in one horizontal split, A single page showing multiple scenes in split panes

• paraboloid — draw arbitrary quadrics via entities + GA translation

• parent_id — Declarative control groups: overlay + 3D-anchored, Declarative control groups on a single-scene page

• PartialDisk — the Disk, PartialDisk, Box, Ellipsoid, Ellipse, and

• pencil — intersect two 2D conics (a point tuple), intersect two 3D quadrics (Perwass pencil)

• pendulum — a swinging pendulum with a live angle-vs-time plot

• performance — Expression.compile() for fast repeated evaluation

• persistence — Table auto-save: JSON load/save + CSV export

• PGA3 — Projective GA (PGA 3D), Gunn/Dorst PGA 3D geometry with plane‑based representation, MV input from PGA3 and N3, OPNS vs IPNS

• pinhole — a real calibrated image (BOP T-LESS) + 3D overview, a live-updated camera view + pane swap, a calibrated camera as a free orbit/pan/zoom view, calibrated camera view (image) + default 3D overview

• pixels — Display a numpy image and draw pixel-coordinate overlays

• Plane — Euclidean 3D geometry: Points, Planes, Reflections, Rotors, Projective 3D geometry: Points, Directions, Lines, Planes, All geometric entity types in one scene

• plane — Demo: Texture labels on planes with different align modes

• plane pair — degenerate quadric (plane pair) analysis + rendering, intersect two 3D quadrics (Perwass pencil)

• plane-based — Gunn/Dorst PGA 3D geometry with plane‑based representation

• playback — Animated HTML export with JS playback engine

• plot — Toggle one scene between a 2D and 3D view with a checkbox

• plotting — VisualizerApp with a sin/cos split view and draggable points, Custom axes and grid as explicit scene objects, annotations in a CoordinateSystem's data frame, logarithmic plotting with CoordinateSystem, 2D plots across a split view, one stretch mode per pane, a swinging pendulum with a live angle-vs-time plot, a plot on a tilted background plane in 3D

• PNG — Programmatic PNG screenshot at custom resolution

• Point — Euclidean 3D geometry: Points, Planes, Reflections, Rotors, Projective 3D geometry: Points, Directions, Lines, Planes, Frame-by-frame animation at ~60 FPS, Gravitational two-body simulation using only, All geometric entity types in one scene

• point — Demo: Drag a 3D point interactively with ActPoint, Demo: Drag a 3D point interactively with the mouse

• point correspondences — Best-fit rotor from point correspondences

• Point Pair — Full conformal (N3) entities: Spheres, Circles, Point Pairs

• point tuple — Q3 point tuples (1–7 points) in distinct colors

• point-line matching — Recover a rotor from 3D point ↔ projection-ray matches, Recover a rotor from point ↔ projection-ray matches

• PointPath — Moving point with a color-gradient trail

• points — Apply a fixed rotor to points with a Variable-backed expression, Rotate a list of points with a variable rotor and variable points

• PointSet — intersect two 2D conics (a point tuple), Q3 point tuples (1–7 points) in distinct colors

• polarity — per-object CSG combine modes

• polynomial — Polynomial (repeated-variable) expressions and affine sums

• presentation — Presentation figure export with FigureStyle

• primitive library — Composed SDF objects + the primitive library

• product tensor — Product tensor basics — compute the geometric product via tensor contraction, Product tensor basics — compute the geometric product via tensor contraction, Recover a rotor from point ↔ projection-ray matches, Product tensor basics — compute the geometric product via tensor contraction

• project_onto — Project an N3 expression onto the Euclidean basis

• projective — Projective 3D geometric algebra G(4, 0), Projective 3D geometry: Points, Directions, Lines, Planes

• projective geometric algebra — Projective GA (PGA 3D)

• pyramid — Display a large image as an on-demand tile pyramid

• Q2 — intersect two 2D conics (a point tuple)

• Q3 — degenerate quadric (plane pair) analysis + rendering, Q3 point tuples (1–7 points) in distinct colors, intersect two 3D quadrics (Perwass pencil)

• quadratic — multilinear AffineExpression.get_tensor()

• quadric — lift a 2D conic into a 3D cone through an apex, reconstruct a conic from 5 points and rotate it with a slider, intersect two 2D conics (a point tuple), fit a conic/quadric from points with the GA primitives, draw arbitrary quadrics via entities + GA translation, degenerate quadric (plane pair) analysis + rendering, Q3 point tuples (1–7 points) in distinct colors, reconstruct a quadric from 9 points and rotate it, reconstruct a quadric from 9 points and ray-render it, intersect two 3D quadrics (Perwass pencil), classify a noisy quadric within a tolerance

• Quadric3D — draw arbitrary quadrics via entities + GA translation

• quadric3d — reconstruct a quadric from 9 points and rotate it

• quadric_from_points — reconstruct a quadric from 9 points and ray-render it

• ray — draw arbitrary quadrics via entities + GA translation, reconstruct a quadric from 9 points and ray-render it

• rc — Named GA product functions over variables

• re-run — Interactive Visualizer

• rectangle — Display a numpy image and draw pixel-coordinate overlays, Add and drag rectangles on an image via a toolbar

• Rectangle2D — Display a numpy image and draw pixel-coordinate overlays

• redo — Editable table: column types, keyboard nav, undo/redo

• refine — reconstruct a conic from 5 points and rotate it with a slider, degenerate quadric (plane pair) analysis + rendering, reconstruct a quadric from 9 points and ray-render it, classify a noisy quadric within a tolerance

• Reflection — Euclidean 3D geometry: Points, Planes, Reflections, Rotors

• register_camera_stream — Stream a programmatic camera feed at 30 Hz over MJPEG

• register_image_pyramid — Display a large image as an on-demand tile pyramid

• register_theme — Load a custom theme and edit it live

• remove — Labels with custom styling, dynamic update, and removal

• remove_dialog — A titled dialog whose body holds view-based controls

• rename_var — Re-key variables so independent expressions merge

• repeated variables — Polynomial (repeated-variable) expressions and affine sums

• residual — Core solver API: inverse and general solve

• RGB — Custom image shader that rotates RGB vectors

• rotation — Custom image shader that rotates RGB vectors

• rotor — Bind a variable to a sub-expression (composition), Expression.compile() for fast repeated evaluation, Apply a fixed rotor to points with a Variable-backed expression, Rotate a list of points with a variable rotor and variable points, reconstruct a conic from 5 points and rotate it with a slider, reconstruct a quadric from 9 points and rotate it, Product tensor basics — compute the geometric product via tensor contraction

• Rotor — Euclidean 3D geometry: Points, Planes, Reflections, Rotors, Full conformal (N3) operators: Rotors, Motors, Inversions, Rotor, Translator, Motor, Dilator visualization

• rotor estimation — Recover a rotor from 3D point ↔ projection-ray matches, Best-fit rotor from point correspondences, Recover a rotor from point ↔ projection-ray matches

• runtime — Switch the viewer theme at runtime without a reload

• sandwich — Expression.compile() for fast repeated evaluation

• scene — Banners scoped to a named scene via VizSceneHandle, Declarative controls drive a sphere

• scene graph — Compose a detached scene subtree, then insert it, Drive a VizGroup transform from a BasisN3 Motor, Demonstrate VizGroup + direct transforms

• scenes — Two named scenes, each shown in its own browser tab, Demonstrate nested VizGroup hierarchies, Demonstrate VizGroup + direct transforms

• screenshot — Programmatic PNG screenshot at custom resolution

• SDF — isolate the SDF arrowhead (capped cone) placement, per-object CSG combine modes, Combine multiple SdfGroups (nesting + merging), Composed SDF objects + the primitive library, First vertical slice for the SDF viewer, SDF object groups with per-member CSG + independent animation, Animate a directional light around a sphere, every solid object as a mesh next to its SDF twin, the unified SDF object model in the standard viewer, Mix standard meshes with SDF-styled objects, Smooth CSG in the standard viewer

• SdfGroup — Combine multiple SdfGroups (nesting + merging)

• separator — Four toolbars, one per alignment, stacked in a vertical split

• set_default_color — Global default styles and per-call overrides

• set_theme — Switch the viewer theme at runtime without a reload

• shader — Display a numpy image and draw pixel-coordinate overlays

• show — Interactive Visualizer, Hide/show a sphere and its controls from a split layout

• show_dialog — A titled dialog whose body holds view-based controls, A file-selection view, embedded and in a dialog box

• signature — Creating and configuring an Algebra

• simulation — Gravitational two-body simulation using only

• single scene — Declarative control groups on a single-scene page

• singleton — Interactive Visualizer

• singular — Core solver API: inverse and general solve

• Size — A titled dialog whose body holds view-based controls, A tour of StackView/SplitView spacing, alignment, and flex

• sizing — A tour of StackView/SplitView spacing, alignment, and flex

• slider — reconstruct a conic from 5 points and rotate it with a slider, reconstruct a quadric from 9 points and rotate it, Two Spheres Intersection — Interactive Controls Demo (IPNS), Slider that triggers a blocking computation on release, Showcase every interactive control in one app, Controls styled from the extracted theme CSS files, Hide/show a sphere and its controls from a split layout, Four toolbars, one per alignment, stacked in a vertical split

• SliderView — Declarative controls drive a sphere

• smooth CSG — Smooth CSG in the standard viewer

• smooth_intersection — Smooth CSG in the standard viewer

• smooth_union — Smooth CSG in the standard viewer

• smoothness — Smooth CSG in the standard viewer

• snapshot — Self-contained HTML and glTF export, Export

• solve — Solve a single-linear-map AffineExpression, Solve the general multivector equation A X = B with expressions

• solve_lsq — Core solver API: inverse and general solve

• solver — Core solver API: inverse and general solve, Core solver API: inverse and general solve, Core solver API: inverse and general solve, Least-squares homogeneous line fitting in P2, Recover a rotor from 3D point ↔ projection-ray matches, Best-fit rotor from point correspondences

• sp — Named GA product functions over variables

• space_dim — Toggle one scene between a 2D and 3D view with a checkbox

• Sphere — Full conformal (N3) entities: Spheres, Circles, Point Pairs, All geometric entity types in one scene

• sphere — Demo: Texture labels on spheres using plain text and KaTeX formulas, Animate a directional light around a sphere, Hide/show a sphere and its controls from a split layout

• spheres — Two Spheres Intersection — Interactive Controls Demo (IPNS)

• split view — VisualizerApp with a sin/cos split view and draggable points, a real calibrated image (BOP T-LESS) + 3D overview, a live-updated camera view + pane swap, a calibrated camera as a free orbit/pan/zoom view, calibrated camera view (image) + default 3D overview, Add and drag rectangles on an image via a toolbar, 2D plots across a split view, one stretch mode per pane, Hide/show a sphere and its controls from a split layout, An editable data table beside a 3D scene, Four toolbars, one per alignment, stacked in a vertical split, A tour of StackView/SplitView spacing, alignment, and flex, Three scenes side-by-side in one horizontal split, A single page showing multiple scenes in split panes, Settable label and markdown panes in a vertical split, A live, auto-scrolling two-column log in a split pane

• stack view — A tour of StackView/SplitView spacing, alignment, and flex

• StackView — A titled dialog whose body holds view-based controls

• standard viewer — the unified SDF object model in the standard viewer

• stream — Stream a programmatic camera feed at 30 Hz over MJPEG, Export an animated noise image stream

• streaming — a live-updated camera view + pane swap, A live, auto-scrolling two-column log in a split pane

• stretch — 2D plots across a split view, one stretch mode per pane

• styled objects — Mix standard meshes with SDF-styled objects

• styling — Global default styles and per-call overrides

• sub-expression — Bind a variable to a sub-expression (composition)

• sub-menu — Menus: per-pane overlay, sub-menus, and sub-sub-menus

• sub-sub-menu — Menus: per-pane overlay, sub-menus, and sub-sub-menus

• submenu — A menu bar with a File → Open… file dialog

• SVD — fit a conic/quadric from points with the GA primitives

• sweep — Nested animation loops honoring Ctrl+C

• switch view — Toggle one scene between a 2D and 3D view with a checkbox

• table — An editable tabular-data control driven by the backend, Editable table: column types, keyboard nav, undo/redo, A TableView with a column-fed enum and a backend-fed enum, Table auto-save: JSON load/save + CSV export, An editable data table beside a 3D scene

• TableView — An editable tabular-data control driven by the backend, Editable table: column types, keyboard nav, undo/redo, A TableView with a column-fed enum and a backend-fed enum, Table auto-save: JSON load/save + CSV export, An editable data table beside a 3D scene

• tabs — Two named scenes, each shown in its own browser tab

• tabular data — An editable tabular-data control driven by the backend, Editable table: column types, keyboard nav, undo/redo, A TableView with a column-fed enum and a backend-fed enum, Table auto-save: JSON load/save + CSV export, An editable data table beside a 3D scene

• tensor — Product tensor basics — compute the geometric product via tensor contraction, Product tensor basics — compute the geometric product via tensor contraction, Recover a rotor from point ↔ projection-ray matches, Product tensor basics — compute the geometric product via tensor contraction

• texture labels — Demo: Texture labels on planes with different align modes, Demo: Texture labels on spheres using plain text and KaTeX formulas

• theme — Controls styled from the extracted theme CSS files, Load a custom theme and edit it live, A custom theme with a full button/checkbox override, Switch the viewer theme at runtime without a reload

• theme switching — A custom theme with a full button/checkbox override

• themes — Load a custom theme and edit it live

• tiles — Display a large image as an on-demand tile pyramid

• tilted plane — a plot on a tilted background plane in 3D

• timeline — Keyframe timeline with fade-in and move

• title — Title overlay and Markdown + LaTeX annotation

• tokens — Load a custom theme and edit it live

• tolerance — classify a noisy quadric within a tolerance

• toolbar — Add and drag rectangles on an image via a toolbar, Four toolbars, one per alignment, stacked in a vertical split

• trail — Moving point with a color-gradient trail

• Transform — Drive a VizGroup transform from a BasisN3 Motor

• transforms — Demonstrate VizGroup + direct transforms

• Translator — Gunn/Dorst PGA 3D geometry with plane‑based representation, Rotor, Translator, Motor, Dilator visualization

• translator — lift a 2D conic into a 3D cone through an apex, draw arbitrary quadrics via entities + GA translation

• twist — BladeMask named bases (auto display basis, composed names, with_basis)

• TwistBivector — get_tensor() (raw MVTensor) + get_array() (named bases)

• two points — Demo: Drag TWO 3D points interactively with ActPoint, Demo: Drag TWO 2D points interactively with ActPoint

• two-body — Gravitational two-body simulation using only

• uint16 — Display a 16-bit image over the lossless (zlib) transport

• uint8 — Display an 8-bit image over the default (JPEG) transport

• underlay — fixed screen-space axes + grid overlay in 2D

• undo — Editable table: column types, keyboard nav, undo/redo

• uniform — Custom image shader that rotates RGB vectors, Display a numpy image and draw pixel-coordinate overlays

• unify — Re-key variables so independent expressions merge

• up vector — 3D projective camera via View3dConfig

• update — Labels with custom styling, dynamic update, and removal

• update in place — Animation

• variable — Expressions, variables, and DataArray bindings

• Variable — Multi-variable linear equations with Variables, Named GA product functions over variables, Project an N3 expression onto the Euclidean basis, Re-key variables so independent expressions merge, Apply a fixed rotor to points with a Variable-backed expression, Rotate a list of points with a variable rotor and variable points

• variables — Multi-variable linear equations with Variables

• View2DConfig — 2D orthographic view via View2DConfig, 2D camera, axes, and grid basics

• View3dConfig — 3D projective camera via View3dConfig

• visible — Hide/show a sphere and its controls from a split layout

• visualization — Least-squares line fitting in P3 with visualization

• visualization-only — the visualization-only Cylinder and Arc entities

• visualizer — Interactive Visualizer

• Visualizer — Demonstrates every banner/dialog kind

• VisualizerApp — Two Spheres Intersection — Interactive Controls Demo (IPNS), Slider that triggers a blocking computation on release, Showcase every interactive control in one app, A file chooser with a backend-driven file browser, An editable tabular-data control driven by the backend

• VizGroup — A chaotic double pendulum from nested VizGroups, Compose a detached scene subtree, then insert it, Drive a VizGroup transform from a BasisN3 Motor, Demonstrate nested VizGroup hierarchies, Demonstrate VizGroup + direct transforms

• VizSceneHandle — Banners scoped to a named scene via VizSceneHandle

• VizSceneObject — Compose a detached scene subtree, then insert it

• vp — Named GA product functions over variables

• weighted sum — Sum an AffineExpression over a batched variable

• wireframe — A custom theme with a full button/checkbox override

• with_basis — BladeMask named bases (auto display basis, composed names, with_basis)

• zlib — Display a 16-bit image over the lossless (zlib) transport

Topics

• Geometric Algebra
• Visualization