mesh.mcl

A circle centered at the origin in the XY plane. Apply stroke or fill operators to style it, and shift to reposition.

let Circle = |radius, samples = 64| ...

Copy

mesh c = fill{alpha{0.15} CYAN} stroke{CYAN, 2} Circle(1.4)

A square centered at the origin with sides parallel to the axes.

let Square = |width| ...

Copy

mesh box = fill{alpha{0.28} ORANGE} stroke{ORANGE, 2} Square(1.7)

An axis-aligned rectangle centered at the origin.

let Rect = |size| ...

Copy

mesh card = fill{alpha{0.22} BLUE} stroke{BLUE, 2} Rect([2.6, 1.4])

A directed arrow from start to end, with an arrowhead at the tip.

path_arc bends the shaft by rotating along a circular arc instead of a straight segment. Its sign is relative to normal; use 0 for a straight arrow.

let Arrow = |start = [0, 0, 0], end = [1, 0, 0], normal = 1b, path_arc = 0, tip_length = 1, tip_width = 1, double_headed = 0| ...

Copy

mesh straight = color{CYAN} Arrow(1.5l + 0.75u, 1.5r + 0.75u)
mesh curved = color{ORANGE} Arrow(1.5l, 1.5r, 1b, PI / 3)
mesh stubby = color{PURPLE} Arrow(1.5l + 0.85d, 1.5r + 0.85d, 1b, 0, 0.6, 1.7)

Sample a color function over a rectangular grid.

By default each visible cell gets one flat color sampled at the cell corner. Pass smooth = 1 to color vertices for smooth interpolation, or pass a callable as the fourth argument to use it as the mask while keeping flat colors. color_at receives (pos, [ix, iy]); mask receives pos.

let ColorGrid = |color_at, x_min_max_samples = [-1, 1, 21], y_min_max_samples = [-1, 1, 21], smooth = 0, mask = |pos| 1| ...

mesh heat = ColorGrid(|p, idx| hsv(norm(p) / 2, 0.7, 0.9), [-2, 2, 60], [-1, 1, 30])

Build a rectangular grid of line segments.

The result is one mesh with subdivided line topology, which makes later point_map and Trans operations smoother.

let LineGrid = |x_min_max_samples = [-1, 1, 21], y_min_max_samples = [-1, 1, 21], subdivision = 16| ...

Copy

mesh grid = stroke{LIGHT_GRAY} LineGrid([-2, 2, 9], [-1, 1, 5])

Sample a mesh-producing function over a rectangular field.

mesh_at receives (pos, [ix, iy]); mask receives pos. Calls are batched internally, so this is the preferred way to build repeated arrows/glyphs on a grid.

let Field = |mesh_at, x_min_max_samples = [-1, 1, 21], y_min_max_samples = [-1, 1, 21], mask = |pos| 1| ...

mesh arrows = Field(|p, idx| Arrow(p, p + 0.2 * normalize(p)), [-2, 2, 12], [-1, 1, 7])

Arrow vector field: an arrow at each grid point for the vector f(pos), with a length-normalisation mode and an optional colour-by-magnitude callback.

Thin wrapper over Field + Arrow. mode controls arrow length: "true" draws the raw vector; "normalized" (default) draws every arrow at length length; "clamped" draws the true direction with length capped at length. color_at receives (pos, magnitude) and returns an RGBA colour; leave it nil to keep the default arrow colour. mask receives pos.

let VectorField = |f, x_min_max_samples = [-1, 1, 11], y_min_max_samples = [-1, 1, 11], mode = "normalized", length = 0.15, color_at = nil, mask = |pos| 1, tip_length = 1, tip_width = 1| ...

Copy

mesh field = VectorField(|p| [-p[1], p[0], 0], [-2, 2, 13], [-2, 2, 13], "normalized", 0.18, |p, mag| [mag / 3, 0.4, 0.9, 1])

Plain text converted to mesh geometry.

Use Text for literal text. It still returns mesh geometry, so Write, Fade, tag_filter, and styling operators all apply. With the default font = nil, text is rendered through the existing LaTeX backend. Passing a string such as "Arial" uses system-font SVG outlines instead; a .ttf, .otf, .ttc, or .otc path is resolved relative to the scene file. Custom/system/font-file text fonts are not available in web runtimes yet; keep font = nil there. Apply text_tag{...} inside the text argument when only part of the rendered text should be addressable; apply tag{...} outside Text when the whole rendered label should share one identity. String escapes use %, not \: write %" for a quote, %% for a literal percent sign, and LaTeX-style backslashes directly.

let Text = |text, scale = 1, font = nil| ...

Copy

mesh title = center{UP} Text("Monocurl", 0.8)

Math text converted through TeX into mesh geometry.

Tex renders TeX math (the body is already in math mode -- no $). It takes a raw string or a list of fragments; the list is concatenated with no separator, so write " + " and other spacing as its own fragment. text_tag{...} fragments, and the raw \text_tag{1,2}{...} / \tagN{...} markers, become tagged mesh contours for tag_filter, filtered styling, and TagTrans.

Monocurl strings escape with %, not \, so LaTeX commands are written directly ("\frac{a}{b}"); use %% for a literal percent. For non-math document structure use Latex; for Typst's lighter syntax use Typst.

let Tex = |tex, scale = 1| ...

Copy

mesh eq = center{ORIGIN} Tex("P(A \mid B) = \frac{P(B \mid A)\,P(A)}{P(B)}", 0.9)

Typst markup and math compiled into mesh geometry (desktop only).

content is compiled by the bundled Typst engine, rendered to SVG, and converted to contours, so Write, Fade, TagTrans, tag_filter, and every styling operator behave exactly as they do for Tex. The page is shrink-wrapped (auto size, zero margin, transparent fill) so the geometry is cropped to the ink. Bundled fonts cover the Typst defaults: New Computer Modern for math, Libertinus Serif for text, DejaVu Sans Mono for code.

Reach for Typst over Tex when you want Typst's lighter math syntax (sum_(i=1)^n, mat(1, 0; 0, 1), cases(...)) or its prose markup (= Heading, *bold*, _italic_). Math lives in $...$; $ x $ with surrounding spaces is display style, $x$ is inline. Typst is not available in web runtimes -- a browser scene must use Tex or Text. #import, Typst packages, and file reads are not available to inline snippets.

Monocurl strings escape with %, not \, so Typst source is written directly ("$sum_(i=1)^n i$"); write %% for a literal percent and %n for a newline, since a string cannot span source lines. A list argument is joined with no separator -- ["= A", "= B"] becomes "= AB" -- so put the breaks in yourself: ["= Title", "%n%n", "body text"].

A fragment can be tagged three ways, all yielding ordinary mesh tags usable by tag_filter, filtered styling, and TagTrans:

• text_tag{...} list fragments ([text_tag{1} "$a^2$", " + ", text_tag{2} "$b^2$"]) -- the portable form shared with Tex, and the only one that accepts a multi-component tag such as text_tag{[2, 7]}.
• raw \tagN{...} or \text_tag{1,2}{...} markers inside the string.
• the native Typst helper tag(n, body) supplied by the preamble: "#tag(1)[alpha] beta #tag(2)[gamma]". Inside math keep the # and wrap the body in its own $...$: "$ #tag(1)[$a^2$] + b^2 $". n is a single component in 0..=255.

let Typst = |content, scale = 1| ...

Copy

# `%n%n` is a paragraph break; a Monocurl string cannot contain a real newline
mesh note = center{ORIGIN} Typst("= Pythagoras%n%nFor a right triangle, $a^2 + b^2 = c^2$.", 0.5)

Copy

# per-term colour via the native `#tag(n)[...]` helper; note the inner `$...$`
let palette = operator |t|
    color{PURPLE, |g| 3 in g}
    color{ORANGE, |g| 2 in g}
    color{BLUE, |g| 1 in g}
    t
mesh eq = center{ORIGIN} palette{} Typst("$ #tag(1)[$a^2$] + #tag(2)[$b^2$] = #tag(3)[$c^2$] $", 1)

Copy

# Typst math shines on dense notation
mesh series = center{ORIGIN} Typst("$ sum_(k=1)^n k = (n(n+1)) / 2 $", 1)

Give an equation or label fragment a stable identity before it is rendered to contours.

text_tag{tag} fragment is the tool for equation choreography: it marks a slice of a Text / Tex / Latex / Typst argument so that every contour the backend produces for that slice carries tag. Those tags are then ordinary mesh tags -- tag_filter, filtered color{...} / stroke{...}, and TagTrans all key off them -- so "the x^2 term" stays addressable across a whole slide sequence even as the glyphs move and reshape.

text_tag{...} goes inside the constructor and tags only its fragment; tag{...} goes outside and relabels the entire rendered mesh. A raw string can carry the markers directly instead: \text_tag{1,2}{...} or the shorthand \tagN{...}.

The argument is a list of fragments, and the backend concatenates them with no separator -- ["a", "b"] renders as ab. Put spacing inside the strings (" + ", "%n"), not between list entries.

Nesting is allowed and the innermost tag owns any overlapping contour, so text_tag{1} ["(", text_tag{2} "x", ")"] gives the parentheses tag 1 and the x tag 2. A tag may be a list for several identities at once (text_tag{[2, 10]}); text_tag{[]} is a valid empty tag list.

let text_tag = operator |target, tag| ...

Copy

# one palette keyed purely by tag, reused for every state of the equation
let palette = operator |t|
    color{MAGENTA, |g| 3 in g}
    color{ORANGE, |g| 2 in g}
    color{BLUE, |g| 1 in g}
    t
mesh eq = center{ORIGIN} palette{} Tex([text_tag{1} "x^2", " + ", text_tag{2} "2x", " + ", text_tag{3} "1"], 1)

Copy

# raw markers in a plain string, and a multi-identity tag on the "1"
mesh eq = center{ORIGIN} color{ORANGE, |g| 9 in g} Tex("\tag1{a} + \text_tag{9}{1}", 1)

Measurement marker drawn next to a target mesh.

Builds a stroke spanning the target's bounds perpendicular to dir, offset by buffer.

let Measure = |target, dir = 1d, buffer = 0.15| ...

mesh width = [seg, Measure(seg, DOWN), Label(seg, "w", DOWN)]

Pre-fill axis options on an axis constructor.

This is a configuration operator; compose it before Axis1d, Axis2d, or Axis3d. It uses set_default internally, so axis settings interpolate cleanly when the axis is animated.

let axis_style = operator |target, axis, min, max, axis_title = nil, tick_spacing = 0.25, major_tick_rate = 4, label_map = (|x| x), arrow_extrusion = 0.2, tick_placement = nil| ...

mesh axes = axis_style{"x", 0, 4, "x"} axis_style{"y", 0, 3, "y"} Axis2d()
mesh one_sided = axis_style{"x", 0, 4, "x", 1, 1, (|x| x), 0.2, "positive"} Axis2d()

A labelled number line: a friendlier Axis1d where every tick is labelled by default.

Thin convenience over Axis1d. Unlike Axis1d/Axis2d, major_tick_rate defaults to 1, so every tick gets a number. Pass label_map = nil for an unlabelled ruler, or a |value| ... callable (for example |x| Number(x, 1)) for custom tick text. Set axis_title for a label at the positive end.

let NumberLine = |min = -5, max = 5, tick_spacing = 1, major_tick_rate = 1, axis_title = nil, label_map = (|x| x), basis = 1r, color = [0, 0, 0, 1]| ...

Copy

mesh line = center{0.6u} NumberLine(-3, 3, 1)
mesh titled = center{0.9d} NumberLine(-3, 3, 1, 3, "t")

Two-dimensional coordinate axes, optionally with grid lines.

basis gives the scene-space x/y unit vectors for the graph. Use grid_color to draw grid lines; leave it nil for ticks only. Grid lines are already split into major/minor by each axis's major_tick_rate. In each axis style list, set the last slot (arrow_extrusion) to nil to hide that axis's arrowheads.

let Axis2d = |basis = [1r, 1u], color = [0, 0, 0, 1], grid_color = nil, x_axis = [-5, 5, nil, 0.25, 4, |x| x, 0.2], y_axis = [-5, 5, nil, 0.25, 4, |x| x, 0.2]| ...

Copy

mesh axes = axis_style{"x", -2, 2, "x"} axis_style{"y", -1, 3, "f(x)"} Axis2d()

Sample y = f(x) as a polyline in the XY plane.

Endpoints are included. Use in_space{...} to embed the graph into a custom axes coordinate system. Set fill to an RGBA colour to also shade the area between the curve and the x axis (this is ExplicitFuncDiff(f, |x| 0, ...) under the hood). Set endpoint_dots truthy to append visible Dots at the two ends. When either is used the result is a mesh list [ (fill,) curve (, dots) ] rather than a bare polyline. Where f(x) returns nil or a non-finite number (a pole, a hole, a piecewise gap), both the curve and the optional fill are split into separate pieces around the gap instead of drawing a vertical jump.

let ExplicitFunc = |f, x_min_max_samples = [-5, 5, 128], endpoint_dots = 0, fill = nil| ...

Copy

mesh graph = stroke{CYAN} ExplicitFunc(|x| sin(x), [-PI, PI, 160])
mesh shaded = stroke{CYAN} ExplicitFunc(|x| sin(x), [0, PI, 160], 0, [0.2, 0.6, 0.9, 0.4])

Translate a mesh by a vector.

Most primitive constructors are authored at the origin; shift is the lightweight way to place them without changing their local parameters.

let shift = operator |target, delta, filter = nil| ...

Copy

mesh home = fill{alpha{0.1} GRAY} stroke{GRAY, 2} Circle(0.5)
mesh moved = fill{alpha{0.28} CYAN} stroke{CYAN, 2} shift{1.9r + 0.9u} Circle(0.5)

Set stroke color and optional stroke width.

If stroke_width is nil, existing stroke widths are preserved. When you need a filter and no width change, call stroke{color, nil, filter}.

let stroke = operator |target, color, stroke_width = nil, filter = nil| ...

Copy

mesh outline = fill{CLEAR} stroke{CYAN, 2} Circle(1)

Set fill color.

Applies to filled surfaces and dots; use color{...} when you want to recolor fill, stroke, and dots together.

let fill = operator |target, color, filter = nil| ...

Copy

mesh disk = fill{alpha{0.2} BLUE} Circle(1)

Recolor both fill and stroke where applicable.

Useful for fading a whole mesh tree into a muted state without separately touching fill and stroke.

let color = operator |target, color, filter = nil| ...

mesh muted = color{LIGHT_GRAY, |tags| not (2 in tags)} group

Replace mesh tags, optionally filtered by existing tags.

Tags are stable identities for filters and tag-aware animations. A scalar tag becomes a one-element tag list; a list can give one mesh several identities. Use tag{...} after construction for whole mesh leaves. For text/Tex/LaTeX fragments, prefer text_tag{...} inside the constructor so only the generated contours for that fragment receive the tag.

let tag = operator |target, tag, filter = nil| [target, __monocurl__native__ op_retagged(target, |old| ...

mesh a = tag{1} fill{alpha{0.2} CYAN} Circle(0.6)
mesh b = tag{2} fill{alpha{0.2} ORANGE} shift{2r} Square(0.9)
slide "swap identities"
    a = tag{1} fill{alpha{0.2} CYAN} shift{2r} Circle(0.6)
    b = tag{2} fill{alpha{0.2} ORANGE} Square(0.9)
    play TagTrans(1)

Map every point of a mesh through a function.

The callback receives a 3-D point and should return a 3-D point. Callback invocations are batched internally for mesh-sized transforms.

let point_map = operator |target, f, filter = nil| ...

Copy

mesh lifted = point_map{|p| [p[0], p[1], p[0] * p[0]]} LineGrid()

Move a mesh so its center lies at a point.

Centers by bounding-box center, not by centroid.

let center = operator |target, center, filter = nil| ...

Copy

mesh title = center{1.2u} Text("Title", 0.8)

Move a mesh near one side of the camera frame.

Placement is camera-aware, so to_side{UP} means the top of the rendered frame rather than global +y when a camera is supplied.

let to_side = operator |target, dir = [0, 0, 0], buffer = 0.1, camera = nil, filter = nil| ...