About reactivity

Reactivity means that derived variables automatically recompute whenever their dependencies change. Define a scalar t, build angles and sizes from it, and every update to t propagates through the entire dependency chain instantly - no manual refresh needed.

A reactive square

The setup below builds a square whose size and rotation are both driven by a single parameter t:

Draw a square whose side and inclination depend on t:

• Define t = 0: t = \scalar 0
• Derive t + 1: t-plus-1 = \add t 1
• Derive rotation angle: angle = \mul t 90
• Derive side length: side = \mul 2 t-plus-1
• Draw the square: \square p0 side angle

---

Now change t and watch everything update:

• Set t to 0.1
• Set t to 1

t-plus-1, angle, side, and the square all recompute immediately. The entire chain is driven by a single value.

---

Animating t

Because everything depends on t, animating t animates the whole structure. The animation-speed variable controls how fast t changes each frame:

• Reset t to 0: t = \scalar 0
• Set animation speed: animation-speed = \scalar 0.001
• Animate t from 0 to 1: \animate t 1
• Animate t back to 0: \animate t 0

The square grows and rotates smoothly as t sweeps between 0 and 1 - driven entirely by two lines of derivation.

---

\copy: a non-reactive snapshot

\copy produces a static copy of an object's current state. The copy is detached from the reactive graph - upstream changes no longer reach it.

• Copy the current square: \copy poly0
• Update t - the copy stays frozen

The live square redraws; the copy does not move.

This pattern can be repeated to build up a sequence of snapshots at different values of t:

• Copy at current t
• Set t = 0.3
• Copy again
• Set t = 0.5
• Copy again
• Set t = 0.7
• Copy once more
• Set t = 1

The canvas now shows five static snapshots alongside the live square. None of the copies responded to any change in t.

---

\translate and \rotate also break reactivity

Transforming a reactive object with \translate or \rotate also cuts its reactive connection. The result is a new static object.

\translate

Start fresh, draw a line, and compute its midpoint:

• Clear the canvas
• Draw a line through a and b: \line a b
• Compute the midpoint of the line: m = \mid-point line0

At this point m is reactive - move a and m follows:

• Move a - m updates: a = \point 0 0

Now translate m:

• Translate m - reactivity is cut: \translate m 1 0
• Move a - m no longer reacts: a = \point -2 0

After \translate, m is a fixed point. Its dependency on a (through line0) is gone.

---

\rotate

• Clear the canvas
• Draw a line
• Compute the midpoint
• Rotate m around p0 - reactivity is cut: \rotate m p0 90
• Move a - m no longer reacts: a = \point -3 0

The outcome is the same: \rotate produces a new static result, detached from the reactive chain.

---

The rule is consistent: reactive objects stay reactive until a structural operation (\copy, \translate, \rotate) creates a new static result. Everything upstream continues to update normally - only the transformed or copied result is frozen.