pymations 0.0.0-stage → 0.1.0

package/pymations.py

@@ -0,0 +1,4346 @@
+# GENERATED by circuitry/scripts/sync-pymations-lib.mjs from src/lib/python-canvas/canvas-anim-py.ts (version 15).
+# Do not edit here: change it in Circuitry, then run the script.
+# Pymations is MIT licensed; see LICENSE.
+import sys, math, types, inspect
+
+VERSION = "15"
+_rt = sys.modules["pyctures"]
+H_ANIM = 6
+
+
+# ---------------------------------------------------------------- run state
+
+class _AnimState:
+    def __init__(self):
+        self.next_id = 1         # 0 is the camera frame
+        self.next_uid = 1        # updater ids
+        self.reset_sent = False
+        self.cfg = {}            # config values set this run
+        self.scene = None        # the implicit scene of a bare script
+        self.capture = None      # [builder target, ops] while .animate records
+        self.trace = None        # _Trace while an updater is being traced
+        self.building = False    # the Scene runner is recording construct()
+        self.rendered = set()    # Scene classes the file ran itself (render())
+        self.told = set()        # one-time notes already printed
+        self.section_sound = None  # a section's voice-over: the section lasts until it ends
+        self.scenes_run = 0        # Scene classes started (transitions go between them)
+        self.anim_t = 0.0        # timeline time of this frame (tick payload)
+        self.anim_v = None       # tracker id -> value at anim_t (tick payload), once sent
+        self.fallbacks = []      # updaters that run in Python every frame
+        self.canvases = []       # PycturesCanvas objects (drawn every frame)
+        self.objects = {}        # id -> mobject made this run
+        self.last_anim_t = None  # to notice a scrub back
+
+
+def _st():
+    st = getattr(_rt.S, "anim", None)
+    if st is None:
+        st = _AnimState()
+        _rt.S.anim = st
+    return st
+
+
+def _on_start(info):
+    _rt.S.anim = st = _AnimState()
+    _frame_info(st, info)
+
+
+def _frame_info(st, p):
+    if "anim_t" in p:
+        st.anim_t = float(p["anim_t"] or 0.0)
+    if "anim_v" in p:
+        st.anim_v = {int(k): v for k, v in (p["anim_v"] or {}).items()}
+
+
+def _before_frame(p):
+    """A tick's timeline time and tracker values, before any frame code runs."""
+    _frame_info(_st(), p)
+
+
+def _on_frame(p):
+    """Every frame (start and each tick): Python-run updaters and canvases."""
+    st = _st()
+    _frame_info(st, p)
+    if st.fallbacks and st.last_anim_t is not None and st.anim_t < st.last_anim_t:
+        # Scrubbed back: what Python-run dt updaters added no longer holds.
+        _call("live_clear")
+        for u in st.fallbacks:
+            u.last_t = None
+    st.last_anim_t = st.anim_t
+    for c in list(st.canvases):
+        c._redraw()
+    for u in list(st.fallbacks):
+        u.run(st)
+
+
+def _stays_live():
+    st = getattr(_rt.S, "anim", None)
+    return bool(st and (st.fallbacks or st.canvases))
+
+
+def _live_phase():
+    """Commands now come from a Pyctures loop (draw(), await frame(), an
+    event), not from the scene being recorded: they change the live scene."""
+    st = _st()
+    return bool(getattr(_rt.S, "live", False)) and not st.building
+
+
+def _tell(key, text):
+    st = _st()
+    if key not in st.told:
+        st.told.add(key)
+        print(text)
+
+
+def _reset_once():
+    """The first engine call of a run resets the engine, so a file that never
+    animates never touches it (its page has no engine)."""
+    st = _st()
+    if not st.reset_sent:
+        st.reset_sent = True
+        _rt._emit("call", 0, H_ANIM, "reset", [{}])
+
+
+def _call(method, *args):
+    if _st().trace is not None:
+        raise _Untraceable("it calls %s()" % method)
+    _reset_once()
+    _rt._emit("call", 0, H_ANIM, method, [_j(a) for a in args])
+
+
+class _Untraceable(Exception):
+    """An updater did something that cannot become a formula."""
+
+
+def _read(target, what, args=None):
+    """An awaitable engine value (engine.value), freed once it is read."""
+    _reset_once()
+    h = _rt._new_handle()
+    _rt._emit("call", h, H_ANIM, "value", [_j(target), what, _j(args)])
+    r = _rt._Read({"$h": h})
+    _rt.S.cmds.append(["free", 0, h])
+    return r
+
+
+# ---------------------------------------------------------------- values
+#
+# A value only the engine knows (c.get_center(), m.width, tracker.get_value(),
+# the time) is an Expr: a formula the engine works out. Maths on it builds a
+# bigger formula ({"$pt": tree} for points, {"$x": tree} for numbers, see
+# "Contract v2" in pyctures-animation.md), so placement and updaters run in the
+# browser. 'await e' reads the numbers; using one as a Python number (if, float,
+# print) needs that await.
+
+_LAZY_HINT = ("is worked out in the browser, so Python does not have its numbers yet. "
+              "Read them with  p = await <expression>  (in a Scene, write  async def construct(self))")
+
+
+def _lazy_error(what):
+    tr = _st().trace
+    if tr is not None and not tr.real:
+        raise _Untraceable("it uses %s as a Python number" % what)
+    if tr is not None:
+        raise _rt.PreviewValueError(
+            what + " is worked out in the browser, so an updater that runs in Python cannot use it as a "
+            "number. Test a ValueTracker's value or pymations.time() instead, or keep the maths in "
+            "np.where(...) so the browser works it out")
+    raise _rt.PreviewValueError(what + " " + _LAZY_HINT)
+
+
+def _num(v, what="a number"):
+    """A number argument: a float, or {"$x": …} when the engine works it out."""
+    if isinstance(v, Expr):
+        if v.shape != "s":
+            raise TypeError("expected %s, got a point" % what)
+        return v._enc()
+    try:
+        f = float(v)
+    except _Untraceable:
+        raise
+    except Exception:
+        raise TypeError("expected %s, got %r" % (what, v))
+    return f if f == f and f not in (float("inf"), float("-inf")) else 0.0
+
+
+def _is_sym(v):
+    return isinstance(v, Expr) or (isinstance(v, (list, tuple)) and any(isinstance(x, Expr) for x in v))
+
+
+def _j(v):
+    """Plain JSON for the engine."""
+    if v is None or isinstance(v, (bool, str)):
+        return v
+    if isinstance(v, int):
+        return v
+    if isinstance(v, float):
+        return v if v == v and v not in (float("inf"), float("-inf")) else None
+    if isinstance(v, Expr):
+        return v._enc()
+    if isinstance(v, Mobject):
+        return v._ref()
+    if isinstance(v, _Rate):
+        return v.name
+    if isinstance(v, (list, tuple)):
+        if any(isinstance(x, Expr) for x in v):
+            return {"$pt": _tree(v)}
+        return [_j(x) for x in v]
+    if isinstance(v, dict):
+        return {str(k): _j(x) for k, x in v.items()}
+    if isinstance(v, type):
+        return v.__name__
+    if callable(v):
+        return None
+    tolist = getattr(v, "tolist", None)   # numpy arrays and scalars
+    if tolist is not None:
+        return _j(tolist())
+    return str(v)
+
+
+class Vec(tuple):
+    """A 3D vector (UP, LEFT …) that does arithmetic like a numpy array."""
+    __slots__ = ()
+    __array_ufunc__ = None   # numpy hands its arithmetic with a Vec to us
+
+    def __new__(cls, x=0.0, y=0.0, z=0.0):
+        return tuple.__new__(cls, (float(x), float(y), float(z)))
+
+    @staticmethod
+    def of(v):
+        if isinstance(v, Vec):
+            return v
+        tolist = getattr(v, "tolist", None)
+        if tolist is not None:
+            v = tolist()
+        v = list(v)
+        if len(v) == 2:
+            v.append(0.0)
+        if len(v) != 3:
+            raise TypeError("a point needs 2 or 3 numbers, got %r" % (v,))
+        return Vec(_num(v[0]), _num(v[1]), _num(v[2]))
+
+    def _other(self, o):
+        if isinstance(o, Expr) or hasattr(type(o), "_t"):   # symbolic, or a mobject
+            return None
+        if isinstance(o, (int, float)) and not isinstance(o, bool):
+            return Vec(o, o, o)
+        try:
+            return Vec.of(o)
+        except Exception:
+            return None
+
+    def __add__(self, o):
+        o = self._other(o)
+        if o is None:
+            return NotImplemented
+        return Vec(self[0] + o[0], self[1] + o[1], self[2] + o[2])
+
+    __radd__ = __add__
+
+    def __sub__(self, o):
+        o = self._other(o)
+        if o is None:
+            return NotImplemented
+        return Vec(self[0] - o[0], self[1] - o[1], self[2] - o[2])
+
+    def __rsub__(self, o):
+        o = self._other(o)
+        if o is None:
+            return NotImplemented
+        return Vec(o[0] - self[0], o[1] - self[1], o[2] - self[2])
+
+    def __mul__(self, o):
+        o = self._other(o)
+        if o is None:
+            return NotImplemented
+        return Vec(self[0] * o[0], self[1] * o[1], self[2] * o[2])
+
+    __rmul__ = __mul__
+
+    def __truediv__(self, o):
+        o = self._other(o)
+        if o is None:
+            return NotImplemented
+        return Vec(self[0] / o[0], self[1] / o[1], self[2] / o[2])
+
+    def __neg__(self):
+        return Vec(-self[0], -self[1], -self[2])
+
+    def __pos__(self):
+        return self
+
+    def __abs__(self):
+        return math.sqrt(self[0] ** 2 + self[1] ** 2 + self[2] ** 2)
+
+    def tolist(self):
+        return list(self)
+
+    def __repr__(self):
+        return "Vec(%g, %g, %g)" % self
+
+
+
+
+def _shape_of(v):
+    if isinstance(v, Expr):
+        return v.shape
+    if isinstance(v, (int, float)) and not isinstance(v, bool):
+        return "s"
+    return "v"
+
+
+_UFUNCS = {
+    "add": "add", "subtract": "sub", "multiply": "mul", "true_divide": "div", "divide": "div",
+    "power": "pow", "remainder": "mod", "mod": "mod", "negative": "neg",
+    "sin": "sin", "cos": "cos", "tan": "tan", "arcsin": "asin", "arccos": "acos", "arctan": "atan",
+    "arctan2": "atan2", "sinh": "sinh", "cosh": "cosh", "tanh": "tanh", "exp": "exp", "log": "log",
+    "log10": "log10", "log2": "log2", "sqrt": "sqrt", "absolute": "abs", "fabs": "abs", "floor": "floor",
+    "ceil": "ceil", "rint": "round", "sign": "sign", "minimum": "min", "maximum": "max", "fmin": "min",
+    "fmax": "max", "hypot": "hypot", "degrees": "degrees", "radians": "radians", "rad2deg": "degrees",
+    "deg2rad": "radians", "less": "lt", "less_equal": "le", "greater": "gt", "greater_equal": "ge",
+    "equal": "eq", "not_equal": "ne",
+}
+# Our names → the engine's formula nodes (Contract v2, as the engine evaluates them).
+_BINOPS = {"add": "+", "sub": "-", "mul": "*", "div": "/", "pow": "**", "mod": "%"}
+_CMPS = {"lt": "<", "le": "<=", "gt": ">", "ge": ">=", "eq": "==", "ne": "!="}
+_FN_NAMES = {"asin": "arcsin", "acos": "arccos", "atan": "arctan", "atan2": "arctan2", "degrees": "deg",
+             "radians": "rad"}
+
+
+def _fn(name, *args):
+    """name(args) as a formula when any arg is symbolic."""
+    shape = "v" if any(_shape_of(a) == "v" for a in args) and name != "norm" else "s"
+    if name in _BINOPS:
+        return Expr([_BINOPS[name]] + [_tree(a) for a in args], shape)
+    if name == "neg":
+        return Expr(["neg", _tree(args[0])], shape)
+    if name in _CMPS:
+        return Expr(["cmp", _CMPS[name], _tree(args[0]), _tree(args[1])], shape)
+    if name == "hypot":
+        a, b = args
+        return _fn("sqrt", _fn("add", _fn("mul", a, a), _fn("mul", b, b)))
+    return Expr(["fn", _FN_NAMES.get(name, name)] + [_tree(a) for a in args], shape)
+
+
+class Expr:
+    """A number or point the engine works out (c.get_center(), m.width,
+    tracker.get_value(), axes.c2p(1, 2), the time …), and maths on it.
+    'await e' gives its value."""
+    __slots__ = ("tree", "shape")
+
+    def __init__(self, tree, shape="v"):
+        self.tree = tree
+        self.shape = shape
+
+    def _enc(self):
+        return {"$pt" if self.shape == "v" else "$x": self.tree}
+
+    def __add__(self, o):
+        return _fn("add", self, o)
+
+    def __radd__(self, o):
+        return _fn("add", o, self)
+
+    def __sub__(self, o):
+        return _fn("sub", self, o)
+
+    def __rsub__(self, o):
+        return _fn("sub", o, self)
+
+    def __mul__(self, o):
+        return _fn("mul", self, o)
+
+    def __rmul__(self, o):
+        return _fn("mul", o, self)
+
+    def __truediv__(self, o):
+        return _fn("div", self, o)
+
+    def __rtruediv__(self, o):
+        return _fn("div", o, self)
+
+    def __pow__(self, o):
+        return _fn("pow", self, o)
+
+    def __rpow__(self, o):
+        return _fn("pow", o, self)
+
+    def __mod__(self, o):
+        return _fn("mod", self, o)
+
+    def __rmod__(self, o):
+        return _fn("mod", o, self)
+
+    def __neg__(self):
+        return _fn("neg", self)
+
+    def __pos__(self):
+        return self
+
+    def __abs__(self):
+        return _fn("abs", self)
+
+    def __round__(self, n=None):
+        return _fn("round", self)
+
+    def __lt__(self, o):
+        return _fn("lt", self, o)
+
+    def __le__(self, o):
+        return _fn("le", self, o)
+
+    def __gt__(self, o):
+        return _fn("gt", self, o)
+
+    def __ge__(self, o):
+        return _fn("ge", self, o)
+
+    def __getitem__(self, i):
+        if self.shape != "v":
+            _lazy_error("this number")
+        if isinstance(i, slice):
+            return [self[k] for k in range(3)[i]]
+        return Expr(["idx", self.tree, int(i) % 3], "s")
+
+    def __iter__(self):
+        if self.shape != "v":
+            _lazy_error("this number")
+        return iter([self[0], self[1], self[2]])
+
+    def __len__(self):
+        if self.shape != "v":
+            _lazy_error("this number")
+        return 3
+
+    def _no(self, *a):
+        _lazy_error("this point" if self.shape == "v" else "this value")
+
+    __float__ = __int__ = __index__ = __bool__ = __complex__ = _no
+
+    def __format__(self, spec):
+        self._no()
+
+    def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
+        name = _UFUNCS.get(ufunc.__name__)
+        if method != "__call__" or name is None or kwargs.get("out") is not None:
+            return NotImplemented
+        return _fn(name, *[_unarray(x) for x in inputs])
+
+    def __array_function__(self, func, types_, args, kwargs):
+        name = func.__name__
+        if name == "clip":
+            return _fn("clip", _unarray(args[0]), *[_unarray(a) for a in args[1:3]])
+        if name == "norm":
+            return _fn("norm", _unarray(args[0]))
+        if name == "where":
+            return Expr(["where", _tree(args[0]), _tree(args[1]), _tree(args[2])],
+                        "v" if "v" in (_shape_of(args[1]), _shape_of(args[2])) else "s")
+        if name in ("array", "asarray"):
+            return args[0]
+        return NotImplemented
+
+    def __await__(self):
+        t = self.tree
+        if self.shape == "v":
+            v = yield from _read(0, "point", self._enc()).__await__()
+            return Vec.of(v)
+        if t[0] == "get" and len(t) == 3:
+            return (yield from _read(t[1], t[2]).__await__())
+        if t[0] == "val":
+            return (yield from _read(t[1], "value").__await__())
+        return (yield from _read(0, "number", self._enc()).__await__())
+
+    def __repr__(self):
+        return "<%s worked out in the browser>" % ("point" if self.shape == "v" else "value")
+
+
+def _unarray(v):
+    tolist = getattr(v, "tolist", None)
+    if tolist is not None and not isinstance(v, (Expr, Vec)):
+        v = tolist()
+    return v
+
+
+def Point(tree):
+    """A point the engine works out, from its formula."""
+    return Expr(tree, "v")
+
+
+def _tree(v):
+    if isinstance(v, Expr):
+        return v.tree
+    if isinstance(v, Mobject):
+        return ["of", v._ref(), "center"]
+    if isinstance(v, (int, float)) and not isinstance(v, bool):
+        return float(v)
+    v = _unarray(v)
+    v = list(v)
+    if any(isinstance(x, Expr) for x in v):
+        while len(v) < 3:
+            v.append(0.0)
+        return ["v", [_tree(x) for x in v[:3]]]
+    return ["v", list(Vec.of(v))]
+
+
+def _P(v):
+    """A point argument: [x, y, z], or {"$pt": …} when the engine works it out."""
+    if v is None:
+        return None
+    if isinstance(v, Expr):
+        if v.shape != "v":
+            raise TypeError("expected a point, got a number")
+        return v._enc()
+    if isinstance(v, Mobject):
+        return {"$pt": ["of", v._ref(), "center"]}
+    if _is_sym(_unarray(v)):
+        return {"$pt": _tree(v)}
+    return list(Vec.of(v))
+
+
+def _MP(v):
+    """A mobject (its target) or a point."""
+    return v._embed() if isinstance(v, Mobject) else _P(v)
+
+
+def _coord(v):
+    """A coordinate inside a formula: a number, or the formula of a symbolic one."""
+    if isinstance(v, Expr):
+        return v.tree
+    return _num(v, "a coordinate")
+
+
+def _var(name, shape="s"):
+    """The time ["t"], an updater's step ["dt"], or a function's variable."""
+    if name in ("time", "dt"):
+        return Expr(["t"] if name == "time" else ["dt"], shape)
+    return Expr(["var", name], shape)
+
+
+def time():
+    """The animation's time in seconds: a formula inside an updater, the
+    timeline time of this frame inside a Pyctures loop."""
+    st = _st()
+    tr = st.trace
+    if tr is not None and not tr.real:
+        return _var("time")
+    if tr is not None or _live_phase():
+        return st.anim_t
+    return _var("time")
+
+
+_ANCHORS = {(0, 0): "center", (0, 1): "top", (0, -1): "bottom", (-1, 0): "left",
+            (1, 0): "right", (-1, 1): "UL", (1, 1): "UR", (-1, -1): "DL", (1, -1): "DR"}
+
+
+def _anchor(direction):
+    d = Vec.of(direction)
+    sx = (d[0] > 1e-9) - (d[0] < -1e-9)
+    sy = (d[1] > 1e-9) - (d[1] < -1e-9)
+    return _ANCHORS[(sx, sy)]
+
+
+# ---------------------------------------------------------------- constants
+
+ORIGIN = Vec(0, 0, 0)
+UP, DOWN, LEFT, RIGHT = Vec(0, 1, 0), Vec(0, -1, 0), Vec(-1, 0, 0), Vec(1, 0, 0)
+IN, OUT = Vec(0, 0, -1), Vec(0, 0, 1)
+UL, UR, DL, DR = UP + LEFT, UP + RIGHT, DOWN + LEFT, DOWN + RIGHT
+X_AXIS, Y_AXIS, Z_AXIS = Vec(1, 0, 0), Vec(0, 1, 0), Vec(0, 0, 1)
+PI = math.pi
+TAU = 2 * math.pi
+DEGREES = TAU / 360
+SMALL_BUFF = 0.1
+MED_SMALL_BUFF = 0.25
+MED_LARGE_BUFF = 0.5
+LARGE_BUFF = 1.0
+DEFAULT_MOBJECT_TO_EDGE_BUFFER = MED_LARGE_BUFF
+DEFAULT_MOBJECT_TO_MOBJECT_BUFFER = MED_SMALL_BUFF
+DEFAULT_STROKE_WIDTH = 4
+DEFAULT_DOT_RADIUS = 0.08
+DEFAULT_SMALL_DOT_RADIUS = 0.04
+DEFAULT_ARROW_TIP_LENGTH = 0.35
+DEFAULT_FONT_SIZE = 48
+SCALE_FACTOR_PER_FONT_POINT = 1 / 960
+DEFAULT_DASH_LENGTH = 0.05
+DEFAULT_WAIT_TIME = 1.0
+NORMAL, BOLD, ITALIC, OBLIQUE = "NORMAL", "BOLD", "ITALIC", "OBLIQUE"
+
+_COLORS = dict(
+    WHITE="#FFFFFF", BLACK="#000000",
+    GRAY_A="#DDDDDD", GRAY_B="#BBBBBB", GRAY_C="#888888", GRAY_D="#444444", GRAY_E="#222222",
+    LIGHTER_GRAY="#DDDDDD", LIGHT_GRAY="#BBBBBB", GRAY="#888888", DARK_GRAY="#444444", DARKER_GRAY="#222222",
+    PURE_RED="#FF0000", PURE_GREEN="#00FF00", PURE_BLUE="#0000FF",
+    PURE_CYAN="#00FFFF", PURE_MAGENTA="#FF00FF", PURE_YELLOW="#FFFF00",
+    BLUE_A="#C7E9F1", BLUE_B="#9CDCEB", BLUE_C="#58C4DD", BLUE_D="#29ABCA", BLUE_E="#236B8E",
+    BLUE="#58C4DD", DARK_BLUE="#236B8E",
+    TEAL_A="#ACEAD7", TEAL_B="#76DDC0", TEAL_C="#5CD0B3", TEAL_D="#55C1A7", TEAL_E="#49A88F", TEAL="#5CD0B3",
+    GREEN_A="#C9E2AE", GREEN_B="#A6CF8C", GREEN_C="#83C167", GREEN_D="#77B05D", GREEN_E="#699C52",
+    GREEN="#83C167",
+    YELLOW_A="#FFF1B6", YELLOW_B="#FFEA94", YELLOW_C="#F7D96F", YELLOW_D="#F4D345", YELLOW_E="#E8C11C",
+    YELLOW="#F7D96F",
+    GOLD_A="#F7C797", GOLD_B="#F9B775", GOLD_C="#F0AC5F", GOLD_D="#E1A158", GOLD_E="#C78D46", GOLD="#F0AC5F",
+    RED_A="#F7A1A3", RED_B="#FF8080", RED_C="#FC6255", RED_D="#E65A4C", RED_E="#CF5044", RED="#FC6255",
+    MAROON_A="#ECABC1", MAROON_B="#EC92AB", MAROON_C="#C55F73", MAROON_D="#A24D61", MAROON_E="#94424F",
+    MAROON="#C55F73",
+    PURPLE_A="#CAA3E8", PURPLE_B="#B189C6", PURPLE_C="#9A72AC", PURPLE_D="#715582", PURPLE_E="#644172",
+    PURPLE="#9A72AC",
+    PINK="#D147BD", LIGHT_PINK="#DC75CD", ORANGE="#FF862F",
+    LIGHT_BROWN="#CD853F", DARK_BROWN="#8B4513", GRAY_BROWN="#736357",
+    LOGO_WHITE="#ECE7E2", LOGO_GREEN="#87C2A5", LOGO_BLUE="#525893", LOGO_RED="#E07A5F", LOGO_BLACK="#343434",
+)
+for _k in list(_COLORS):
+    if "GRAY" in _k:
+        _COLORS[_k.replace("GRAY", "GREY")] = _COLORS[_k]
+globals().update(_COLORS)
+
+
+def _color(c):
+    if c is None:
+        return None
+    if isinstance(c, str):
+        return _COLORS.get(c.upper(), c) if not c.startswith("#") else c
+    if isinstance(c, (list, tuple)) and c and not isinstance(c[0], (int, float)):
+        return [_color(x) for x in c]
+    if isinstance(c, (list, tuple)) and len(c) in (3, 4):
+        r, g, b = (max(0, min(255, int(round(float(x) * 255)))) for x in c[:3])
+        return "#%02X%02X%02X" % (r, g, b)
+    return str(c)
+
+
+def _rgb(c):
+    c = _color(c)
+    if not (isinstance(c, str) and c.startswith("#") and len(c) == 7):
+        raise ValueError("expected a colour like '#FC6255', got %r" % (c,))
+    return [int(c[i:i + 2], 16) / 255.0 for i in (1, 3, 5)]
+
+
+def rgb_to_color(rgb):
+    return _color(list(rgb))
+
+
+def color_to_rgb(color):
+    return _rgb(color)
+
+
+def interpolate_color(a, b, alpha):
+    ra, rb = _rgb(a), _rgb(b)
+    return rgb_to_color([x + (y - x) * alpha for x, y in zip(ra, rb)])
+
+
+def color_gradient(colors, length):
+    colors = [_color(c) for c in colors]
+    if length <= 1 or len(colors) == 1:
+        return colors[:1] * max(1, length)
+    out = []
+    for i in range(length):
+        t = i / (length - 1) * (len(colors) - 1)
+        k = min(int(t), len(colors) - 2)
+        out.append(interpolate_color(colors[k], colors[k + 1], t - k))
+    return out
+
+
+def average_color(*colors):
+    rgbs = [_rgb(c) for c in colors]
+    return rgb_to_color([sum(x) / len(rgbs) for x in zip(*rgbs)])
+
+
+def ManimColor(value):
+    return _color(value)
+
+
+# ---------------------------------------------------------------- rate functions
+
+class _Rate:
+    """A named rate function: callable here, sent to the engine by name."""
+    __slots__ = ("name", "fn")
+
+    def __init__(self, name, fn):
+        self.name = name
+        self.fn = fn
+
+    def __call__(self, t, *a, **k):
+        return self.fn(t, *a, **k)
+
+    def __repr__(self):
+        return "<rate function %s>" % self.name
+
+
+def _rate(v):
+    """A rate_func argument: its name, or 65 samples of a Python function."""
+    if v is None:
+        return None
+    if isinstance(v, _Rate):
+        return v.name
+    if isinstance(v, str):
+        return v
+    if callable(v):
+        return {"samples": [_num(v(i / 64.0)) for i in range(65)]}
+    raise TypeError("rate_func must be a rate function such as smooth or linear, got %r" % (v,))
+
+
+def _sigmoid(x):
+    return 1.0 / (1.0 + math.exp(-x))
+
+
+def _smooth(t, inflection=10.0):
+    e = _sigmoid(-inflection / 2.0)
+    return min(max((_sigmoid(inflection * (t - 0.5)) - e) / (1 - 2 * e), 0.0), 1.0)
+
+
+def _there_and_back(t, inflection=10.0):
+    return _smooth(2 * t if t < 0.5 else 2 * (1 - t), inflection)
+
+
+def _there_and_back_with_pause(t, pause_ratio=1.0 / 3):
+    a = 1.0 / pause_ratio
+    if t < 0.5 - pause_ratio / 2:
+        return _smooth(a * t)
+    if t < 0.5 + pause_ratio / 2:
+        return 1.0
+    return _smooth(a - a * t)
+
+
+def _running_start(t, pull_factor=-0.5):
+    # A cubic Bezier through 0, 0, pull, pull, 1, 1, 1 evaluated at t.
+    pts = [0, 0, pull_factor, pull_factor, 1, 1, 1]
+    n = len(pts) - 1
+    return sum(math.comb(n, k) * (1 - t) ** (n - k) * t ** k * p for k, p in enumerate(pts))
+
+
+def _bounce_out(t):
+    n, d = 7.5625, 2.75
+    if t < 1 / d:
+        return n * t * t
+    if t < 2 / d:
+        t -= 1.5 / d
+        return n * t * t + 0.75
+    if t < 2.5 / d:
+        t -= 2.25 / d
+        return n * t * t + 0.9375
+    t -= 2.625 / d
+    return n * t * t + 0.984375
+
+
+_c1 = 1.70158
+_c2 = _c1 * 1.525
+_c3 = _c1 + 1
+_c4 = TAU / 3
+_c5 = TAU / 4.5
+
+_RATES = dict(
+    linear=lambda t: t,
+    smooth=_smooth,
+    smoothstep=lambda t: 0.0 if t <= 0 else (1.0 if t >= 1 else 3 * t ** 2 - 2 * t ** 3),
+    smootherstep=lambda t: 0.0 if t <= 0 else (1.0 if t >= 1 else 6 * t ** 5 - 15 * t ** 4 + 10 * t ** 3),
+    smoothererstep=lambda t: 0.0 if t <= 0 else (1.0 if t >= 1 else
+                                                  35 * t ** 4 - 84 * t ** 5 + 70 * t ** 6 - 20 * t ** 7),
+    rush_into=lambda t, inflection=10.0: 2 * _smooth(t / 2.0, inflection),
+    rush_from=lambda t, inflection=10.0: 2 * _smooth(t / 2.0 + 0.5, inflection) - 1,
+    slow_into=lambda t: math.sqrt(max(0.0, 1 - (1 - t) * (1 - t))),
+    double_smooth=lambda t: 0.5 * _smooth(2 * t) if t < 0.5 else 0.5 * (1 + _smooth(2 * t - 1)),
+    there_and_back=_there_and_back,
+    there_and_back_with_pause=_there_and_back_with_pause,
+    running_start=_running_start,
+    wiggle=lambda t, wiggles=2: _there_and_back(t) * math.sin(wiggles * PI * t),
+    lingering=lambda t: _smooth(min(1.0, t / 0.8)),
+    exponential_decay=lambda t, half_life=0.1: 1 - math.exp(-t / half_life),
+    ease_in_sine=lambda t: 1 - math.cos(t * PI / 2),
+    ease_out_sine=lambda t: math.sin(t * PI / 2),
+    ease_in_out_sine=lambda t: -(math.cos(PI * t) - 1) / 2,
+    ease_in_quad=lambda t: t * t,
+    ease_out_quad=lambda t: 1 - (1 - t) * (1 - t),
+    ease_in_out_quad=lambda t: 2 * t * t if t < 0.5 else 1 - (-2 * t + 2) ** 2 / 2,
+    ease_in_cubic=lambda t: t ** 3,
+    ease_out_cubic=lambda t: 1 - (1 - t) ** 3,
+    ease_in_out_cubic=lambda t: 4 * t ** 3 if t < 0.5 else 1 - (-2 * t + 2) ** 3 / 2,
+    ease_in_quart=lambda t: t ** 4,
+    ease_out_quart=lambda t: 1 - (1 - t) ** 4,
+    ease_in_out_quart=lambda t: 8 * t ** 4 if t < 0.5 else 1 - (-2 * t + 2) ** 4 / 2,
+    ease_in_quint=lambda t: t ** 5,
+    ease_out_quint=lambda t: 1 - (1 - t) ** 5,
+    ease_in_out_quint=lambda t: 16 * t ** 5 if t < 0.5 else 1 - (-2 * t + 2) ** 5 / 2,
+    ease_in_expo=lambda t: 0.0 if t == 0 else 2 ** (10 * t - 10),
+    ease_out_expo=lambda t: 1.0 if t == 1 else 1 - 2 ** (-10 * t),
+    ease_in_out_expo=lambda t: (0.0 if t == 0 else 1.0 if t == 1 else
+                                2 ** (20 * t - 10) / 2 if t < 0.5 else (2 - 2 ** (-20 * t + 10)) / 2),
+    ease_in_circ=lambda t: 1 - math.sqrt(max(0.0, 1 - t * t)),
+    ease_out_circ=lambda t: math.sqrt(max(0.0, 1 - (t - 1) ** 2)),
+    ease_in_out_circ=lambda t: ((1 - math.sqrt(max(0.0, 1 - (2 * t) ** 2))) / 2 if t < 0.5 else
+                                (math.sqrt(max(0.0, 1 - (-2 * t + 2) ** 2)) + 1) / 2),
+    ease_in_back=lambda t: _c3 * t ** 3 - _c1 * t * t,
+    ease_out_back=lambda t: 1 + _c3 * (t - 1) ** 3 + _c1 * (t - 1) ** 2,
+    ease_in_out_back=lambda t: (((2 * t) ** 2 * ((_c2 + 1) * 2 * t - _c2)) / 2 if t < 0.5 else
+                                ((2 * t - 2) ** 2 * ((_c2 + 1) * (t * 2 - 2) + _c2) + 2) / 2),
+    ease_in_elastic=lambda t: (t if t in (0, 1) else
+                               -(2 ** (10 * t - 10)) * math.sin((t * 10 - 10.75) * _c4)),
+    ease_out_elastic=lambda t: (t if t in (0, 1) else
+                                2 ** (-10 * t) * math.sin((t * 10 - 0.75) * _c4) + 1),
+    ease_in_out_elastic=lambda t: (t if t in (0, 1) else
+                                   -(2 ** (20 * t - 10) * math.sin((20 * t - 11.125) * _c5)) / 2 if t < 0.5 else
+                                   (2 ** (-20 * t + 10) * math.sin((20 * t - 11.125) * _c5)) / 2 + 1),
+    ease_in_bounce=lambda t: 1 - _bounce_out(1 - t),
+    ease_out_bounce=_bounce_out,
+    ease_in_out_bounce=lambda t: ((1 - _bounce_out(1 - 2 * t)) / 2 if t < 0.5 else
+                                  (1 + _bounce_out(2 * t - 1)) / 2),
+)
+rate_functions = types.SimpleNamespace()
+for _k, _f in _RATES.items():
+    globals()[_k] = _r = _Rate(_k, _f)
+    setattr(rate_functions, _k, _r)
+
+
+# ---------------------------------------------------------------- config
+
+def _frame_size():
+    cfg = _st().cfg
+    h = cfg.get("frame_height", 8.0)
+    return cfg.get("frame_width", h * 16.0 / 9.0), h
+
+
+class _Config:
+    """config(background=…, frame_height=…) or config.background_color = …"""
+    _ENGINE = {"background": "background", "background_color": "background",
+               "frame_height": "frame_height", "frame_width": "frame_width"}
+    _DEFAULTS = {"background_color": BLACK, "frame_height": 8.0, "pixel_width": 1920,
+                 "pixel_height": 1080, "frame_rate": 60, "transition": "none", "transition_time": 0.5}
+
+    def __call__(self, **kw):
+        for k, v in kw.items():
+            self[k] = v
+        return self
+
+    def __setitem__(self, k, v):
+        st = _st()
+        if k == "background":
+            k = "background_color"
+        st.cfg[k] = v
+        key = self._ENGINE.get(k)
+        if key is not None:
+            _call("config", {key: _color(v) if key == "background" else _num(v)})
+
+    def __getitem__(self, k):
+        cfg = _st().cfg
+        if k in cfg:
+            return cfg[k]
+        w, h = _frame_size()
+        extra = {"frame_width": w, "frame_x_radius": w / 2, "frame_y_radius": h / 2,
+                 "background": cfg.get("background_color", BLACK)}
+        if k in extra:
+            return extra[k]
+        return self._DEFAULTS.get(k)
+
+    def __setattr__(self, k, v):
+        self[k] = v
+
+    def __getattr__(self, k):
+        if k.startswith("__"):
+            raise AttributeError(k)
+        return self[k]
+
+    def __repr__(self):
+        return "config(%s)" % ", ".join("%s=%r" % kv for kv in _st().cfg.items())
+
+
+config = _Config()
+
+
+# ---------------------------------------------------------------- mobjects
+
+_STYLE = ("color", "fill_color", "fill_opacity", "stroke_color", "stroke_width",
+          "stroke_opacity", "opacity", "z_index", "background_stroke_color",
+          "background_stroke_width", "sheen_factor")
+_VSTYLE = {"color": WHITE, "fill_opacity": 0.0, "stroke_width": DEFAULT_STROKE_WIDTH}
+_FILLED = {"color": WHITE, "fill_opacity": 1.0, "stroke_width": 0}
+
+
+def _flat(items):
+    out = []
+    for m in items:
+        if isinstance(m, Mobject):
+            out.append(m)
+        elif isinstance(m, (list, tuple, types.GeneratorType)):
+            out.extend(_flat(m))
+        else:
+            raise TypeError("expected mobjects, such as Circle() or Text('Hi'), got %r" % (m,))
+    return out
+
+
+class Mobject:
+    """Anything on the stage. Methods return the mobject, so they chain."""
+
+    def __init__(self, **kwargs):
+        self._make("group", {}, kwargs, {})
+
+    # -- identity
+
+    def _make(self, kind, geom, kwargs, style=_VSTYLE, n=None, kids=None, extra=()):
+        st = _st()
+        self._path = None
+        self._kids = kids
+        self._n = n
+        self._tmpl = None
+        props = dict(style)
+        for k, v in kwargs.items():
+            if v is None or (callable(v) and not isinstance(v, (_Rate, type))):
+                continue
+            props[k] = _color(v) if k.endswith("color") and not isinstance(v, Expr) else v
+        props.update(geom)
+        self.z_index = props.get("z_index", 0)
+        tr = st.trace
+        if tr is not None:
+            # Made inside an updater: a TEMPLATE the engine builds every frame.
+            tr.next_key += 1
+            self._id = None
+            self._tmpl = {"key": tr.next_key, "kind": kind, "props": props, "ops": []}
+            return
+        self._id = st.next_id
+        st.next_id += 1
+        st.objects[self._id] = self
+        _call("make", self._id, kind, props, *extra)
+
+    def _t(self):
+        """This object as the target of a command."""
+        tm = self.__dict__.get("_tmpl")
+        if tm is not None:
+            return {"tmpl": tm["key"]}
+        return self._id if self._path is None else {"id": self._id, "path": list(self._path)}
+
+    _ref = _t
+
+    def _embed(self):
+        """This object as an argument: a template travels whole."""
+        tm = self.__dict__.get("_tmpl")
+        return tm if tm is not None else self._t()
+
+    def _op(self, name, args):
+        st = _st()
+        tm = self.__dict__.get("_tmpl")
+        if tm is not None:
+            tm["ops"].append([name, args])
+            return self
+        cap = st.capture
+        if cap is not None:
+            op = [name, args]
+            if cap[0] != self._t():
+                op.append(self._t())
+            cap[1].append(op)
+            return self
+        tr = st.trace
+        if tr is not None:
+            tr.ops.append([name, args, self._t()])
+            return self
+        if _live_phase():
+            # From a Pyctures loop: a change to the live scene, on top of the timeline.
+            _live_op(name, args, self._t())
+            return self
+        _call("op", self._t(), name, args)
+        return self
+
+    @property
+    def animate(self):
+        return _Animate(self)
+
+    def __bool__(self):
+        return True
+
+    def __repr__(self):
+        return "<%s #%s>" % (type(self).__name__, self._t())
+
+    # -- parts
+
+    def _count(self):
+        if self._kids is not None:
+            return len(self._kids)
+        return self._n
+
+    def __len__(self):
+        n = self._count()
+        if n is None:
+            raise TypeError("the parts of a %s are only known in the browser; index them "
+                            "directly, such as m[0]" % type(self).__name__)
+        return n
+
+    def __iter__(self):
+        return iter([self[i] for i in range(len(self))])
+
+    def __getitem__(self, i):
+        if isinstance(i, slice):
+            return VGroup(*[self[k] for k in range(len(self))[i]])
+        if self._kids is not None:
+            return self._kids[i]
+        i = int(i)
+        if i < 0:
+            i += len(self)
+        if self._n is not None and not 0 <= i < self._n:
+            raise IndexError("%s has %d parts; there is no part %d" % (type(self).__name__, self._n, i))
+        return _Part(self, i)
+
+    @property
+    def submobjects(self):
+        return list(self)
+
+    def copy(self):
+        st = _st()
+        m = object.__new__(_Copy if isinstance(self, _Part) else type(self))
+        m.__dict__.update(self.__dict__)
+        m.__dict__.pop("updaters", None)
+        tr = st.trace
+        if tr is not None:
+            # Inside an updater: a template that copies the object every frame.
+            tr.next_key += 1
+            m._id, m._path, m._ptmpl = None, None, None
+            m._tmpl = {"key": tr.next_key, "kind": "copy", "props": {"mobject": self._embed()}, "ops": []}
+            return m
+        m._id = st.next_id
+        st.next_id += 1
+        m._path = None
+        if self._kids is not None:
+            m._n, m._kids = len(self._kids), None
+        _call("copy", m._id, self._t())
+        return m
+
+    def generate_target(self):
+        self.target = self.copy()
+        return self.target
+
+    def get_family(self):
+        return [self] + [f for k in (self._kids or ()) for f in k.get_family()]
+
+    # -- reading back (lazy)
+
+    def get_center(self):
+        return Point(["of", self._ref(), "center"])
+
+    def get_top(self):
+        return Point(["of", self._ref(), "top"])
+
+    def get_bottom(self):
+        return Point(["of", self._ref(), "bottom"])
+
+    def get_left(self):
+        return Point(["of", self._ref(), "left"])
+
+    def get_right(self):
+        return Point(["of", self._ref(), "right"])
+
+    def get_start(self):
+        return Point(["of", self._ref(), "start"])
+
+    def get_end(self):
+        return Point(["of", self._ref(), "end"])
+
+    def get_corner(self, direction):
+        return Point(["of", self._ref(), _anchor(direction)])
+
+    get_critical_point = get_edge_center = get_boundary_point = get_corner
+    get_center_of_mass = get_center
+
+    def get_x(self):
+        return Expr(["get", self._ref(), "x"], "s")
+
+    def get_y(self):
+        return Expr(["get", self._ref(), "y"], "s")
+
+    def get_z(self):
+        return Expr(["get", self._ref(), "z"], "s")
+
+    def get_width(self):
+        return Expr(["get", self._ref(), "width"], "s")
+
+    def get_height(self):
+        return Expr(["get", self._ref(), "height"], "s")
+
+    def get_color(self):
+        return Expr(["get", self._ref(), "color"], "s")
+
+    @property
+    def width(self):
+        return self.get_width()
+
+    @width.setter
+    def width(self, value):
+        self.scale_to_fit_width(value)
+
+    @property
+    def height(self):
+        return self.get_height()
+
+    @height.setter
+    def height(self, value):
+        self.scale_to_fit_height(value)
+
+    # -- placement
+
+    def shift(self, *vectors):
+        if not vectors:
+            return self
+        total = vectors[0]
+        for v in vectors[1:]:
+            total = (total + v) if _is_sym(total) or _is_sym(v) else Vec.of(total) + v
+        return self._op("shift", {"vectors": [_P(total)]})
+
+    def move_to(self, point_or_mobject, aligned_edge=ORIGIN, coor_mask=(1, 1, 1)):
+        return self._op("move_to", {"point_or_mobject": _MP(point_or_mobject), "aligned_edge": _P(aligned_edge),
+                                    "coor_mask": _P(coor_mask)})
+
+    def center(self):
+        return self.move_to(ORIGIN)
+
+    def next_to(self, mobject_or_point, direction=RIGHT, buff=DEFAULT_MOBJECT_TO_MOBJECT_BUFFER,
+                aligned_edge=ORIGIN, **kwargs):
+        return self._op("next_to", {"mobject_or_point": _MP(mobject_or_point), "direction": _P(direction),
+                                    "buff": _num(buff), "aligned_edge": _P(aligned_edge)})
+
+    def to_edge(self, edge=LEFT, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):
+        return self._op("to_edge", {"edge": _P(edge), "buff": _num(buff)})
+
+    def to_corner(self, corner=DL, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):
+        return self._op("to_corner", {"corner": _P(corner), "buff": _num(buff)})
+
+    def align_to(self, mobject_or_point, direction=ORIGIN, **kwargs):
+        return self._op("align_to", {"mobject_or_point": _MP(mobject_or_point), "direction": _P(direction)})
+
+    def arrange(self, direction=RIGHT, buff=DEFAULT_MOBJECT_TO_MOBJECT_BUFFER, center=True,
+                aligned_edge=ORIGIN, **kwargs):
+        return self._op("arrange", {"direction": _P(direction), "buff": _num(buff), "center": bool(center),
+                                    "aligned_edge": _P(aligned_edge)})
+
+    def arrange_in_grid(self, rows=None, cols=None, buff=MED_SMALL_BUFF, cell_alignment=ORIGIN,
+                        flow_order="rd", **kwargs):
+        b = [_num(x) for x in buff] if isinstance(buff, (list, tuple)) else _num(buff)
+        return self._op("arrange_in_grid", {"rows": rows, "cols": cols, "buff": b,
+                                            "cell_alignment": _P(cell_alignment), "flow_order": flow_order})
+
+    def scale(self, scale_factor, about_point=None, about_edge=None, **kwargs):
+        return self._op("scale", {"scale_factor": _num(scale_factor), "about_point": _P(about_point),
+                                  "about_edge": _P(about_edge)})
+
+    def rotate(self, angle, axis=OUT, about_point=None, **kwargs):
+        return self._op("rotate", {"angle": _num(angle), "axis": _P(axis), "about_point": _P(about_point)})
+
+    def flip(self, axis=UP, **kwargs):
+        return self._op("flip", {"axis": _P(axis)})
+
+    def stretch(self, factor, dim, **kwargs):
+        return self._op("stretch", {"factor": _num(factor), "dim": int(dim)})
+
+    def set_x(self, x, direction=ORIGIN):
+        return self._op("set_x", {"x": _num(x)})
+
+    def set_y(self, y, direction=ORIGIN):
+        return self._op("set_y", {"y": _num(y)})
+
+    def set_z(self, z, direction=ORIGIN):
+        return self._op("set_z", {"z": _num(z)})
+
+    def scale_to_fit_width(self, width, **kwargs):
+        return self._op("scale_to_fit_width", {"width": _num(width)})
+
+    def scale_to_fit_height(self, height, **kwargs):
+        return self._op("scale_to_fit_height", {"height": _num(height)})
+
+    def stretch_to_fit_width(self, width, **kwargs):
+        return self._op("stretch_to_fit_width", {"width": _num(width)})
+
+    def stretch_to_fit_height(self, height, **kwargs):
+        return self._op("stretch_to_fit_height", {"height": _num(height)})
+
+    set_width, set_height = scale_to_fit_width, scale_to_fit_height
+
+    def match_width(self, mobject, **kwargs):
+        return self._op("match_width", {"mobject": mobject._embed()})
+
+    def match_height(self, mobject, **kwargs):
+        return self._op("match_height", {"mobject": mobject._embed()})
+
+    # -- style
+
+    def set_color(self, color=YELLOW_C, family=True):
+        return self._op("set_color", {"color": _color(color)})
+
+    def set_color_by_gradient(self, *colors):
+        return self._op("set_color", {"color": [_color(c) for c in _flat_colors(colors)]})
+
+    def set_fill(self, color=None, opacity=None, family=True):
+        args = {}
+        if color is not None:
+            args["color"] = _color(color)
+        if opacity is not None:
+            args["opacity"] = _num(opacity)
+        return self._op("set_fill", args)
+
+    def set_stroke(self, color=None, width=None, opacity=None, background=False, family=True):
+        args = {}
+        if color is not None:
+            args["color"] = _color(color)
+        if width is not None:
+            args["width"] = _num(width)
+        if opacity is not None:
+            args["opacity"] = _num(opacity)
+        return self._op("set_stroke", args)
+
+    def set_opacity(self, opacity, family=True):
+        return self._op("set_opacity", {"opacity": _num(opacity)})
+
+    def fade(self, darkness=0.5, family=True):
+        return self._op("fade", {"darkness": _num(darkness)})
+
+    def set_z_index(self, z_index_value, family=True):
+        self.z_index = z_index_value
+        return self._op("set_z_index", {"z_index": _num(z_index_value)})
+
+    def set(self, **kwargs):
+        for k, v in kwargs.items():
+            if k == "color":
+                self.set_color(v)
+            elif k in ("width", "height"):
+                getattr(self, "scale_to_fit_" + k)(v)
+            elif k == "opacity":
+                self.set_opacity(v)
+            elif k in ("fill_color", "fill_opacity"):
+                self.set_fill(**{k[5:]: v})
+            elif k in ("stroke_color", "stroke_width", "stroke_opacity"):
+                self.set_stroke(**{k[7:]: v})
+            elif k == "z_index":
+                self.set_z_index(v)
+            else:
+                setattr(self, k, v)
+        return self
+
+    def become(self, mobject, **kwargs):
+        self._n = mobject._count()
+        return self._op("become", {"mobject": mobject._embed()})
+
+    def save_state(self):
+        return self._op("save_state", {})
+
+    def restore(self):
+        return self._op("restore", {})
+
+    # -- groups
+
+    def add(self, *mobjects):
+        mobs = _flat(mobjects)
+        if self._kids is not None:
+            self._kids.extend(m for m in mobs if m not in self._kids)
+        return self._op("add", {"mobjects": [m._embed() for m in mobs]})
+
+    def remove(self, *mobjects):
+        mobs = _flat(mobjects)
+        if self._kids is not None:
+            self._kids[:] = [k for k in self._kids if k not in mobs]
+        return self._op("remove", {"mobjects": [m._embed() for m in mobs]})
+
+    # -- not yet
+
+    def add_updater(self, update_function, index=None, call_updater=False):
+        """Run update_function(m) — or (m, dt) — every frame. It is traced once
+        into a formula the browser runs; if it cannot be, it runs in Python."""
+        _add_updater(self, update_function)
+        return self
+
+    def remove_updater(self, update_function):
+        ups = self.__dict__.get("updaters") or []
+        for entry in list(ups):
+            if entry[0] is update_function:
+                ups.remove(entry)
+                self._stop_updates(entry[1])
+        return self
+
+    def _stop_updates(self, entries):
+        for target, uid in entries:
+            if target is None:
+                uid.active = False   # a Python-run updater
+            else:
+                _call("remove_updater", target, uid)
+
+    def clear_updaters(self, recursive=True):
+        for _fn, entries in self.__dict__.get("updaters") or []:
+            for target, uid in entries:
+                if target is None:
+                    uid.active = False
+                elif target != self._t():
+                    _call("remove_updater", target, uid)
+        self.__dict__["updaters"] = []
+        _call("clear_updaters", self._t())
+        return self
+
+    def suspend_updating(self, recursive=True):
+        _call("suspend_updating", self._t())
+        return self
+
+    def resume_updating(self, recursive=True):
+        _call("resume_updating", self._t())
+        return self
+
+    def set_shadow(self, blur=0.15, offset=(0.05, -0.05), color=BLACK, opacity=0.5):
+        """A soft shadow (blur and offset in scene units)."""
+        return self._op("set_shadow", {"blur": _num(blur), "offset": [_num(offset[0]), _num(offset[1])],
+                                       "color": _color(color), "opacity": _num(opacity)})
+
+    def get_updaters(self):
+        return [entry[0] for entry in self.__dict__.get("updaters") or []]
+
+    def has_updaters(self):
+        return bool(self.__dict__.get("updaters"))
+
+    def point_from_proportion(self, alpha):
+        return Point(["get", self._ref(), "point_from_proportion", _coord(alpha)])
+
+    def __getattr__(self, name):
+        if name.startswith("__") or name.startswith("_"):
+            raise AttributeError(name)
+        raise AttributeError("%s has no %s() in Pymations yet" % (type(self).__name__, name))
+
+
+def _flat_colors(colors):
+    out = []
+    for c in colors:
+        if isinstance(c, (list, tuple)) and c and isinstance(c[0], str):
+            out.extend(c)
+        else:
+            out.append(c)
+    return out
+
+
+class _Part(Mobject):
+    """A part of a mobject the engine owns (eq[1], text[0], copy[2])."""
+
+    def __init__(self, parent, index):
+        self._id = parent._id
+        self._path = (list(parent._path) if parent._path else []) + [index]
+        self._kids = None
+        self._ptmpl = parent.__dict__.get("_tmpl") or parent.__dict__.get("_ptmpl")
+        parts = parent.__dict__.get("_parts")
+        self._n = None
+        if parts is not None and index < len(parts):
+            self.tex = parts[index]
+
+
+    def _t(self):
+        if self._ptmpl is not None:
+            return {"tmpl": self._ptmpl["key"], "path": list(self._path)}
+        return Mobject._t(self)
+
+    _ref = _embed = _t
+
+
+class _Copy(Mobject):
+    pass
+
+
+class VMobject(Mobject):
+    def __init__(self, fill_color=None, fill_opacity=0.0, stroke_color=None, stroke_width=DEFAULT_STROKE_WIDTH,
+                 **kwargs):
+        kwargs.update(fill_color=fill_color, fill_opacity=fill_opacity, stroke_color=stroke_color,
+                      stroke_width=stroke_width)
+        self._make("vmobject", {"points": [], "smooth": False}, kwargs, n=0)
+
+    def set_points_as_corners(self, points):
+        return self._op("set_points", {"points": [_P(p) for p in points], "smooth": False})
+
+    def set_points_smoothly(self, points):
+        return self._op("set_points", {"points": [_P(p) for p in points], "smooth": True})
+
+    def get_length(self):
+        return Expr(["get", self._ref(), "length"], "s")
+
+    def get_angle(self):
+        return Expr(["get", self._ref(), "angle"], "s")
+
+
+class Group(Mobject):
+    _kind = "group"
+
+    def __init__(self, *mobjects, **kwargs):
+        kids = _flat(mobjects)
+        self._make(self._kind, {"children": [m._embed() for m in kids]}, kwargs, {}, kids=kids)
+
+
+class VGroup(Group, VMobject):
+    _kind = "group"
+
+
+class Circle(VMobject):
+    def __init__(self, radius=1.0, color=RED, **kwargs):
+        self._make("circle", {"radius": _num(radius)}, dict(kwargs, color=color), n=0)
+
+    def surround(self, mobject, dim_to_match=0, stretch=False, buffer_factor=1.2):
+        return self._op("surround", {"mobject": mobject._embed(), "buffer_factor": _num(buffer_factor)})
+
+
+class Ellipse(Circle):
+    def __init__(self, width=2.0, height=1.0, color=RED, **kwargs):
+        self._make("ellipse", {"width": _num(width), "height": _num(height)}, dict(kwargs, color=color), n=0)
+
+
+class Dot(VMobject):
+    def __init__(self, point=ORIGIN, radius=DEFAULT_DOT_RADIUS, stroke_width=0, fill_opacity=1.0,
+                 color=WHITE, **kwargs):
+        self._make("dot", {"point": _P(point), "radius": _num(radius)},
+                   dict(kwargs, stroke_width=stroke_width, fill_opacity=fill_opacity, color=color), n=0)
+
+
+class SmallDot(Dot):
+    def __init__(self, radius=DEFAULT_SMALL_DOT_RADIUS, **kwargs):
+        Dot.__init__(self, radius=radius, **kwargs)
+
+
+class Rectangle(VMobject):
+    def __init__(self, color=WHITE, height=2.0, width=4.0, **kwargs):
+        self._make("rectangle", {"width": _num(width), "height": _num(height)}, dict(kwargs, color=color), n=0)
+
+
+class Square(Rectangle):
+    def __init__(self, side_length=2.0, color=WHITE, **kwargs):
+        self._make("square", {"side_length": _num(side_length)}, dict(kwargs, color=color), n=0)
+
+
+class RoundedRectangle(Rectangle):
+    def __init__(self, corner_radius=0.5, color=WHITE, height=2.0, width=4.0, **kwargs):
+        self._make("rounded_rectangle", {"width": _num(width), "height": _num(height),
+                                        "corner_radius": _num(corner_radius)}, dict(kwargs, color=color), n=0)
+
+
+class Line(VMobject):
+    _kind = "line"
+
+    def __init__(self, start=LEFT, end=RIGHT, buff=0, path_arc=None, **kwargs):
+        geom = {"start": _MP(start), "end": _MP(end), "buff": _num(buff),
+                "path_arc": _num(path_arc) if path_arc else 0.0}
+        geom.update(self._extra(kwargs))
+        self._make(self._kind, geom, kwargs, n=0)
+
+    def _extra(self, kwargs):
+        return {}
+
+    def put_start_and_end_on(self, start, end):
+        return self._op("put_start_and_end_on", {"start": _P(start), "end": _P(end)})
+
+
+class DashedLine(Line):
+    _kind = "dashed_line"
+
+    def _extra(self, kwargs):
+        return {"dash_length": _num(kwargs.pop("dash_length", DEFAULT_DASH_LENGTH)),
+                "dashed_ratio": _num(kwargs.pop("dashed_ratio", 0.5))}
+
+
+class Arrow(Line):
+    _kind = "arrow"
+
+    def __init__(self, start=LEFT, end=RIGHT, buff=MED_SMALL_BUFF, stroke_width=6, **kwargs):
+        Line.__init__(self, start, end, buff=buff, stroke_width=stroke_width, **kwargs)
+
+    def _extra(self, kwargs):
+        return {"max_tip_length_to_length_ratio": _num(kwargs.pop("max_tip_length_to_length_ratio", 0.25)),
+                "max_stroke_width_to_length_ratio": _num(kwargs.pop("max_stroke_width_to_length_ratio", 5)),
+                "tip_length": _num(kwargs.pop("tip_length", DEFAULT_ARROW_TIP_LENGTH))}
+
+
+class DoubleArrow(Arrow):
+    _kind = "double_arrow"
+
+
+class Vector(Arrow):
+    def __init__(self, direction=RIGHT, buff=0, **kwargs):
+        Arrow.__init__(self, ORIGIN, direction, buff=buff, **kwargs)
+
+
+class Arc(VMobject):
+    def __init__(self, radius=1.0, start_angle=0, angle=TAU / 4, arc_center=ORIGIN, **kwargs):
+        self._make("arc", {"radius": _num(radius), "start_angle": _num(start_angle), "angle": _num(angle),
+                           "arc_center": _P(arc_center)}, kwargs, n=0)
+
+
+class Polygon(VMobject):
+    def __init__(self, *vertices, color=BLUE, **kwargs):
+        self._make("polygon", {"vertices": [_P(v) for v in vertices]}, dict(kwargs, color=color), n=0)
+
+
+class RegularPolygon(Polygon):
+    def __init__(self, n=6, radius=1.0, start_angle=None, color=BLUE, **kwargs):
+        if start_angle is None:
+            start_angle = (n % 2) * 90 * DEGREES
+        self._make("regular_polygon", {"n": int(n), "radius": _num(radius), "start_angle": _num(start_angle)},
+                   dict(kwargs, color=color), n=0)
+
+
+class Triangle(RegularPolygon):
+    def __init__(self, **kwargs):
+        RegularPolygon.__init__(self, n=3, **kwargs)
+
+
+class Star(Polygon):
+    def __init__(self, n=5, outer_radius=1.0, inner_radius=None, density=2, start_angle=TAU / 4,
+                 color=BLUE, **kwargs):
+        if inner_radius is None:
+            inner_radius = (outer_radius * math.cos(TAU * density / 2 / n)
+                            / math.cos(TAU * (density - 1) / 2 / n))
+        self._make("star", {"n": int(n), "outer_radius": _num(outer_radius), "inner_radius": _num(inner_radius),
+                            "start_angle": _num(start_angle)}, dict(kwargs, color=color), n=0)
+
+
+class Annulus(VMobject):
+    def __init__(self, inner_radius=1, outer_radius=2, fill_opacity=1, stroke_width=0, color=WHITE, **kwargs):
+        self._make("annulus", {"inner_radius": _num(inner_radius), "outer_radius": _num(outer_radius)},
+                   dict(kwargs, fill_opacity=fill_opacity, stroke_width=stroke_width, color=color), n=0)
+
+
+class Text(VMobject):
+    def __init__(self, text, font_size=DEFAULT_FONT_SIZE, font="", weight=NORMAL, slant=NORMAL,
+                 line_spacing=-1, t2c=None, letter_spacing=0, **kwargs):
+        text = str(text)
+        self.text = text
+        # font: a family name, or a font file beside the .py ("Brand.ttf"), sent as written.
+        geom = {"text": text, "font_size": _num(font_size), "font": font, "weight": weight,
+                "slant": slant, "line_spacing": _num(line_spacing), "letter_spacing": _num(letter_spacing)}
+        if t2c:
+            geom["t2c"] = {str(k): _color(v) for k, v in t2c.items()}
+        self._make("text", geom, kwargs, _FILLED, n=sum(1 for ch in text if not ch.isspace()))
+
+
+
+def _split_tex(strings, isolate):
+    """Manim's part rule: each argument is a part, {{ … }} marks parts too
+    ("{{ a }} + {{ b }}" is a, +, b), and every substring to isolate becomes
+    its own part. Parts are sent trimmed, so get_part_by_tex("a") finds one."""
+    pieces = []
+    for s in strings:
+        s = str(s)
+        if "{{" in s:
+            for chunk in s.replace("}}", "{{").split("{{"):
+                if chunk.strip():
+                    pieces.append(chunk.strip())
+        elif s.strip():
+            pieces.append(s.strip())
+    isolate = sorted({str(x) for x in isolate if x}, key=len, reverse=True)
+    if not isolate:
+        return pieces
+    out = []
+    for p in pieces:
+        i, start = 0, 0
+        while i < len(p):
+            hit = next((x for x in isolate if p.startswith(x, i)), None)
+            if hit:
+                if p[start:i].strip():
+                    out.append(p[start:i].strip())
+                out.append(hit)
+                i += len(hit)
+                start = i
+            else:
+                i += 1
+        if p[start:].strip():
+            out.append(p[start:].strip())
+    return out
+
+
+class MathTex(VMobject):
+    _kind = "mathtex"
+    _sep = " "
+
+    def __init__(self, *tex_strings, arg_separator=None, substrings_to_isolate=None, tex_to_color_map=None,
+                 font_size=DEFAULT_FONT_SIZE, tex_environment=None, **kwargs):
+        cmap = dict(tex_to_color_map or {})
+        parts = _split_tex(tex_strings, list(substrings_to_isolate or []) + list(cmap))
+        self._parts = parts
+        self.tex_string = (self._sep if arg_separator is None else arg_separator).join(parts)
+        geom = {"tex_strings": parts, "font_size": _num(font_size),
+                "arg_separator": self._sep if arg_separator is None else arg_separator}
+        if tex_environment is not None:
+            # How lines (\\) are laid out: "flushleft", "center", "align*", …; absent = the default.
+            geom["tex_environment"] = str(tex_environment)
+        self._make(self._kind, geom, kwargs, _FILLED, n=len(parts))
+        for tex, col in cmap.items():
+            self.set_color_by_tex(tex, col)
+
+    def get_parts_by_tex(self, tex, substring=True, case_sensitive=True):
+        f = (lambda s: s) if case_sensitive else (lambda s: s.lower())
+        hits = [i for i, p in enumerate(self._parts)
+                if (f(tex) in f(p) if substring else f(tex) == f(p))]
+        return VGroup(*[self[i] for i in hits])
+
+    def get_part_by_tex(self, tex, **kwargs):
+        for i, p in enumerate(self._parts):
+            if tex in p:
+                return self[i]
+        return None
+
+    def index_of_part_by_tex(self, tex, **kwargs):
+        for i, p in enumerate(self._parts):
+            if tex in p:
+                return i
+        return -1
+
+    index_of_part = index_of_part_by_tex
+
+    def set_color_by_tex(self, tex, color, **kwargs):
+        for i, p in enumerate(self._parts):
+            if tex in p:
+                self[i].set_color(color)
+        return self
+
+    def set_color_by_tex_to_color_map(self, texs_to_color_map, **kwargs):
+        for tex, col in texs_to_color_map.items():
+            self.set_color_by_tex(tex, col)
+        return self
+
+
+class Tex(MathTex):
+    _kind = "tex"
+    _sep = ""
+
+
+class Title(Tex):
+    """A Tex at the top, underlined (the underline is its last part)."""
+
+    def __init__(self, *text_parts, include_underline=True, match_underline_width_to_text=False,
+                 underline_buff=MED_SMALL_BUFF, **kwargs):
+        Tex.__init__(self, *text_parts, **kwargs)
+        self.to_edge(UP)
+        if include_underline:
+            w, _h = _frame_size()
+            self.underline = Line(LEFT, RIGHT).next_to(self, DOWN, buff=underline_buff)
+            if match_underline_width_to_text:
+                self.underline.match_width(self)
+            else:
+                self.underline.scale_to_fit_width(w - 2)
+            self.add(self.underline)
+            self._n += 1
+
+
+def _number_tex(number, num_decimal_places, include_sign):
+    s = ("%+." if include_sign else "%.") + str(int(num_decimal_places)) + "f"
+    return s % number
+
+
+def _real_number(v):
+    return isinstance(v, (int, float)) and not isinstance(v, bool)
+
+
+def _decimal_text(number, num_decimal_places, include_sign, group_with_commas):
+    s = ("{:+," if include_sign else "{:,") if group_with_commas else ("{:+" if include_sign else "{:")
+    return (s + ".%df}" % int(num_decimal_places)).format(number)
+
+
+class DecimalNumber(VMobject):
+    """A number drawn digit by digit, so changing it is cheap."""
+
+    def __init__(self, number=0, num_decimal_places=2, mob_class=None, include_sign=False,
+                 group_with_commas=True, digit_buff_per_font_unit=0.001, show_ellipsis=False, unit=None,
+                 unit_buff_per_font_unit=0, include_background_rectangle=False, edge_to_fix=LEFT,
+                 font_size=DEFAULT_FONT_SIZE, stroke_width=0, fill_opacity=1.0, **kwargs):
+        self.number = number
+        self.num_decimal_places = num_decimal_places
+        n = None
+        if _real_number(number):
+            text = _decimal_text(number, num_decimal_places, include_sign, group_with_commas)
+            n = len(text) + (1 if unit else 0) + (3 if show_ellipsis else 0)
+        self._make("decimal_number", {
+            "number": _num(number), "num_decimal_places": int(num_decimal_places),
+            "include_sign": bool(include_sign), "group_with_commas": bool(group_with_commas),
+            "show_ellipsis": bool(show_ellipsis), "unit": unit, "edge_to_fix": _P(edge_to_fix),
+            "include_background_rectangle": bool(include_background_rectangle), "font_size": _num(font_size),
+        }, dict(kwargs, stroke_width=stroke_width, fill_opacity=fill_opacity), _FILLED, n=n)
+
+    def set_value(self, number):
+        self.number = number
+        return self._op("set_value", {"value": _num(number)})
+
+    def get_value(self):
+        if _real_number(self.number) and _st().trace is None:
+            return self.number
+        return Expr(["get", self._ref(), "value"], "s")
+
+    def increment_value(self, delta_t=1):
+        if _real_number(self.number) and _real_number(delta_t):
+            self.number += delta_t
+        return self._op("increment_value", {"value": _num(delta_t)})
+
+
+class Integer(DecimalNumber):
+    def __init__(self, number=0, num_decimal_places=0, **kwargs):
+        DecimalNumber.__init__(self, number, num_decimal_places=num_decimal_places, **kwargs)
+
+
+class ValueTracker(Mobject):
+    """A number on the timeline: animate it, and have updaters follow it."""
+
+    def __init__(self, value=0, **kwargs):
+        self._value = self._initial = float(value) if _real_number(value) else 0.0
+        self._make("value_tracker", {"value": _num(value)}, kwargs, {}, n=0)
+
+    def get_value(self):
+        st = _st()
+        tr = st.trace
+        real = (tr is not None and tr.real) or (tr is None and _live_phase())
+        if real and self.__dict__.get("_tmpl") is None:
+            if st.anim_v is None:   # no frame from the page yet: the timeline's start
+                return self._initial if st.trace is not None else self._value
+            return st.anim_v.get(self._id, self._value)
+        return Expr(["val", self._ref()], "s")
+
+    def set_value(self, value):
+        if _real_number(value):
+            self._value = float(value)
+        return self._op("set_value", {"value": _num(value)})
+
+    def increment_value(self, d_value):
+        if _real_number(d_value):
+            self._value += d_value
+        return self._op("increment_value", {"value": _num(d_value)})
+
+    def __iadd__(self, d_value):
+        return self.increment_value(d_value)
+
+    def __isub__(self, d_value):
+        return self.increment_value(-d_value)
+
+
+class Variable(VGroup):
+    """label = value, with a tracker (var.tracker) that the value follows."""
+
+    def __init__(self, var, label, var_type=None, num_decimal_places=2, **kwargs):
+        var_type = var_type or DecimalNumber
+        label = MathTex(label) if isinstance(label, str) else label
+        # As Manim's: the label carries its "=", so the parts are [label, value].
+        self.label = VGroup(label, MathTex("=")).arrange(RIGHT)
+        self.tracker = ValueTracker(var)
+        if var_type is Integer or (isinstance(var_type, type) and issubclass(var_type, Integer)):
+            self.value = var_type(var, **kwargs)
+        else:
+            self.value = var_type(var, num_decimal_places=num_decimal_places, **kwargs)
+        VGroup.__init__(self, self.label, self.value)
+        self.arrange(RIGHT)
+        tracker = self.tracker
+        self.value.add_updater(lambda v: v.set_value(tracker.get_value()))
+
+
+# ---------------------------------------------------------------- updaters
+#
+# An updater is TRACED: called once with symbolic values (tracker values,
+# positions, the time, dt), so its ops become formulas the engine runs every
+# frame — scrubbing and recording stay exact and Python stays idle. One that
+# cannot be traced (an if on a value, math.sin, a call we cannot follow) runs in
+# Python every frame instead: the runtime stays live, and its ops are sent as
+# live overrides at the frame's timeline time (anim_t in the tick payload).
+
+_RELATIVE_OPS = ("shift", "rotate", "scale", "stretch", "increment_value", "rotate_about_origin")
+
+
+class _Trace:
+    __slots__ = ("ops", "next_key", "real")
+
+    def __init__(self, real):
+        self.ops = []        # [name, args, target] on existing objects
+        self.next_key = 0    # templates made inside the traced function
+        self.real = real     # Python fallback: trackers and time are real numbers
+
+
+def _run_trace(fn, args, real=False):
+    st = _st()
+    prev = st.trace
+    tr = st.trace = _Trace(real)
+    try:
+        return tr, fn(*args), None
+    except Exception as e:  # noqa: BLE001 — any failure means: run it in Python instead
+        if real:
+            raise
+        return tr, None, e
+    finally:
+        st.trace = prev
+
+
+def _takes_dt(fn):
+    try:
+        params = [p for p in inspect.signature(fn).parameters.values()
+                  if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)]
+    except (TypeError, ValueError):
+        return False
+    return len(params) >= 2 or any(p.name == "dt" for p in params)
+
+
+def _fn_line(fn):
+    code = getattr(fn, "__code__", None)
+    if code is not None and code.co_filename == _rt.USER_FILE:
+        return code.co_firstlineno
+    return _rt._user_line()
+
+
+def _new_uid():
+    st = _st()
+    uid = st.next_uid
+    st.next_uid += 1
+    return uid
+
+
+def _wire(v):
+    """A template ({key, kind, props, ops}) as the engine takes it: [kind, props, ops],
+    nested wherever one appears. A reference to another template cannot be sent."""
+    if isinstance(v, dict):
+        if "kind" in v and "key" in v:
+            return [v["kind"], _wire(v["props"]), [[op[0], _wire(op[1])] for op in v["ops"]]]
+        if "tmpl" in v:
+            raise _Untraceable("one object it makes refers to another one it makes")
+        return {k: _wire(x) for k, x in v.items()}
+    if isinstance(v, (list, tuple)):
+        if any(isinstance(x, Expr) for x in v):
+            return _j(v)   # a point with a formula in it: {"$pt": …}
+        return [_wire(x) for x in v]
+    if isinstance(v, (Expr, Mobject)):
+        return _wire(_j(v))
+    return v
+
+
+def _per_frame(args, name, k):
+    """A per-frame relative op as a rate: its amount times k = 60·dt (Manim's 60 fps)."""
+    def times(v):
+        v = _j(v)
+        if isinstance(v, dict):
+            key = "$pt" if "$pt" in v else "$x"
+            return {key: ["*", v[key], k]}
+        if isinstance(v, list):
+            return {"$pt": ["*", v, k]}
+        return {"$x": ["*", v, k]}
+
+    def power(v):
+        v = _j(v)
+        return {"$x": ["**", v.get("$x") if isinstance(v, dict) else v, k]}
+
+    a = dict(args)
+    if name == "shift":
+        a["vectors"] = [times(v) for v in a.get("vectors", [])]
+    elif name in ("rotate", "rotate_about_origin"):
+        a["angle"] = times(a["angle"])
+    elif name == "increment_value":
+        a["value"] = times(a["value"])
+    elif name == "scale":
+        a["scale_factor"] = power(a["scale_factor"])
+    elif name == "stretch":
+        a["factor"] = power(a["factor"])
+    return a
+
+
+def _by_target(ops):
+    out = {}
+    for name, args, target in ops:
+        out.setdefault(repr(target), (target, []))[1].append([name, args])
+    return list(out.values())
+
+
+def _add_updater(mob, fn):
+    if mob.__dict__.get("_tmpl") is not None or _st().trace is not None:
+        raise _Untraceable("it adds an updater")
+    dt = _takes_dt(fn)
+    tr, result, err = _run_trace(fn, (mob, _var("dt")) if dt else (mob,))
+    entries = []
+    if err is None:
+        ops = tr.ops
+        kind = "dt" if dt else "op"
+        if not dt and any(op[0] in _RELATIVE_OPS for op in ops):
+            k = ["*", ["dt"], float(config.frame_rate or 60)]
+            ops = [[name, _per_frame(args, name, k) if name in _RELATIVE_OPS else args, target]
+                   for name, args, target in ops]
+            kind = "dt"
+        try:
+            groups = [(target, _wire(o)) for target, o in _by_target(ops)] or [(mob._t(), [])]
+        except _Untraceable as e:
+            err = e
+        else:
+            for target, o in groups:
+                uid = _new_uid()
+                _call("add_updater", target, {"uid": uid, "kind": kind, "ops": o})
+                entries.append((target, uid))
+    if err is not None:
+        u = _PyUpdater("dt" if dt else "op", fn, mob)
+        _fallback(u)
+        entries.append((None, u))
+    mob.__dict__.setdefault("updaters", []).append((fn, entries))
+
+
+def _fallback(u):
+    _tell("fb%d" % id(u), "Note: the updater on line %d runs in Python on every frame, so the program "
+                          "keeps running." % _fn_line(u.fn))
+    _st().fallbacks.append(u)
+
+
+def _live_op(name, args, target, accumulate=False):
+    """One change on top of the timeline, at whatever time is drawn."""
+    if (name == "set_value" and not accumulate and isinstance(target, int)
+            and isinstance(_st().objects.get(target), ValueTracker)):
+        _call("live_set", target, _wire(args.get("value")))
+        return
+    if accumulate:
+        _call("live_op", target, name, _wire(args), {"accumulate": True})
+    else:
+        _call("live_op", target, name, _wire(args))
+
+
+class _PyUpdater:
+    """An updater run in Python each frame; its ops become live overrides."""
+
+    def __init__(self, kind, fn, mob):
+        self.kind, self.fn, self.mob = kind, fn, mob
+        self.last_t = None
+        self.active = True
+
+    def run(self, st):
+        if not self.active:
+            return
+        if self.kind == "dt":
+            t = st.anim_t
+            last, self.last_t = self.last_t, t
+            if last is None or t <= last:
+                return
+            tr, _r, _e = _run_trace(self.fn, (self.mob, t - last), real=True)
+            for name, args, target in tr.ops:
+                _live_op(name, args, target, accumulate=True)
+            return
+        if self.kind == "redraw":
+            tr, result, _e = _run_trace(self.fn, (), real=True)
+            if isinstance(result, Mobject):
+                _live_op("become", {"mobject": result._embed()}, self.mob._t())
+        else:
+            tr, _r, _e = _run_trace(self.fn, (self.mob,), real=True)
+        for name, args, target in tr.ops:
+            _live_op(name, args, target)
+
+
+def always_redraw(func):
+    """A mobject rebuilt from func() every frame."""
+    st = _st()
+    tr, result, err = _run_trace(func, ())
+    if err is None and isinstance(result, Mobject) and result.__dict__.get("_tmpl") is not None:
+        try:
+            make = _wire(result._tmpl)
+        except _Untraceable as e:
+            err = e
+        else:
+            result._tmpl = None
+            result._id = st.next_id
+            st.next_id += 1
+            st.objects[result._id] = result
+            uid = _new_uid()
+            _call("add_updater", result._id, {"uid": uid, "kind": "redraw", "make": make})
+            result.__dict__["updaters"] = [(func, [(result._id, uid)])]
+            return result
+    if err is None and not isinstance(result, Mobject):
+        raise TypeError("always_redraw needs a function that returns a mobject, such as "
+                        "lambda: Line(a.get_center(), b.get_center())")
+    holder = VGroup()
+    u = _PyUpdater("redraw", func, holder)
+    _fallback(u)
+    holder.__dict__["updaters"] = [(func, [(None, u)])]
+    return holder
+
+
+def always(method, *args, **kwargs):
+    """always(m.next_to, other, UP): keep calling the method every frame."""
+    mob = method.__self__
+    mob.add_updater(lambda m: method(*args, **kwargs))
+    return mob
+
+
+def f_always(method, *arg_generators, **kwargs):
+    """f_always(m.set_x, lambda: t.get_value()): the arguments are worked out every frame."""
+    mob = method.__self__
+    mob.add_updater(lambda m: method(*[g() for g in arg_generators], **kwargs))
+    return mob
+
+
+def always_shift(mobject, direction=RIGHT, rate=0.1):
+    return mobject.add_updater(lambda m, dt: m.shift(dt * rate * direction))
+
+
+def always_rotate(mobject, rate=20 * DEGREES, **kwargs):
+    return mobject.add_updater(lambda m, dt: m.rotate(dt * rate, **kwargs))
+
+
+class TracedPath(VMobject):
+    """The path a point leaves behind: TracedPath(dot.get_center)."""
+
+    def __init__(self, traced_point_func, stroke_width=2, stroke_color=WHITE, dissipating_time=None, **kwargs):
+        tr, point, err = _run_trace(traced_point_func, ())
+        if err is not None or not _is_sym(point):
+            raise TypeError("TracedPath needs a point it can follow, such as TracedPath(dot.get_center)")
+        self._make("traced_path", {"point": _P(point), "dissipating_time": dissipating_time},
+                   dict(kwargs, stroke_width=stroke_width, stroke_color=stroke_color), n=0)
+
+
+# ---------------------------------------------------------------- Pyctures inside a scene
+
+class PycturesCanvas(Mobject):
+    """A picture drawn with Pyctures' ctx every frame, placed in the scene:
+    draw(ctx, t) draws in pixels (resolution per scene unit); t is the time."""
+
+    def __init__(self, width=4.0, height=3.0, draw=None, resolution=100, **kwargs):
+        w, h = float(width), float(height)
+        ratio = ((_rt.S.ns or {}).get("pixel_ratio", 1) or 1)
+        self._lw, self._lh = max(1, int(round(w * resolution))), max(1, int(round(h * resolution)))
+        pw, ph = max(1, int(round(self._lw * ratio))), max(1, int(round(self._lh * ratio)))
+        self._ratio = ratio
+        self._draw_fn = draw
+        self._make("pyctures_canvas", {"width": w, "height": h, "px_width": pw, "px_height": ph}, kwargs, {}, n=0)
+        # The engine makes the canvas element; Python draws on it through a handle.
+        self._canvas = _rt.JsRef(H_ANIM).canvas_for(self._id)
+        self._ctx = self._canvas.getContext("2d")
+        _st().canvases.append(self)
+
+    @property
+    def ctx(self):
+        return self._ctx
+
+    def _redraw(self):
+        if self._draw_fn is None:
+            return
+        g = self._ctx
+        g.setTransform(self._ratio, 0, 0, self._ratio, 0, 0)
+        g.clearRect(0, 0, self._lw, self._lh)
+        self._draw_fn(g, _st().anim_t)
+
+
+def _style_dict(d):
+    """A config dict (axis_config={"color": GREEN}): colours as '#RRGGBB', the rest as JSON."""
+    return {str(k): _color(v) if str(k).endswith("color") else _j(v) for k, v in dict(d or {}).items()}
+
+
+def _range3(r, default):
+    r = list(default if r is None else r)
+    if len(r) == 2:
+        r.append(1.0)
+    return [_num(x) for x in r]
+
+
+class _Curve(VMobject):
+    """A curve sampled in Python once (axes.plot, ParametricFunction, get_area)."""
+
+    def __init__(self, points, axes=None, function=None, closed=False, x_range=None, **kwargs):
+        self._func = function
+        self._axes = axes
+        self._x_range = x_range
+        # Pen-up gaps (None) split the curve into segments.
+        segs, seg = [], []
+        for p in points:
+            if p is None:
+                if seg:
+                    segs.append(seg)
+                seg = []
+            else:
+                seg.append(p)
+        if seg:
+            segs.append(seg)
+        if axes is not None:
+            # In the axes' own coordinates; the engine places them on the axes.
+            geom = {"segments": segs, "axes": axes._ref()}
+            if closed:
+                geom.update(closed=True, use_smoothing=False)
+            self._make("graph", geom, kwargs, n=0)
+        else:
+            self._make("vmobject", {"subpaths": segs, "smooth": not closed, "closed": bool(closed)}, kwargs, n=0)
+
+    def underlying_function(self, x):
+        return self._func(x)
+
+
+def _sample(fn, t0, t1, step, to_point):
+    span = t1 - t0
+    if span <= 0:
+        return []
+    step = min(abs(step) if step else span, span / 200.0)
+    count = min(4000, int(math.ceil(span / step)))
+    pts, pen = [], False
+    for i in range(count + 1):
+        t = t0 + span * i / count
+        try:
+            p = to_point(fn, t)
+            # A symbolic value (a tracker inside the function) is worked out by the
+            # engine, every frame when the curve is redrawn.
+            ok = all(isinstance(v, Expr) or (v == v and abs(v) < 1e7) for v in p)
+        except (ArithmeticError, ValueError):
+            ok = False
+        if ok:
+            pts.append(p)
+            pen = True
+        elif pen:
+            pts.append(None)
+            pen = False
+    while pts and pts[-1] is None:
+        pts.pop()
+    return pts
+
+
+def _xy(fn, x):
+    y = fn(x)
+    if isinstance(y, Expr):
+        if y.shape != "s":
+            raise TypeError("a plotted function must return a number")
+        return [float(x), y, 0.0]
+    return [float(x), float(y), 0.0]
+
+
+def _xyz(fn, t):
+    p = _unarray(fn(t))
+    if _is_sym(p):
+        p = list(p)
+        return (p + [0.0, 0.0])[:3] if len(p) < 3 else p[:3]
+    return list(Vec.of(p))
+
+
+class ParametricFunction(_Curve):
+    def __init__(self, function, t_range=(0, 1), color=YELLOW, **kwargs):
+        t = _range3(t_range, (0, 1, 0.01))
+        _Curve.__init__(self, _sample(function, t[0], t[1], t[2] if len(t_range) > 2 else None, _xyz),
+                       function=function, color=color, **kwargs)
+
+
+class FunctionGraph(ParametricFunction):
+    def __init__(self, function, x_range=None, color=YELLOW, **kwargs):
+        w, _h = _frame_size()
+        r = _range3(x_range, (-w / 2, w / 2, 0.01))
+        _Curve.__init__(self, _sample(function, r[0], r[1], r[2], _xy), function=function, color=color,
+                        x_range=(r[0], r[1]), **kwargs)
+
+
+class NumberLine(VMobject):
+    def __init__(self, x_range=None, length=None, unit_size=1, include_numbers=False, include_tip=False,
+                 **kwargs):
+        w, _h = _frame_size()
+        half = float(round(w / 2))
+        r = _range3(x_range, (-half, half, 1))
+        self.x_range = r
+        self._make("number_line", {"x_range": r, "length": _num(length) if length else None,
+                                  "unit_size": _num(unit_size), "include_numbers": bool(include_numbers),
+                                  "include_tip": bool(include_tip)}, kwargs, n=None)
+
+    def number_to_point(self, number):
+        return Point(["c2p", self._ref(), _coord(number), 0.0])
+
+    n2p = number_to_point
+
+
+class Axes(VMobject):
+    _kind = "axes"
+
+    def __init__(self, x_range=None, y_range=None, x_length=None, y_length=None, axis_config=None,
+                 x_axis_config=None, y_axis_config=None, tips=True, **kwargs):
+        w, h = _frame_size()
+        self.x_range = _range3(x_range, self._default_range(w))
+        self.y_range = _range3(y_range, self._default_range(h))
+        geom = {"x_range": self.x_range, "y_range": self.y_range,
+                "x_length": _num(x_length) if x_length is not None else self._length(round(w) - 2, self.x_range),
+                "y_length": _num(y_length) if y_length is not None else self._length(round(h) - 2, self.y_range),
+                "tips": bool(tips), "axis_config": _style_dict(axis_config),
+                "x_axis_config": _style_dict(x_axis_config), "y_axis_config": _style_dict(y_axis_config)}
+        geom.update(self._extra(kwargs))
+        self._make(self._kind, geom, kwargs, n=4 if isinstance(self, NumberPlane) else 2)
+
+    def _length(self, frame_length, r):
+        return float(frame_length)
+
+    def _default_range(self, frame_length):
+        # Whole units: x -7..7 and y -4..4 in the 16:9 frame.
+        half = float(round(frame_length / 2))
+        return (-half, half, 1)
+
+    def _extra(self, kwargs):
+        return {}
+
+    _axis_index = (0, 1)   # where the x and y axes sit among the parts
+
+    @property
+    def x_axis(self):
+        return self[self._axis_index[0]]
+
+    @property
+    def y_axis(self):
+        return self[self._axis_index[1]]
+
+    def get_axes(self):
+        return VGroup(self.x_axis, self.y_axis)
+
+    def coords_to_point(self, *coords):
+        if len(coords) == 1:
+            coords = tuple(_unarray(coords[0]))
+        x = _coord(coords[0])
+        y = _coord(coords[1]) if len(coords) > 1 else 0.0
+        return Point(["c2p", self._ref(), x, y])
+
+    c2p = coords_to_point
+
+    def plot(self, function, x_range=None, color=None, **kwargs):
+        r = list(x_range) if x_range is not None else list(self.x_range)
+        r = _range3(r, self.x_range)
+        step = r[2] if (x_range is not None and len(x_range) > 2) else None
+        kw = dict(kwargs)
+        kw["color"] = color if color is not None else kw.get("color", YELLOW)
+        g = _Curve(_sample(function, r[0], r[1], step, _xy), axes=self, function=function,
+                   x_range=(r[0], r[1]), **kw)
+        g.color = kw["color"]
+        return g
+
+    get_graph = plot
+
+    def plot_parametric_curve(self, function, t_range=(0, 1), color=YELLOW, **kwargs):
+        t = _range3(t_range, (0, 1, 0.01))
+        return _Curve(_sample(function, t[0], t[1], t[2] if len(t_range) > 2 else None, _xyz),
+                      axes=self, function=function, color=color, **kwargs)
+
+    def input_to_graph_point(self, x, graph):
+        fn = getattr(graph, "_func", None)
+        if fn is None:
+            raise TypeError("input_to_graph_point needs a graph made with axes.plot(...)")
+        return self.c2p(x, fn(x))
+
+    i2gp = input_to_graph_point
+
+    def get_graph_label(self, graph, label="f(x)", x_val=None, direction=RIGHT, buff=MED_SMALL_BUFF,
+                        color=None, dot=False, dot_config=None):
+        m = label if isinstance(label, Mobject) else MathTex(label)
+        if x_val is None:
+            x_val = self.x_range[1]
+        m.next_to(self.i2gp(x_val, graph), direction, buff=buff)
+        m.set_color(color if color is not None else getattr(graph, "color", YELLOW))
+        return m
+
+    def get_x_axis_label(self, label, edge=UR, direction=UR, buff=SMALL_BUFF, **kwargs):
+        m = label if isinstance(label, Mobject) else MathTex(label)
+        return m.next_to(self.x_axis.get_corner(edge), direction, buff=buff)
+
+    def get_y_axis_label(self, label, edge=UR, direction=UR, buff=SMALL_BUFF, **kwargs):
+        m = label if isinstance(label, Mobject) else MathTex(label)
+        return m.next_to(self.y_axis.get_corner(edge), direction, buff=buff)
+
+    def get_axis_labels(self, x_label="x", y_label="y"):
+        return VGroup(self.get_x_axis_label(x_label), self.get_y_axis_label(y_label))
+
+    def add_coordinates(self, *axes_numbers, num_decimal_places=None, **kwargs):
+        return self._op("add_coordinates", {"num_decimal_places": num_decimal_places})
+
+    # -- helpers built here from the plotted function (Python knows it)
+
+    def _graph_fn(self, graph, what):
+        fn = getattr(graph, "_func", None)
+        if fn is None:
+            raise TypeError("%s needs a graph made with axes.plot(...)" % what)
+        return fn
+
+    def get_area(self, graph, x_range=None, color=(BLUE, GREEN), opacity=0.3, bounded_graph=None, **kwargs):
+        f = self._graph_fn(graph, "get_area")
+        a, b = x_range if x_range is not None else (graph._x_range or self.x_range[:2])
+        g = getattr(bounded_graph, "_func", None) or (lambda x: 0.0)
+        top = [p for p in _sample(f, a, b, None, _xy) if p is not None]
+        bottom = [p for p in _sample(g, a, b, None, _xy) if p is not None]
+        area = _Curve(top + bottom[::-1], axes=self, closed=True, fill_opacity=opacity, stroke_width=0,
+                      color=list(color) if isinstance(color, (list, tuple)) else color, **kwargs)
+        return area
+
+    def get_riemann_rectangles(self, graph, x_range=None, dx=0.1, input_sample_type="left", stroke_width=1,
+                               stroke_color=BLACK, fill_opacity=1, color=(BLUE, GREEN), show_signed_area=True,
+                               bounded_graph=None, blend=False, width_scale_factor=1.001):
+        f = self._graph_fn(graph, "get_riemann_rectangles")
+        g = getattr(bounded_graph, "_func", None) or (lambda x: 0.0)
+        a, b = x_range if x_range is not None else self.x_range[:2]
+        n = max(1, int(round((b - a) / dx)))
+        colors = color_gradient(color if isinstance(color, (list, tuple)) else [color], n)
+        rects = []
+        for i in range(n):
+            x0 = a + i * dx
+            x1 = x0 + dx * width_scale_factor
+            xs = {"left": x0, "right": x0 + dx, "center": x0 + dx / 2}.get(input_sample_type, x0)
+            y = f(xs)
+            base = g(xs)
+            pts = [[x0, base, 0.0], [x1, base, 0.0], [x1, y, 0.0], [x0, y, 0.0]]
+            rects.append(_Curve(pts, axes=self, closed=True, fill_opacity=fill_opacity, stroke_width=stroke_width,
+                                stroke_color=stroke_color, fill_color=colors[i], color=colors[i]))
+        return VGroup(*rects)
+
+    def get_vertical_line(self, point, line_config=None, line_func=None, **kwargs):
+        line_func = line_func or DashedLine
+        foot = Point(["v", [["idx", _tree(point), 0], ["idx", ["c2p", self._ref(), 0.0, 0.0], 1], 0.0]])
+        return line_func(point, foot, **dict(line_config or {}, **kwargs))
+
+    def get_horizontal_line(self, point, line_config=None, line_func=None, **kwargs):
+        line_func = line_func or DashedLine
+        foot = Point(["v", [["idx", ["c2p", self._ref(), 0.0, 0.0], 0], ["idx", _tree(point), 1], 0.0]])
+        return line_func(point, foot, **dict(line_config or {}, **kwargs))
+
+    def get_T_label(self, x_val, graph, label=None, label_color=None, triangle_size=MED_SMALL_BUFF,
+                    triangle_color=WHITE, line_func=None, line_color=YELLOW):
+        line_func = line_func or Line
+        tri = Triangle(color=triangle_color, fill_opacity=1).scale_to_fit_height(triangle_size)
+        tri.move_to(self.c2p(x_val, 0), UP)
+        parts = [tri]
+        if label is not None:
+            lab = label if isinstance(label, Mobject) else MathTex(label)
+            lab.next_to(tri, DOWN)
+            if label_color is not None:
+                lab.set_color(label_color)
+            parts.append(lab)
+        parts.append(line_func(self.c2p(x_val, 0), self.i2gp(x_val, graph), color=line_color))
+        return VGroup(*parts)
+
+    def get_secant_slope_group(self, x, graph, dx=None, dx_line_color=YELLOW, dy_line_color=None,
+                               dx_label=None, dy_label=None, include_secant_line=True, secant_line_color=GREEN,
+                               secant_line_length=10):
+        f = self._graph_fn(graph, "get_secant_slope_group")
+        dx = dx if dx is not None else (self.x_range[1] - self.x_range[0]) / 10
+        p1, p2 = self.c2p(x, f(x)), self.c2p(x + dx, f(x + dx))
+        corner = self.c2p(x + dx, f(x))
+        dx_line = Line(p1, corner, color=dx_line_color)
+        dy_line = Line(corner, p2, color=dy_line_color or getattr(graph, "color", YELLOW))
+        parts = [dx_line, dy_line]
+        if dx_label is not None:
+            parts.append((dx_label if isinstance(dx_label, Mobject) else MathTex(dx_label)).next_to(dx_line, DOWN))
+        if dy_label is not None:
+            parts.append((dy_label if isinstance(dy_label, Mobject) else MathTex(dy_label)).next_to(dy_line, RIGHT))
+        if include_secant_line:
+            secant = Line(p1, p2, color=secant_line_color)
+            secant.scale(secant_line_length / secant.get_length())
+            parts.append(secant)
+        return VGroup(*parts)
+
+
+class ThreeDAxes(Axes):
+    def __init__(self, x_range=None, y_range=None, z_range=None, x_length=None, y_length=None,
+                 z_length=None, **kwargs):
+        _tell("3d", "Note: 3D is not shown yet, so this scene plays in 2D.")
+        Axes.__init__(self, x_range, y_range, x_length, y_length, **kwargs)
+
+
+class NumberPlane(Axes):
+    """Parts: background lines, faded lines, x axis, y axis (as Manim's)."""
+    _kind = "number_plane"
+    _axis_index = (2, 3)
+
+    def __init__(self, x_range=None, y_range=None, x_length=None, y_length=None,
+                 background_line_style=None, **kwargs):
+        kwargs["background_line_style"] = background_line_style
+        Axes.__init__(self, x_range, y_range, x_length, y_length, **kwargs)
+
+    def _length(self, frame_length, r):
+        return r[1] - r[0]
+
+    def _default_range(self, frame_length):
+        # A plane covers the whole frame.
+        return (-frame_length / 2, frame_length / 2, 1)
+
+    def _extra(self, kwargs):
+        return {"background_line_style": _style_dict(kwargs.pop("background_line_style", None))}
+
+
+class SurroundingRectangle(RoundedRectangle):
+    def __init__(self, mobject, color=YELLOW, buff=SMALL_BUFF, corner_radius=0.0, **kwargs):
+        self._make("surrounding_rectangle", {"mobject": mobject._embed(), "buff": _num(buff),
+                                            "corner_radius": _num(corner_radius)},
+                   dict(kwargs, color=color), n=0)
+
+
+class BackgroundRectangle(SurroundingRectangle):
+    def __init__(self, mobject, color=None, stroke_width=0, stroke_opacity=0, fill_opacity=0.75, buff=0,
+                 **kwargs):
+        if color is None:
+            color = config.background_color
+        self._make("background_rectangle", {"mobject": mobject._embed(), "buff": _num(buff)},
+                   dict(kwargs, color=color, stroke_width=stroke_width, stroke_opacity=stroke_opacity,
+                        fill_opacity=fill_opacity), n=0)
+
+
+class Brace(VMobject):
+    def __init__(self, mobject, direction=DOWN, buff=0.2, **kwargs):
+        self.direction = Vec.of(direction)
+        self._make("brace", {"mobject": mobject._embed(), "direction": _P(direction), "buff": _num(buff)},
+                   kwargs, _FILLED, n=0)
+
+    def put_at_tip(self, mob, use_next_to=True, buff=MED_SMALL_BUFF, **kwargs):
+        return mob.next_to(self, self.direction, buff=buff)
+
+    def get_text(self, *text, **kwargs):
+        """A Tex label at the tip (Manim's: TeX type at the default size, not Text)."""
+        return self.put_at_tip(Tex(*text), **kwargs)
+
+    def get_tex(self, *tex, **kwargs):
+        """A MathTex label at the tip."""
+        return self.put_at_tip(MathTex(*tex), **kwargs)
+
+
+class BraceLabel(VGroup):
+    def __init__(self, obj, text, brace_direction=DOWN, label_constructor=MathTex, font_size=DEFAULT_FONT_SIZE,
+                 buff=0.2, **kwargs):
+        self.brace = Brace(obj, brace_direction, buff=buff)
+        self.label = label_constructor(text, font_size=font_size)
+        self.brace.put_at_tip(self.label)
+        VGroup.__init__(self, self.brace, self.label, **kwargs)
+
+
+class BraceText(BraceLabel):
+    def __init__(self, obj, text, label_constructor=Text, **kwargs):
+        BraceLabel.__init__(self, obj, text, label_constructor=label_constructor, **kwargs)
+
+
+class CameraFrame(Mobject):
+    """The camera frame (MovingCameraScene): target 0, never made."""
+
+    def __init__(self):
+        self._id = 0
+        self._path = None
+        self._kids = None
+        self._n = 0
+
+    def _t(self):
+        return 0
+
+
+class _Camera:
+    def __init__(self):
+        self.frame = CameraFrame()
+
+    @property
+    def background_color(self):
+        return config.background_color
+
+    @background_color.setter
+    def background_color(self, value):
+        config.background_color = value
+
+
+camera = _Camera()
+
+
+# ---------------------------------------------------------------- .animate
+
+class _Animate:
+    """m.animate.shift(UP).scale(2): records the ops, played as one animation."""
+
+    def __init__(self, mob):
+        self._mob = mob
+        self._ops = []
+        self._kw = {}
+
+    def __call__(self, **kwargs):
+        self._kw.update(kwargs)
+        return self
+
+    def __getattr__(self, name):
+        if name.startswith("_"):
+            raise AttributeError(name)
+        fn = getattr(self._mob, name)
+        if not callable(fn):
+            raise AttributeError("%s.animate.%s is not something that can be animated" % (
+                type(self._mob).__name__, name))
+
+        def record(*args, **kwargs):
+            st = _st()
+            prev = st.capture
+            st.capture = (self._mob._t(), self._ops)
+            try:
+                fn(*args, **kwargs)
+            finally:
+                st.capture = prev
+            return self
+        return record
+
+    def _anim(self):
+        a = {"kind": "animate", "target": self._mob._t(), "args": {"ops": self._ops}}
+        _timing(a, self._kw)
+        return a
+
+    def _added(self):
+        return [self._mob]
+
+    def _removed(self):
+        return []
+
+
+# ---------------------------------------------------------------- animations
+
+def _timing(d, kw):
+    for k in ("run_time", "lag_ratio"):
+        if kw.get(k) is not None:
+            d[k] = _num(kw[k])
+    if kw.get("rate_func") is not None:
+        d["rate_func"] = _rate(kw["rate_func"])
+    return d
+
+
+class Animation:
+    kind = "animation"
+
+    def __init__(self, mobject=None, *args, run_time=None, rate_func=None, lag_ratio=None, **kwargs):
+        # Positional arguments after the mobject are the animation's own
+        # (Circumscribe(m, Circle), Indicate(m, 1.5)), as in Manim.
+        self.mobject = mobject
+        self._kw = {"run_time": run_time, "rate_func": rate_func, "lag_ratio": lag_ratio}
+        self._args = self._make_args(*args, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return {}
+
+    def _anim(self):
+        t = self.mobject._t() if isinstance(self.mobject, Mobject) else None
+        return _timing({"kind": self.kind, "target": t, "args": self._args}, self._kw)
+
+    def _added(self):
+        return [self.mobject] if isinstance(self.mobject, Mobject) else []
+
+    def _removed(self):
+        return []
+
+    @property
+    def run_time(self):
+        return self._kw.get("run_time") or 1.0
+
+    def set_run_time(self, run_time):
+        self._kw["run_time"] = run_time
+        return self
+
+    def set_rate_func(self, rate_func):
+        self._kw["rate_func"] = rate_func
+        return self
+
+
+class _Remover(Animation):
+    def _removed(self):
+        return [self.mobject]
+
+
+class Create(Animation):
+    kind = "create"
+
+
+class ShowCreation(Create):
+    pass
+
+
+class Uncreate(_Remover):
+    kind = "uncreate"
+
+
+class Write(Animation):
+    kind = "write"
+
+    def _make_args(self, reverse=False, **kwargs):
+        return {"reverse": bool(reverse)}
+
+
+class Unwrite(_Remover):
+    kind = "unwrite"
+
+    def _make_args(self, reverse=True, **kwargs):
+        return {"reverse": bool(reverse)}
+
+
+class DrawBorderThenFill(Animation):
+    kind = "draw_border_then_fill"
+
+
+class _Fade(Animation):
+    def __init__(self, *mobjects, shift=None, target_position=None, scale=1, **kwargs):
+        mobs = _flat(mobjects)
+        self._many = mobs if len(mobs) > 1 else None
+        self._fade_kw = {"shift": shift, "target_position": target_position, "scale": scale}
+        Animation.__init__(self, mobs[0] if mobs else None, **kwargs)
+
+    def _make_args(self, **kwargs):
+        args = {}
+        kw = self._fade_kw
+        if kw["shift"] is not None:
+            args["shift"] = _P(kw["shift"])
+        if kw["target_position"] is not None:
+            args["target_position"] = _P(kw["target_position"])
+        if kw["scale"] != 1:
+            args["scale"] = _num(kw["scale"])
+        return args
+
+    def _anim(self):
+        if self._many is None:
+            return Animation._anim(self)
+        items = [{"kind": self.kind, "target": m._t(), "args": self._args} for m in self._many]
+        return _timing({"kind": "group", "items": items}, self._kw)
+
+    def _added(self):
+        return self._many or Animation._added(self)
+
+
+class FadeIn(_Fade):
+    kind = "fade_in"
+
+
+class FadeOut(_Fade):
+    kind = "fade_out"
+
+    def _removed(self):
+        return self._added()
+
+
+class Transform(Animation):
+    kind = "transform"
+
+    def __init__(self, mobject, target_mobject=None, path_arc=0, **kwargs):
+        self.target_mobject = target_mobject
+        if not isinstance(target_mobject, Mobject):
+            raise TypeError("%s needs two mobjects: %s(a, b)" % (type(self).__name__, type(self).__name__))
+        Animation.__init__(self, mobject, path_arc=path_arc, **kwargs)
+
+    def _make_args(self, path_arc=0, **kwargs):
+        return {"target_mobject": self.target_mobject._embed(), "path_arc": _num(path_arc)}
+
+
+class ReplacementTransform(Transform):
+    kind = "replacement_transform"
+
+    def _added(self):
+        return [self.mobject, self.target_mobject]
+
+    def _removed(self):
+        return [self.mobject]
+
+
+class TransformFromCopy(Transform):
+    kind = "transform_from_copy"
+
+    def _added(self):
+        return [self.target_mobject]
+
+
+class TransformMatchingTex(ReplacementTransform):
+    kind = "transform_matching_tex"
+
+
+class TransformMatchingShapes(ReplacementTransform):
+    kind = "transform_matching_shapes"
+
+
+class MoveToTarget(Transform):
+    def __init__(self, mobject, **kwargs):
+        target = getattr(mobject, "target", None)
+        if target is None:
+            raise TypeError("MoveToTarget needs  m.generate_target()  first")
+        Transform.__init__(self, mobject, target, **kwargs)
+
+
+class Restore(Animation):
+    kind = "restore"
+
+
+class GrowFromCenter(Animation):
+    kind = "grow_from_center"
+
+
+class GrowFromPoint(Animation):
+    kind = "grow_from_point"
+
+    def __init__(self, mobject, point, **kwargs):
+        self._point = point
+        Animation.__init__(self, mobject, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return {"point": _P(self._point)}
+
+
+class GrowFromEdge(Animation):
+    kind = "grow_from_edge"
+
+    def __init__(self, mobject, edge, **kwargs):
+        self._edge = edge
+        Animation.__init__(self, mobject, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return {"edge": _P(self._edge)}
+
+
+class GrowArrow(Animation):
+    kind = "grow_arrow"
+
+
+class SpinInFromNothing(Animation):
+    kind = "spin_in_from_nothing"
+
+    def _make_args(self, angle=PI / 2, **kwargs):
+        return {"angle": _num(angle)}
+
+
+class Indicate(Animation):
+    kind = "indicate"
+
+    def _make_args(self, scale_factor=1.2, color=PURE_YELLOW, **kwargs):
+        return {"scale_factor": _num(scale_factor), "color": _color(color)}
+
+
+class Circumscribe(Animation):
+    kind = "circumscribe"
+
+    def _make_args(self, shape=None, fade_in=False, fade_out=False, time_width=0.3, buff=SMALL_BUFF,
+                   color=YELLOW, stroke_width=DEFAULT_STROKE_WIDTH, **kwargs):
+        name = getattr(shape, "__name__", "Rectangle") if shape is not None else "Rectangle"
+        return {"shape": "Circle" if name in ("Circle", "Ellipse") else "Rectangle", "color": _color(color),
+                "buff": _num(buff), "fade_in": bool(fade_in), "fade_out": bool(fade_out),
+                "time_width": _num(time_width), "stroke_width": _num(stroke_width)}
+
+
+class Flash(Animation):
+    kind = "flash"
+
+    def __init__(self, point, line_length=0.2, num_lines=12, flash_radius=0.1, line_stroke_width=3,
+                 color=YELLOW, time_width=1, **kwargs):
+        self._flash = {"point": _P(point), "color": _color(color), "line_length": _num(line_length),
+                       "num_lines": int(num_lines), "flash_radius": _num(flash_radius),
+                       "line_stroke_width": _num(line_stroke_width), "time_width": _num(time_width)}
+        Animation.__init__(self, None, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return self._flash
+
+
+class Wiggle(Animation):
+    kind = "wiggle"
+
+    def _make_args(self, scale_value=1.1, rotation_angle=0.01 * TAU, n_wiggles=6, **kwargs):
+        return {"scale_value": _num(scale_value), "rotation_angle": _num(rotation_angle),
+                "n_wiggles": int(n_wiggles)}
+
+
+class Rotate(Animation):
+    kind = "rotate"
+
+    def __init__(self, mobject, angle=PI, axis=OUT, about_point=None, **kwargs):
+        self._rot = {"angle": _num(angle), "axis": _P(axis), "about_point": _P(about_point)}
+        Animation.__init__(self, mobject, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return self._rot
+
+
+class Rotating(Rotate):
+    """A steady turn: a full turn over 5 s at constant speed, unless told otherwise."""
+
+    def __init__(self, mobject, axis=OUT, radians=TAU, about_point=None, about_edge=None, run_time=5,
+                 rate_func=linear, **kwargs):
+        Rotate.__init__(self, mobject, radians, axis, about_point, run_time=run_time, rate_func=rate_func,
+                        **kwargs)
+
+
+class MoveAlongPath(Animation):
+    kind = "move_along_path"
+
+    def __init__(self, mobject, path, **kwargs):
+        self._path_mob = path
+        Animation.__init__(self, mobject, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return {"path": self._path_mob._t()}
+
+
+class Wait(Animation):
+    kind = "wait"
+
+    def __init__(self, run_time=1, **kwargs):
+        Animation.__init__(self, None, run_time=run_time, **kwargs)
+
+
+def _as_anim(a, where="play()"):
+    if isinstance(a, (Animation, _Animate)):
+        return a
+    if isinstance(a, Mobject):
+        raise TypeError("%s takes animations, such as Create(m) or m.animate.shift(UP); got a %s"
+                        % (where, type(a).__name__))
+    raise TypeError("%s takes animations, such as Create(m) or m.animate.shift(UP); got %r" % (where, a))
+
+
+class AnimationGroup(Animation):
+    kind = "group"
+
+    def __init__(self, *animations, group=None, run_time=None, rate_func=None, lag_ratio=None, **kwargs):
+        items = []
+        for a in animations:
+            if isinstance(a, (list, tuple, types.GeneratorType)):
+                items.extend(_as_anim(x, type(self).__name__ + "()") for x in a)
+            else:
+                items.append(_as_anim(a, type(self).__name__ + "()"))
+        self.animations = items
+        Animation.__init__(self, None, run_time=run_time, rate_func=rate_func,
+                           lag_ratio=self._lag(lag_ratio))
+
+    def _lag(self, lag_ratio):
+        return lag_ratio
+
+    def _anim(self):
+        return _timing({"kind": self.kind, "items": [a._anim() for a in self.animations]}, self._kw)
+
+    def _added(self):
+        return [m for a in self.animations for m in a._added()]
+
+    def _removed(self):
+        return [m for a in self.animations for m in a._removed()]
+
+
+class Succession(AnimationGroup):
+    kind = "succession"
+
+
+class LaggedStart(AnimationGroup):
+    kind = "lagged"
+
+    def _lag(self, lag_ratio):
+        return 0.05 if lag_ratio is None else lag_ratio
+
+
+def LaggedStartMap(AnimationClass, mobject, arg_creator=None, run_time=2, **kwargs):
+    anims = [AnimationClass(*(arg_creator(m) if arg_creator else (m,))) for m in mobject]
+    return LaggedStart(*anims, run_time=run_time, **kwargs)
+
+
+# ---------------------------------------------------------------- more geometry
+
+class Angle(VMobject):
+    def __init__(self, line1, line2, radius=None, quadrant=(1, 1), other_angle=False, dot=False,
+                 dot_radius=None, dot_distance=0.55, dot_color=WHITE, elbow=False, **kwargs):
+        self._make("angle", {"line1": line1._embed(), "line2": line2._embed(),
+                             "radius": None if radius is None else _num(radius), "quadrant": list(quadrant),
+                             "other_angle": bool(other_angle), "dot": bool(dot),
+                             "dot_radius": None if dot_radius is None else _num(dot_radius),
+                             "dot_distance": _num(dot_distance), "dot_color": _color(dot_color),
+                             "elbow": bool(elbow)}, kwargs, n=None)
+
+    def get_value(self, degrees=False):
+        v = Expr(["get", self._ref(), "value"], "s")
+        return v / DEGREES if degrees else v
+
+    @staticmethod
+    def from_three_points(A, B, C, **kwargs):
+        return Angle(Line(B, A), Line(B, C), **kwargs)
+
+
+class RightAngle(Angle):
+    def __init__(self, line1, line2, length=None, **kwargs):
+        self._make("right_angle", {"line1": line1._embed(), "line2": line2._embed(),
+                                   "length": None if length is None else _num(length)}, kwargs, n=None)
+
+
+class AnnularSector(Arc):
+    def __init__(self, inner_radius=1, outer_radius=2, angle=TAU / 4, start_angle=0, fill_opacity=1,
+                 stroke_width=0, color=WHITE, arc_center=ORIGIN, **kwargs):
+        self._make("annular_sector", {"inner_radius": _num(inner_radius), "outer_radius": _num(outer_radius),
+                                      "angle": _num(angle), "start_angle": _num(start_angle),
+                                      "arc_center": _P(arc_center)},
+                   dict(kwargs, fill_opacity=fill_opacity, stroke_width=stroke_width, color=color), n=0)
+
+
+class Sector(AnnularSector):
+    def __init__(self, radius=1, angle=TAU / 4, start_angle=0, fill_opacity=1, stroke_width=0, color=WHITE,
+                 arc_center=ORIGIN, **kwargs):
+        self._make("sector", {"radius": _num(radius), "angle": _num(angle), "start_angle": _num(start_angle),
+                              "arc_center": _P(arc_center)},
+                   dict(kwargs, fill_opacity=fill_opacity, stroke_width=stroke_width, color=color), n=0)
+
+
+class ArcBetweenPoints(Arc):
+    _kind = "arc_between_points"
+
+    def __init__(self, start, end, angle=TAU / 4, radius=None, **kwargs):
+        self._make(self._kind, {"start": _P(start), "end": _P(end), "angle": _num(angle),
+                                "radius": None if radius is None else _num(radius)}, kwargs, n=self._parts_n)
+
+    _parts_n = 0
+
+
+class CurvedArrow(ArcBetweenPoints):
+    _kind = "curved_arrow"
+    _parts_n = 1
+
+    def __init__(self, start_point, end_point, **kwargs):
+        ArcBetweenPoints.__init__(self, start_point, end_point, **kwargs)
+
+
+class CurvedDoubleArrow(CurvedArrow):
+    _kind = "curved_double_arrow"
+    _parts_n = 2
+
+
+class Elbow(VMobject):
+    def __init__(self, width=0.2, angle=0, **kwargs):
+        self._make("elbow", {"width": _num(width), "angle": _num(angle)}, kwargs, n=0)
+
+
+class Cross(VGroup):
+    def __init__(self, mobject=None, stroke_color=RED, stroke_width=6.0, scale_factor=1.0, **kwargs):
+        self._kids = None
+        self._make("cross", {"mobject": mobject._embed() if mobject is not None else None,
+                             "scale_factor": _num(scale_factor)},
+                   dict(kwargs, color=stroke_color, stroke_color=stroke_color, fill_color=WHITE,
+                        stroke_width=stroke_width), n=2)
+
+
+class Underline(Line):
+    def __init__(self, mobject, buff=SMALL_BUFF, **kwargs):
+        self._make("underline", {"mobject": mobject._embed(), "buff": _num(buff)}, kwargs, n=0)
+
+
+class LabeledDot(Dot):
+    def __init__(self, label, radius=None, buff=SMALL_BUFF, **kwargs):
+        lab = label._embed() if isinstance(label, Mobject) else str(label)
+        self._make("labeled_dot", {"label": lab, "radius": None if radius is None else _num(radius),
+                                   "buff": _num(buff)}, kwargs, _FILLED, n=1)
+
+
+class AnnotationDot(Dot):
+    def __init__(self, radius=DEFAULT_DOT_RADIUS * 1.3, stroke_width=5, stroke_color=WHITE, fill_color=BLUE,
+                 **kwargs):
+        Dot.__init__(self, radius=radius, stroke_width=stroke_width, stroke_color=stroke_color,
+                     fill_color=fill_color, **kwargs)
+
+
+class DashedVMobject(VMobject):
+    def __init__(self, vmobject, num_dashes=15, dashed_ratio=0.5, dash_offset=0, color=None,
+                 equal_lengths=True, **kwargs):
+        # The dashes keep the object's own style (a Circle's dashes are red).
+        self._make("dashed_vmobject", {"vmobject": vmobject._embed(), "num_dashes": int(num_dashes),
+                                       "dashed_ratio": _num(dashed_ratio), "dash_offset": _num(dash_offset),
+                                       "equal_lengths": bool(equal_lengths)},
+                   dict(kwargs, color=color), {}, n=int(num_dashes))
+
+
+class CubicBezier(VMobject):
+    def __init__(self, start_anchor, start_handle, end_handle, end_anchor, **kwargs):
+        self._make("cubic_bezier", {"start_anchor": _P(start_anchor), "start_handle": _P(start_handle),
+                                    "end_handle": _P(end_handle), "end_anchor": _P(end_anchor)}, kwargs, n=0)
+
+
+class TangentLine(Line):
+    def __init__(self, vmob, alpha, length=1, d_alpha=1e-6, **kwargs):
+        self._make("tangent_line", {"vmobject": vmob._embed(), "alpha": _num(alpha), "length": _num(length)},
+                   kwargs, n=0)
+
+
+# ---------------------------------------------------------------- text and layout
+
+def _text_kwargs(kwargs):
+    return {k: kwargs.pop(k) for k in ("font_size", "font", "weight", "slant", "line_spacing", "letter_spacing")
+            if k in kwargs}
+
+
+class Paragraph(VGroup):
+    def __init__(self, *text, line_spacing=-1, alignment=None, **kwargs):
+        lines = "\n".join(str(t) for t in text).split("\n")
+        self.lines_text = lines
+        self._kids = None
+        geom = {"lines": lines, "line_spacing": _num(line_spacing), "alignment": alignment,
+                "font_size": DEFAULT_FONT_SIZE}
+        geom.update(_text_kwargs(kwargs))
+        self._make("paragraph", geom, kwargs, _FILLED, n=len(lines))
+
+
+class BulletedList(VGroup):
+    def __init__(self, *items, buff=MED_LARGE_BUFF, dot_scale_factor=2, tex_environment=None, dot_buff=SMALL_BUFF,
+                 **kwargs):
+        self.items = [str(i) for i in items]
+        self._kids = None
+        geom = {"items": self.items, "buff": _num(buff), "dot_scale_factor": _num(dot_scale_factor),
+                "dot_buff": _num(dot_buff), "font_size": DEFAULT_FONT_SIZE}
+        geom.update(_text_kwargs(kwargs))
+        self._make("bulleted_list", geom, kwargs, _FILLED, n=len(self.items))
+
+    def fade_all_but(self, index, opacity=0.5):
+        for i in range(len(self.items)):
+            self[i].set_opacity(1.0 if i == index else opacity)
+        return self
+
+
+class MarkupText(Text):
+    def __init__(self, text, fill_opacity=1, stroke_width=0, color=None, font_size=DEFAULT_FONT_SIZE,
+                 line_spacing=-1, font="", slant=NORMAL, weight=NORMAL, justify=False, **kwargs):
+        import re
+        plain = re.sub(r"&[a-z]+;", "x", re.sub(r"<[^>]*>", "", str(text)))
+        self.text = str(text)
+        self._make("markup_text", {"text": str(text), "font_size": _num(font_size), "line_spacing": _num(line_spacing),
+                                   "font": font, "slant": slant, "weight": weight, "justify": bool(justify)},
+                   dict(kwargs, color=color or WHITE, fill_opacity=fill_opacity, stroke_width=stroke_width),
+                   _FILLED, n=sum(1 for ch in plain if not ch.isspace()))
+
+
+def _entry(v, element):
+    """A table or matrix entry: a string the engine sets in the element kind, or an existing mobject."""
+    if isinstance(v, Mobject):
+        return v._embed()
+    return str(v)
+
+
+def _element_of(element_to_mobject, default):
+    names = {MathTex: "mathtex", Tex: "tex", Text: "paragraph", Paragraph: "paragraph",
+             DecimalNumber: "mathtex", Integer: "mathtex"}
+    return names.get(element_to_mobject, default)
+
+
+def _format_entries(rows, element_to_mobject, config):
+    if element_to_mobject in (Integer,):
+        return [["%d" % int(round(float(x))) for x in r] for r in rows]
+    if element_to_mobject in (DecimalNumber,):
+        places = int((config or {}).get("num_decimal_places", 2))
+        return [[("%." + str(places) + "f") % float(x) for x in r] for r in rows]
+    return rows
+
+
+class Table(VGroup):
+    _element = "paragraph"
+
+    def __init__(self, table, row_labels=None, col_labels=None, top_left_entry=None, v_buff=0.8, h_buff=1.3,
+                 include_outer_lines=False, include_inner_lines=True, add_background_rectangles_to_entries=False,
+                 entries_background_color=BLACK, include_background_rectangle=False,
+                 background_rectangle_color=BLACK, element_to_mobject=None, element_to_mobject_config=None,
+                 arrange_in_grid_config=None, line_config=None, **kwargs):
+        rows = [list(r) for r in table]
+        rows = _format_entries(rows, element_to_mobject, element_to_mobject_config)
+        element = _element_of(element_to_mobject, self._element)
+        self.n_rows = len(rows) + (1 if col_labels else 0)
+        self.n_cols = (len(rows[0]) if rows else 0) + (1 if row_labels else 0)
+        self._kids = None
+        self._make("table", {
+            "table": [[_entry(v, element) for v in r] for r in rows], "element": element,
+            "row_labels": [m._embed() for m in row_labels] if row_labels else None,
+            "col_labels": [m._embed() for m in col_labels] if col_labels else None,
+            "top_left_entry": top_left_entry._embed() if top_left_entry is not None else None,
+            "v_buff": _num(v_buff), "h_buff": _num(h_buff), "include_outer_lines": bool(include_outer_lines),
+            "include_inner_lines": bool(include_inner_lines),
+            "include_background_rectangle": bool(include_background_rectangle),
+            "background_rectangle_color": _color(background_rectangle_color),
+            "add_background_rectangles_to_entries": bool(add_background_rectangles_to_entries),
+            "entries_background_color": _color(entries_background_color),
+            "line_config": _style_dict(line_config),
+        }, kwargs, {}, n=3)
+
+    def get_entries(self, pos=None):
+        if pos is None:
+            return self[0]
+        r, c = pos
+        return self[0][(r - 1) * self.n_cols + (c - 1)]
+
+    def get_entries_without_labels(self, pos=None):
+        return self.get_entries(pos)
+
+    def get_rows(self):
+        return VGroup(*[VGroup(*[self[0][r * self.n_cols + c] for c in range(self.n_cols)])
+                        for r in range(self.n_rows)])
+
+    def get_columns(self):
+        return VGroup(*[VGroup(*[self[0][r * self.n_cols + c] for r in range(self.n_rows)])
+                        for c in range(self.n_cols)])
+
+    def get_horizontal_lines(self):
+        return self[1]
+
+    def get_vertical_lines(self):
+        return self[2]
+
+    def get_cell(self, pos, **kwargs):
+        return SurroundingRectangle(self.get_entries(pos), buff=0.1, **kwargs)
+
+
+class MathTable(Table):
+    _element = "mathtex"
+
+
+class IntegerTable(Table):
+    def __init__(self, table, element_to_mobject=Integer, **kwargs):
+        Table.__init__(self, table, element_to_mobject=element_to_mobject, **kwargs)
+
+
+class DecimalTable(Table):
+    def __init__(self, table, element_to_mobject=DecimalNumber, element_to_mobject_config=None, **kwargs):
+        Table.__init__(self, table, element_to_mobject=element_to_mobject,
+                       element_to_mobject_config=element_to_mobject_config or {"num_decimal_places": 1}, **kwargs)
+
+
+class Matrix(VMobject):
+    _default_element = MathTex
+    _default_config = None
+
+    def __init__(self, matrix, v_buff=0.8, h_buff=1.3, bracket_h_buff=MED_SMALL_BUFF,
+                 bracket_v_buff=MED_SMALL_BUFF, add_background_rectangles_to_entries=False,
+                 include_background_rectangle=False, element_to_mobject=None, element_to_mobject_config=None,
+                 element_alignment_corner=DR, left_bracket="[", right_bracket="]", stretch_brackets=True,
+                 bracket_config=None, **kwargs):
+        rows = [list(r) if isinstance(r, (list, tuple)) or hasattr(r, "tolist") else [r]
+                for r in _unarray(matrix)]
+        rows = [list(_unarray(r)) for r in rows]
+        element_to_mobject = element_to_mobject or self._default_element
+        rows = _format_entries(rows, element_to_mobject, element_to_mobject_config or self._default_config)
+        self.n_rows = len(rows)
+        self.n_cols = len(rows[0]) if rows else 0
+        self._make("matrix", {
+            "matrix": [[_entry(v, "mathtex") for v in r] for r in rows], "v_buff": _num(v_buff),
+            "h_buff": _num(h_buff), "bracket_h_buff": _num(bracket_h_buff), "bracket_v_buff": _num(bracket_v_buff),
+            "left_bracket": left_bracket, "right_bracket": right_bracket,
+            "element_alignment_corner": _P(element_alignment_corner),
+            "include_background_rectangle": bool(include_background_rectangle),
+            "add_background_rectangles_to_entries": bool(add_background_rectangles_to_entries),
+        }, kwargs, _FILLED, n=3)
+
+    def get_entries(self):
+        return self[0]
+
+    def get_mob_matrix(self):
+        return [[self[0][r * self.n_cols + c] for c in range(self.n_cols)] for r in range(self.n_rows)]
+
+    def get_rows(self):
+        return VGroup(*[VGroup(*row) for row in self.get_mob_matrix()])
+
+    def get_columns(self):
+        return VGroup(*[VGroup(*[self[0][r * self.n_cols + c] for r in range(self.n_rows)])
+                        for c in range(self.n_cols)])
+
+    def get_brackets(self):
+        return VGroup(self[1], self[2])
+
+    def set_column_colors(self, *colors):
+        for col, color in zip(self.get_columns(), colors):
+            col.set_color(color)
+        return self
+
+    def set_row_colors(self, *colors):
+        for row, color in zip(self.get_rows(), colors):
+            row.set_color(color)
+        return self
+
+
+class IntegerMatrix(Matrix):
+    _default_element = Integer
+
+
+class DecimalMatrix(Matrix):
+    _default_element = DecimalNumber
+    _default_config = {"num_decimal_places": 1}
+
+
+class MobjectMatrix(Matrix):
+    pass
+
+
+_CODE_LANGS = {".py": "python", ".js": "javascript", ".ts": "typescript", ".c": "c", ".cpp": "cpp",
+               ".java": "java", ".rs": "rust", ".go": "go", ".rb": "ruby", ".sh": "bash", ".html": "html",
+               ".css": "css", ".json": "json", ".lua": "lua", ".swift": "swift", ".kt": "kotlin"}
+
+
+class Code(VMobject):
+    def __init__(self, code_file=None, code_string=None, language=None, formatter_style="vim", tab_width=4,
+                 add_line_numbers=True, line_numbers_from=1, background="rectangle", background_config=None,
+                 paragraph_config=None, **kwargs):
+        if code_string is None and code_file is not None:
+            with open(code_file) as fh:
+                code_string = fh.read()
+        code = (code_string or "").expandtabs(tab_width).rstrip("\n")
+        if language is None and code_file:
+            language = _CODE_LANGS.get("." + str(code_file).rsplit(".", 1)[-1].lower())
+        self.code_lines = code.split("\n")
+        self._make("code", {"code": code, "language": language or "python", "tab_width": int(tab_width),
+                            "add_line_numbers": bool(add_line_numbers), "line_numbers_from": int(line_numbers_from),
+                            "background": background, "formatter_style": formatter_style,
+                            "background_config": _style_dict(background_config),
+                            "paragraph_config": _style_dict(paragraph_config)}, kwargs, {},
+                   n=3 if add_line_numbers else 2)
+
+    @property
+    def code(self):
+        return self[self._n - 1]
+
+    @property
+    def line_numbers(self):
+        return self[1] if self._n == 3 else None
+
+    @property
+    def background(self):
+        return self[0]
+
+
+# ---------------------------------------------------------------- more graphing
+
+class ComplexPlane(NumberPlane):
+    _kind = "complex_plane"
+
+    def number_to_point(self, number):
+        z = complex(number)
+        return self.c2p(z.real, z.imag)
+
+    n2p = number_to_point
+
+
+class PolarPlane(Axes):
+    def __init__(self, radius_max=None, size=None, radius_step=1, azimuth_step=None, azimuth_units="PI radians",
+                 azimuth_compact_fraction=True, azimuth_offset=0, azimuth_direction="CCW",
+                 azimuth_label_buff=SMALL_BUFF, azimuth_label_font_size=24, radius_config=None,
+                 background_line_style=None, faded_line_style=None, faded_line_ratio=1, **kwargs):
+        w, h = _frame_size()
+        self.radius_max = float(radius_max) if radius_max is not None else h / 2
+        self.size = float(size) if size is not None else 2 * self.radius_max
+        self.x_range = self.y_range = [-self.radius_max, self.radius_max, radius_step]
+        self._make("polar_plane", {
+            "radius_max": self.radius_max, "size": self.size, "radius_step": _num(radius_step),
+            "azimuth_step": azimuth_step, "azimuth_units": azimuth_units,
+            "azimuth_compact_fraction": bool(azimuth_compact_fraction), "azimuth_offset": _num(azimuth_offset),
+            "azimuth_direction": azimuth_direction, "azimuth_label_buff": _num(azimuth_label_buff),
+            "azimuth_label_font_size": _num(azimuth_label_font_size), "radius_config": _style_dict(radius_config),
+            "background_line_style": _style_dict(background_line_style),
+            "faded_line_style": _style_dict(faded_line_style), "faded_line_ratio": int(faded_line_ratio),
+        }, kwargs, n=4)
+
+    _axis_index = (2, 3)
+
+    def polar_to_point(self, radius, azimuth):
+        r, a = _np_scalar(radius), _np_scalar(azimuth)
+        return self.c2p(r * np.cos(a), r * np.sin(a))
+
+    pr2pt = polar_to_point
+
+
+def _np_scalar(v):
+    return v if isinstance(v, Expr) else float(v)
+
+
+class BarChart(Axes):
+    def __init__(self, values, bar_names=None, y_range=None, x_length=None, y_length=None,
+                 bar_colors=("#003f5c", "#58508d", "#bc5090", "#ff6361", "#ffa600"), bar_width=0.6,
+                 bar_fill_opacity=0.7, bar_stroke_width=3, **kwargs):
+        self.values = [float(v) for v in values]
+        self.x_range = [0, len(self.values), 1]
+        self.y_range = list(y_range) if y_range is not None else None
+        self._make("bar_chart", {
+            "values": self.values, "bar_names": [str(n) for n in bar_names] if bar_names else None,
+            "y_range": self.y_range, "x_length": None if x_length is None else _num(x_length),
+            "y_length": None if y_length is None else _num(y_length),
+            "bar_colors": [_color(c) for c in bar_colors], "bar_width": _num(bar_width),
+            "bar_fill_opacity": _num(bar_fill_opacity), "bar_stroke_width": _num(bar_stroke_width),
+        }, kwargs, n=3)
+
+    @property
+    def bars(self):
+        return self[2]
+
+    def get_bar_labels(self, color=None, font_size=24, buff=MED_SMALL_BUFF, label_constructor=None):
+        label_constructor = label_constructor or Tex
+        labels = []
+        for i, v in enumerate(self.values):
+            lab = label_constructor(("%g" % v), font_size=font_size)
+            if color is not None:
+                lab.set_color(color)
+            lab.next_to(self[2][i], UP if v >= 0 else DOWN, buff=buff)
+            labels.append(lab)
+        return VGroup(*labels)
+
+    def change_bar_values(self, values, update_colors=True):
+        self.values = [float(v) for v in values]
+        return self._op("change_bar_values", {"values": self.values})
+
+
+class GenericGraph(VMobject):
+    """Vertices and edges, laid out automatically (Manim's Graph)."""
+    _directed = False
+
+    def __init__(self, vertices, edges, labels=False, label_fill_color=BLACK, layout="spring", layout_scale=2,
+                 layout_config=None, vertex_type=None, vertex_config=None, vertex_mobjects=None, edge_type=None,
+                 partitions=None, root_vertex=None, edge_config=None, **kwargs):
+        self._vlist = list(vertices)
+        index = {v: i for i, v in enumerate(self._vlist)}
+        self._elist = [tuple(e) for e in edges]
+        if isinstance(layout, dict):
+            layout = {str(index[v]): _P(p) for v, p in layout.items()}
+
+        def per_vertex(cfg):
+            cfg = dict(cfg or {})
+            if cfg and all(k in index for k in cfg):
+                return {"per": {str(index[k]): _style_dict(c) for k, c in cfg.items()}}
+            return _style_dict(cfg)
+
+        def per_edge(cfg):
+            cfg = dict(cfg or {})
+            if cfg and all(isinstance(k, tuple) for k in cfg):
+                return {"per": {"%d,%d" % (index[a], index[b]): _style_dict(c) for (a, b), c in cfg.items()}}
+            return _style_dict(cfg)
+
+        self._make("network_graph", {
+            "vertices": [str(v) for v in self._vlist], "edges": [[index[a], index[b]] for a, b in self._elist],
+            "directed": self._directed, "labels": bool(labels) if not isinstance(labels, dict) else
+            {str(index[k]): str(v) for k, v in labels.items()}, "label_fill_color": _color(label_fill_color),
+            "layout": layout, "layout_scale": _j(layout_scale), "layout_config": _j(layout_config or {}),
+            "root_vertex": index.get(root_vertex) if root_vertex is not None else None,
+            "partitions": [[index[v] for v in p] for p in partitions] if partitions else None,
+            "vertex_config": per_vertex(vertex_config), "edge_config": per_edge(edge_config),
+        }, kwargs, {}, n=2)
+        self.vertices = {v: _Part(_Part(self, 0), i) for i, v in enumerate(self._vlist)}
+        self.edges = {e: _Part(_Part(self, 1), j) for j, e in enumerate(self._elist)}
+
+    def __getitem__(self, key):
+        if isinstance(key, int) and not isinstance(key, bool) and key in (0, 1) and key not in self._vertex_keys():
+            return Mobject.__getitem__(self, key)
+        if key in self._vertex_keys():
+            return self.vertices[key]
+        return Mobject.__getitem__(self, key)
+
+    def _vertex_keys(self):
+        return self.__dict__.get("vertices") or {}
+
+    def change_layout(self, layout="spring", layout_scale=2, layout_config=None, root_vertex=None, **kwargs):
+        index = {v: i for i, v in enumerate(self._vlist)}
+        if isinstance(layout, dict):
+            layout = {str(index[v]): _P(p) for v, p in layout.items()}
+        return self._op("change_layout", {"layout": layout, "layout_scale": _j(layout_scale),
+                                          "layout_config": _j(layout_config or {}),
+                                          "root_vertex": index.get(root_vertex)})
+
+
+class Graph(GenericGraph):
+    pass
+
+
+class DiGraph(GenericGraph):
+    _directed = True
+
+
+# ---------------------------------------------------------------- pictures
+
+_MIME = {"png": "image/png", "jpg": "image/jpeg", "jpeg": "image/jpeg", "gif": "image/gif",
+         "webp": "image/webp", "svg": "image/svg+xml", "bmp": "image/bmp"}
+
+
+class SVGMobject(VMobject):
+    def __init__(self, file_name=None, should_center=True, height=2, width=None, color=None, opacity=None,
+                 fill_color=None, fill_opacity=None, stroke_color=None, stroke_opacity=None, stroke_width=None,
+                 svg_default=None, path_string_config=None, use_svg_cache=True, trace=None, ops=None,
+                 remove_background=False, resize=None, **kwargs):
+        geom = {"should_center": bool(should_center), "height": None if height is None else _num(height),
+                "width": None if width is None else _num(width)}
+        extra = ()
+        image = _own_attr(file_name, "_cir_image_src") or file_name
+        if trace is not None or (isinstance(image, str) and image.lower().endswith(_IMAGE_EXTS)):
+            # A picture traced to outlines in the preview (2Vec), after any image ops.
+            ref = _preview_object(image)
+            if ref is not None:
+                self._source = ref
+                extra = ({"$h": ref._handle()},)
+                image = None
+            geom.update(image_src=image, ops=_image_op_chain(ops, remove_background, resize),
+                        trace=_trace_params(trace))
+            style = {k: v for k, v in dict(color=color, opacity=opacity, fill_color=fill_color,
+                                           fill_opacity=fill_opacity, stroke_color=stroke_color,
+                                           stroke_opacity=stroke_opacity, stroke_width=stroke_width).items()
+                     if v is not None}
+            self._make("svg_mobject", geom, dict(kwargs, **style), {}, n=None, extra=extra)
+            return
+        ref = _preview_object(file_name)
+        traced = _own_attr(file_name, "_cir_svg")   # an image's .trace() (pyctures_images.Vector)
+        text = file_name if isinstance(file_name, str) else _own_attr(file_name, "svg")
+        if isinstance(traced, str):
+            geom["svg"] = traced
+        elif ref is not None:
+            # An SVG worked out in the preview (an image's .trace()): sent as the
+            # call's 4th argument, which the page resolves to the object.
+            self._source = ref
+            extra = ({"$h": ref._handle()},)
+        elif isinstance(text, str) and text.lstrip().startswith("<"):
+            geom["svg"] = text   # SVG markup itself
+        else:
+            try:
+                with open(str(file_name), encoding="utf-8") as fh:
+                    geom["svg"] = fh.read()
+            except (OSError, TypeError):
+                geom["file_name"] = str(file_name)
+        style = {k: v for k, v in dict(color=color, opacity=opacity, fill_color=fill_color,
+                                       fill_opacity=fill_opacity, stroke_color=stroke_color,
+                                       stroke_opacity=stroke_opacity, stroke_width=stroke_width).items()
+                 if v is not None}
+        self._make("svg_mobject", geom, dict(kwargs, **style), {}, n=None, extra=extra)
+
+
+def _png_data_uri(pixels):
+    """An image array (rows of [r, g, b(, a)] 0-255, or floats 0-1) as a PNG data URI."""
+    import base64, struct, zlib
+    rows = [list(_unarray(r)) for r in _unarray(pixels)]
+    h, w = len(rows), len(rows[0]) if rows else 0
+
+    def px(v):
+        v = list(_unarray(v)) if hasattr(v, "__len__") or hasattr(v, "tolist") else [v, v, v]
+        scale = 255.0 if all(isinstance(x, float) and x <= 1.0 for x in v) else 1.0
+        v = [max(0, min(255, int(round(float(x) * scale)))) for x in v]
+        return (v + [255])[:4] if len(v) >= 3 else [v[0], v[0], v[0], 255]
+
+    raw = b"".join(b"\x00" + bytes(c for p in r for c in px(p)) for r in rows)
+
+    def chunk(tag, data):
+        return struct.pack(">I", len(data)) + tag + data + struct.pack(">I", zlib.crc32(tag + data) & 0xFFFFFFFF)
+    png = (b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", struct.pack(">IIBBBBB", w, h, 8, 6, 0, 0, 0))
+           + chunk(b"IDAT", zlib.compress(raw)) + chunk(b"IEND", b""))
+    return "data:image/png;base64," + base64.b64encode(png).decode("ascii")
+
+
+def _own_attr(obj, name):
+    """obj.name only if obj really has it: a JsRef answers every name with a lazy
+    member (and records a command), so look without calling __getattr__."""
+    found = inspect.getattr_static(obj, name, None)
+    if found is None:
+        return None
+    return getattr(obj, name)
+
+
+def _preview_object(v):
+    """A JavaScript object in the browser page (a loaded or processed image, a canvas),
+    or a wrapper holding one: its JsRef, else None."""
+    if isinstance(v, _rt.JsRef):
+        return v
+    for name in ("_jsref", "ref", "handle"):
+        x = _own_attr(v, name)
+        if isinstance(x, _rt.JsRef):
+            return x
+    return None
+
+
+_IMAGE_EXTS = (".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".avif")
+
+
+def _image_op_chain(ops=None, remove_background=False, resize=None):
+    """Image ops run in the browser before the picture is used, in order:
+    remove_background, then ops=[("name", {params}) …], then resize. The engine
+    holds the commands after it until they are done, as it does for text."""
+    chain = []
+    if remove_background:
+        chain.append(["remove_background", _j(remove_background) if isinstance(remove_background, dict) else {}])
+    for op in ops or ():
+        if isinstance(op, str):
+            chain.append([op, {}])
+        else:
+            op = list(op)
+            chain.append([str(op[0]), _j(op[1] if len(op) > 1 and op[1] else {})])
+    if resize is not None:
+        chain.append(["resize", _j(resize) if isinstance(resize, dict) else {"width": _num(resize)}])
+    return chain
+
+
+def _trace_params(trace):
+    return _j(trace) if isinstance(trace, dict) else {}
+
+
+class ImageMobject(Mobject):
+    """A picture: a path beside the .py, a web address, a data URI, an array, or
+    an image already in the browser page (load_image(...), and what image ops return).
+    Optional rounded corners, a border, a shadow and a crop. Image ops run in the
+    browser, no await needed: ops=[("remove_background",), ("resize", {"width": 800})],
+    or remove_background=True, resize=800; trace=True (or {...}) makes it a vector
+    outline instead."""
+
+    def __init__(self, filename_or_array, scale_to_resolution=1080, invert=False, image_mode="RGBA",
+                 corner_radius=0, border_color=None, border_width=0, shadow=None, crop=None, ops=None,
+                 remove_background=False, resize=None, trace=None, **kwargs):
+        # A Picture (pyctures_images) names its source: a relative path, or a blob:
+        # URL for an image op's result.
+        src = _own_attr(filename_or_array, "_cir_image_src") or filename_or_array
+        ref = _preview_object(src)
+        extra = ()
+        if ref is not None:
+            # The element itself travels as the call's 4th argument (the page
+            # resolves a top-level {"$h": n} to the object).
+            self._source = ref   # keeps the browser object alive
+            src = None
+            extra = ({"$h": ref._handle()},)
+        elif not isinstance(src, str):
+            src = _png_data_uri(src)
+        # A relative path is sent as written: the app reads it from the file's folder.
+        self.src = src
+        chain = _image_op_chain(ops, remove_background, resize)
+        if trace:
+            # Traced to vector outlines (2Vec): an SVG object made from the picture.
+            self._make("svg_mobject", {"image_src": src, "ops": chain, "trace": _trace_params(trace),
+                                       "should_center": True, "height": None, "width": None},
+                       kwargs, {}, n=None, extra=extra)
+            return
+        props = {"src": src, "scale_to_resolution": int(scale_to_resolution), "invert": bool(invert)}
+        if chain:
+            props["ops"] = chain
+        self._make("image_mobject", props, kwargs, {}, n=0, extra=extra)
+        if crop is not None:
+            self.crop(*crop)
+        if corner_radius:
+            self.set_corner_radius(corner_radius)
+        if border_color is not None or border_width:
+            self.set_border(border_color or WHITE, border_width or DEFAULT_STROKE_WIDTH)
+        if shadow:
+            self.set_shadow(**(shadow if isinstance(shadow, dict) else {}))
+
+    def set_corner_radius(self, radius):
+        return self._op("set_corner_radius", {"radius": _num(radius)})
+
+    def set_border(self, color=WHITE, width=DEFAULT_STROKE_WIDTH):
+        return self._op("set_border", {"color": _color(color), "width": _num(width)})
+
+    def crop(self, x0=0.0, y0=0.0, x1=1.0, y1=1.0):
+        """Keep the box (x0, y0)–(x1, y1), as fractions of the picture, origin bottom-left."""
+        return self._op("crop", {"box": [_num(x0), _num(y0), _num(x1), _num(y1)]})
+
+
+# ---------------------------------------------------------------- more animations
+
+class ApplyMethod(Animation):
+    """ApplyMethod(m.shift, UP): the method's change, played."""
+    kind = "animate"
+
+    def __init__(self, method, *args, **kwargs):
+        timing = {k: kwargs.pop(k) for k in ("run_time", "rate_func", "lag_ratio") if k in kwargs}
+        mob = method.__self__
+        ops = []
+        st = _st()
+        prev = st.capture
+        st.capture = (mob._t(), ops)
+        try:
+            method(*args, **kwargs)
+        finally:
+            st.capture = prev
+        self._ops = ops
+        Animation.__init__(self, mob, **timing)
+
+    def _make_args(self, **kwargs):
+        return {"ops": self._ops}
+
+
+class ApplyFunction(Animation):
+    """ApplyFunction(f, m): f's change to m, played."""
+    kind = "animate"
+
+    def __init__(self, function, mobject, **kwargs):
+        ops = []
+        st = _st()
+        prev = st.capture
+        st.capture = (mobject._t(), ops)
+        try:
+            result = function(mobject)
+        finally:
+            st.capture = prev
+        if isinstance(result, Mobject) and result is not mobject:
+            ops.append(["become", {"mobject": result._embed()}])
+        self._ops = ops
+        Animation.__init__(self, mobject, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return {"ops": self._ops}
+
+
+def _trace_formula(fn, args, what):
+    tr, result, err = _run_trace(fn, args)
+    if err is not None or result is None:
+        raise TypeError("%s needs a function that can be worked out with + - * / and np.sin, np.cos … "
+                        "(not math.* or an if on the point)%s" % (what, ": %s" % err if err else ""))
+    return _tree(result)
+
+
+class ApplyPointwiseFunction(Animation):
+    kind = "apply_pointwise_function"
+
+    def __init__(self, function, mobject, run_time=3, **kwargs):
+        self._formula = _trace_formula(function, (_var("p", "v"),), "ApplyPointwiseFunction")
+        Animation.__init__(self, mobject, run_time=run_time, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return {"function": self._formula}
+
+
+class Homotopy(Animation):
+    kind = "homotopy"
+
+    def __init__(self, homotopy, mobject, run_time=3, apply_function_kwargs=None, **kwargs):
+        self._formula = _trace_formula(homotopy, (_var("x"), _var("y"), _var("z"), _var("t")), "Homotopy")
+        Animation.__init__(self, mobject, run_time=run_time, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return {"homotopy": self._formula}
+
+
+class ShowPassingFlash(_Remover):
+    kind = "show_passing_flash"
+
+    def _make_args(self, time_width=0.1, **kwargs):
+        return {"time_width": _num(time_width)}
+
+
+class ShowIncreasingSubsets(Animation):
+    kind = "show_increasing_subsets"
+
+    def _make_args(self, suspend_mobject_updating=False, int_func=None, reverse_rate_function=False, **kwargs):
+        return {"int_func": "ceil" if getattr(int_func, "__name__", "") == "ceil" else "floor"}
+
+
+class ShowSubmobjectsOneByOne(ShowIncreasingSubsets):
+    kind = "show_increasing_subsets"
+
+
+class AddTextLetterByLetter(Animation):
+    kind = "add_text_letter_by_letter"
+
+    def __init__(self, text, suspend_mobject_updating=False, int_func=None, rate_func=linear, time_per_char=0.1,
+                 run_time=None, reverse_rate_function=False, introducer=True, **kwargs):
+        self._tpc = time_per_char
+        if run_time is None:
+            n = text._count()
+            run_time = max(1 / 60, n * time_per_char) if n is not None else None
+        Animation.__init__(self, text, run_time=run_time, rate_func=rate_func, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return {"time_per_char": _num(self._tpc)}
+
+
+class RemoveTextLetterByLetter(AddTextLetterByLetter):
+    kind = "remove_text_letter_by_letter"
+
+    def _removed(self):
+        return [self.mobject]
+
+
+class CyclicReplace(Animation):
+    kind = "cyclic_replace"
+
+    def __init__(self, *mobjects, path_arc=90 * DEGREES, **kwargs):
+        self._mobs = _flat(mobjects)
+        self._arc = path_arc
+        Animation.__init__(self, None, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return {"mobjects": [m._embed() for m in self._mobs], "path_arc": _num(self._arc)}
+
+    def _added(self):
+        return list(self._mobs)
+
+
+class Swap(CyclicReplace):
+    kind = "swap"
+
+
+class FadeTransform(ReplacementTransform):
+    kind = "fade_transform"
+
+    def __init__(self, mobject, target_mobject, stretch=True, dim_to_match=1, **kwargs):
+        self._fade = {"stretch": bool(stretch), "dim_to_match": int(dim_to_match)}
+        ReplacementTransform.__init__(self, mobject, target_mobject, **kwargs)
+
+    def _make_args(self, path_arc=0, **kwargs):
+        return dict({"target_mobject": self.target_mobject._embed()}, **self._fade)
+
+
+class FadeTransformPieces(FadeTransform):
+    kind = "fade_transform_pieces"
+
+
+class ChangeDecimalToValue(Animation):
+    kind = "change_decimal_to_value"
+
+    def __init__(self, decimal_mob, target_number, **kwargs):
+        self._target = target_number
+        if _real_number(target_number):
+            decimal_mob.number = target_number
+        Animation.__init__(self, decimal_mob, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return {"target_number": _num(self._target)}
+
+
+class ChangingDecimal(Animation):
+    kind = "changing_decimal"
+
+    def __init__(self, decimal_mob, number_update_func, suspend_mobject_updating=False, **kwargs):
+        self._formula = _trace_formula(number_update_func, (_var("alpha"),), "ChangingDecimal")
+        Animation.__init__(self, decimal_mob, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return {"function": self._formula}
+
+
+class ChangeSpeed(Animation):
+    kind = "change_speed"
+
+    def __init__(self, anim, speedinfo, rate_func=None, affects_speed_updaters=True, **kwargs):
+        self._inner = _as_anim(anim, "ChangeSpeed()")
+        self._speed = {repr(float(k)): _num(v) for k, v in speedinfo.items()}
+        Animation.__init__(self, None, rate_func=rate_func, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return {"anim": self._inner._anim(), "speedinfo": self._speed}
+
+    def _added(self):
+        return self._inner._added()
+
+    def _removed(self):
+        return self._inner._removed()
+
+
+class Broadcast(Animation):
+    kind = "broadcast"
+
+    def __init__(self, mobject, focal_point=ORIGIN, n_mobs=5, initial_opacity=1, final_opacity=0,
+                 initial_width=0.0, remover=True, lag_ratio=0.2, run_time=3, **kwargs):
+        self._b = {"focal_point": _P(focal_point), "n_mobs": int(n_mobs), "initial_opacity": _num(initial_opacity),
+                   "final_opacity": _num(final_opacity), "initial_width": _num(initial_width)}
+        Animation.__init__(self, mobject, lag_ratio=lag_ratio, run_time=run_time, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return self._b
+
+    def _added(self):
+        return []
+
+
+class ApplyWave(Animation):
+    kind = "apply_wave"
+
+    def __init__(self, mobject, direction=UP, amplitude=0.2, wave_func=smooth, time_width=1, ripples=1, run_time=2,
+                 **kwargs):
+        self._w = {"direction": _P(direction), "amplitude": _num(amplitude), "wave_func": _rate(wave_func),
+                   "time_width": _num(time_width), "ripples": int(ripples)}
+        Animation.__init__(self, mobject, run_time=run_time, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return self._w
+
+
+class Blink(Animation):
+    kind = "blink"
+
+    def __init__(self, mobject, time_on=0.5, time_off=0.5, blinks=1, hide_at_end=False, **kwargs):
+        self._bl = {"time_on": _num(time_on), "time_off": _num(time_off), "blinks": int(blinks),
+                    "hide_at_end": bool(hide_at_end)}
+        self._hide = hide_at_end
+        Animation.__init__(self, mobject, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return self._bl
+
+
+
+class FocusOn(Animation):
+    kind = "focus_on"
+
+    def __init__(self, focus_point, opacity=0.2, color=GREY, run_time=2, **kwargs):
+        self._f = {"focus_point": _MP(focus_point), "opacity": _num(opacity), "color": _color(color)}
+        Animation.__init__(self, None, run_time=run_time, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return self._f
+
+
+class ShrinkToCenter(Animation):
+    kind = "shrink_to_center"
+
+
+class ApplyMatrix(ApplyPointwiseFunction):
+    """ApplyMatrix([[1, 1], [0, 1]], m): a linear map about about_point."""
+
+    def __init__(self, matrix, mobject, about_point=ORIGIN, **kwargs):
+        rows = [list(_unarray(r)) for r in _unarray(matrix)]
+        n = len(rows)
+        full = [[float(rows[i][j]) if i < n and j < len(rows[i]) else float(i == j) for j in range(3)]
+                for i in range(3)]
+        about = Vec.of(about_point)
+
+        def term(c, v):
+            return v if c == 1 else -v if c == -1 else c * v
+
+        def apply(p):
+            q = [p[k] - about[k] if about[k] else p[k] for k in range(3)]
+            out = []
+            for i in range(3):
+                terms = [term(full[i][j], q[j]) for j in range(3) if full[i][j]]
+                v = terms[0] if terms else 0.0
+                for t in terms[1:]:
+                    v = v + t
+                out.append(v + about[i] if about[i] else v)
+            return out
+        ApplyPointwiseFunction.__init__(self, apply, mobject, **kwargs)
+
+
+class ScaleInPlace(Animation):
+    """ScaleInPlace(m, 2): .animate.scale(2) by another name."""
+    kind = "animate"
+
+    def __init__(self, mobject, scale_factor, **kwargs):
+        self._sf = scale_factor
+        Animation.__init__(self, mobject, **kwargs)
+
+    def _make_args(self, **kwargs):
+        return {"ops": [["scale", {"scale_factor": _num(self._sf), "about_point": None, "about_edge": None}]]}
+
+
+# ---------------------------------------------------------------- product explainers
+#
+# Pymations extras (not in Manim), built from the shapes above: cards, callouts,
+# lower thirds, badges, end cards, highlights and a spotlight.
+
+class Card(RoundedRectangle):
+    """A filled panel with rounded corners and a soft shadow."""
+
+    def __init__(self, width=4.0, height=2.5, fill=GREY_E, radius=0.25, shadow=True, stroke_color=None,
+                 stroke_width=0, **kwargs):
+        RoundedRectangle.__init__(self, corner_radius=radius, width=width, height=height, color=fill,
+                                  fill_color=fill, fill_opacity=kwargs.pop("fill_opacity", 1),
+                                  stroke_color=stroke_color or fill, stroke_width=stroke_width, **kwargs)
+        if shadow:
+            self.set_shadow(**(shadow if isinstance(shadow, dict) else {}))
+
+
+class Callout(VGroup):
+    """A label in a box with an arrow to a spot: Callout(button, "Tap here", side=UR)."""
+
+    def __init__(self, target, text, side=UR, distance=1.6, color=YELLOW, text_color=WHITE, font_size=28,
+                 box_color=BLACK, box_opacity=0.8, **text_kwargs):
+        spot = target.get_center() if isinstance(target, Mobject) else (
+            target if isinstance(target, Expr) else Vec.of(target))
+        d = Vec.of(side)
+        norm = abs(d) or 1.0
+        self.label = Text(text, font_size=font_size, color=text_color, **text_kwargs)
+        self.label.move_to(spot + d * (distance / norm))
+        self.box = SurroundingRectangle(self.label, color=color, buff=0.15, corner_radius=0.1,
+                                        fill_color=box_color, fill_opacity=box_opacity)
+        self.arrow = Arrow(self.box, target, buff=0.1, color=color, stroke_width=4)
+        VGroup.__init__(self, self.box, self.label, self.arrow)
+
+
+class LowerThird(VGroup):
+    """A name strip for the bottom left: LowerThird("Ada Lovelace", "Founder")."""
+
+    def __init__(self, title, subtitle=None, color=BLUE, text_color=WHITE, background=BLACK,
+                 background_opacity=0.65, font="", corner=DL, buff=0.6):
+        self.title = Text(title, font_size=36, weight=BOLD, color=text_color, font=font)
+        lines = [self.title]
+        if subtitle:
+            self.subtitle = Text(subtitle, font_size=24, color=GREY_A, font=font)
+            lines.append(self.subtitle)
+        texts = VGroup(*lines).arrange(DOWN, aligned_edge=LEFT, buff=0.12)
+        self.bar = Rectangle(width=0.08, height=1, color=color, fill_opacity=1, stroke_width=0)
+        self.bar.stretch_to_fit_height(texts.height).next_to(texts, LEFT, buff=0.2)
+        inner = VGroup(self.bar, texts)
+        self.box = SurroundingRectangle(inner, buff=0.25, corner_radius=0.1, color=background,
+                                        fill_color=background, fill_opacity=background_opacity, stroke_width=0)
+        VGroup.__init__(self, self.box, inner)
+        self.to_corner(corner, buff=buff)
+
+
+class Badge(VGroup):
+    """A pill-shaped label: Badge("NEW")."""
+
+    def __init__(self, text, color=BLUE, text_color=WHITE, font_size=24, **text_kwargs):
+        self.label = Text(text, font_size=font_size, color=text_color, weight=BOLD, **text_kwargs)
+        self.pill = SurroundingRectangle(self.label, buff=0.12, corner_radius=self.label.height / 2 + 0.12,
+                                         color=color, fill_color=color, fill_opacity=1, stroke_width=0)
+        VGroup.__init__(self, self.pill, self.label)
+
+
+class EndCard(VGroup):
+    """The closing card: a logo, a title and a web address, centred."""
+
+    def __init__(self, logo=None, title="", url=None, subtitle=None, font="", logo_height=1.6):
+        parts = []
+        if logo is not None:
+            self.logo = logo if isinstance(logo, Mobject) else ImageMobject(logo)
+            self.logo.scale_to_fit_height(logo_height)
+            parts.append(self.logo)
+        if title:
+            parts.append(Text(title, font_size=56, weight=BOLD, font=font))
+        if subtitle:
+            parts.append(Text(subtitle, font_size=32, color=GREY_A, font=font))
+        if url:
+            parts.append(Text(url, font_size=30, color=GREY_B, font=font))
+        VGroup.__init__(self, *parts)
+        self.arrange(DOWN, buff=0.4).center()
+
+
+class Highlight(SurroundingRectangle):
+    """A box, or a soft glow (style="glow"), around something to look at."""
+
+    def __init__(self, mobject, color=YELLOW, style="box", buff=0.12, corner_radius=0.12, stroke_width=6,
+                 **kwargs):
+        SurroundingRectangle.__init__(self, mobject, color=color, buff=buff, corner_radius=corner_radius,
+                                      stroke_width=stroke_width, **kwargs)
+        if style == "glow":
+            self.set_stroke(opacity=0.8)
+            self.set_shadow(blur=0.3, offset=(0, 0), color=color, opacity=0.9)
+
+
+class Spotlight(VMobject):
+    """Dims everything except one object: a dark sheet with a hole around it."""
+
+    def __init__(self, mobject, opacity=0.75, buff=0.15, color=BLACK, **kwargs):
+        w, h = _frame_size()
+        W, H = 1.5 * w, 1.5 * h
+        outer = [[-W, -H, 0], [W, -H, 0], [W, H, 0], [-W, H, 0]]
+        b = float(buff)
+        hole = [mobject.get_corner(UL) + Vec(-b, b, 0), mobject.get_corner(UR) + Vec(b, b, 0),
+                mobject.get_corner(DR) + Vec(b, -b, 0), mobject.get_corner(DL) + Vec(-b, -b, 0)]
+        self._make("vmobject", {"subpaths": [[_P(p) for p in outer], [_P(p) for p in hole]], "closed": True,
+                                "mode": "corners"},
+                   dict(kwargs, color=color, fill_color=color, fill_opacity=opacity, stroke_width=0), n=0)
+
+
+# ---------------------------------------------------------------- sound
+
+def _volume(gain):
+    return 1.0 if gain is None else 10 ** (float(gain) / 20.0)
+
+
+def _sound(src, kind="sound", time_offset=0, volume=1.0, fade_in=0, fade_out=0, loop=False):
+    _call("sound", {"src": str(src), "kind": kind, "time_offset": _num(time_offset), "volume": _num(volume),
+                    "fade_in": _num(fade_in), "fade_out": _num(fade_out), "loop": bool(loop)})
+
+
+def add_sound(sound_file, time_offset=0, gain=None, **kwargs):
+    """Play a sound from this point of the timeline (gain in dB, as in Manim)."""
+    _sound(sound_file, "sound", time_offset, _volume(gain))
+
+
+def music(sound_file, volume=0.3, fade_in=0, fade_out=1, loop=True):
+    """A music bed under the whole timeline from here, quiet and looping."""
+    _sound(sound_file, "music", 0, volume, fade_in, fade_out, loop)
+
+
+def wait_for_sound(sound=None, extra=0):
+    """Wait until a sound (or the last one started) has finished, plus extra seconds."""
+    _call("wait_sound", {"src": None if sound is None else str(sound), "extra": _num(extra)})
+
+
+def _end_section_sound():
+    st = _st()
+    if st.section_sound is not None:
+        src, st.section_sound = st.section_sound, None
+        _call("wait_sound", {"src": src, "extra": 0})
+
+
+def _section(name, transition=None, transition_time=None, sound=None):
+    _end_section_sound()
+    if transition and transition != "none":
+        tt = transition_time if transition_time is not None else (config.transition_time or 0.5)
+        _call("section", str(name), {"transition": transition, "transition_time": _num(tt)})
+    else:
+        _call("section", str(name))
+    if sound is not None:
+        _sound(sound)
+        _st().section_sound = str(sound)
+
+
+# ---------------------------------------------------------------- scenes
+
+class Scene:
+    """construct() records the scene; every Scene in the file plays in order."""
+
+    def __init__(self, **kwargs):
+        self.mobjects = []
+        self.camera = _Camera()
+
+    def setup(self):
+        pass
+
+    def construct(self):
+        pass
+
+    def tear_down(self):
+        pass
+
+    def render(self, preview=False):
+        _st().rendered.add(type(self))
+        _run_scene_sync(self)
+
+    # -- the stage
+
+    def _keep(self, mobs, to_front=False):
+        for m in mobs:
+            if m in self.mobjects:
+                if not to_front:
+                    continue
+                self.mobjects.remove(m)
+            self.mobjects.append(m)
+
+    def _drop(self, mobs):
+        # Removing a member of a group on the stage splits that group, so its
+        # other members stay (Manim's rule).
+        out = []
+        for m in self.mobjects:
+            if m in mobs:
+                continue
+            fam = m.get_family()
+            if any(x in fam for x in mobs if x is not m):
+                out.extend(_split(m, mobs))
+            else:
+                out.append(m)
+        self.mobjects[:] = out
+
+    def add(self, *mobjects):
+        mobs = _flat(mobjects)
+        self._keep(mobs, to_front=True)
+        _call("add", [m._t() for m in mobs])
+        return self
+
+    add_foreground_mobjects = add_foreground_mobject = add
+
+    def remove(self, *mobjects):
+        mobs = _flat(mobjects)
+        self._drop(mobs)
+        _call("remove", [m._t() for m in mobs])
+        return self
+
+    remove_foreground_mobjects = remove_foreground_mobject = remove
+
+    def clear(self):
+        self.mobjects = []
+        _call("clear")
+        return self
+
+    def bring_to_front(self, *mobjects):
+        for m in _flat(mobjects):
+            m.set_z_index(max([getattr(x, "z_index", 0) or 0 for x in self.mobjects] + [0]) + 1)
+        return self
+
+    def bring_to_back(self, *mobjects):
+        for m in _flat(mobjects):
+            m.set_z_index(min([getattr(x, "z_index", 0) or 0 for x in self.mobjects] + [0]) - 1)
+        return self
+
+    # -- the timeline
+
+    def play(self, *animations, run_time=None, rate_func=None, lag_ratio=None, **kwargs):
+        anims = []
+        for a in animations:
+            if isinstance(a, (list, tuple, types.GeneratorType)):
+                anims.extend(_as_anim(x) for x in a)
+            else:
+                anims.append(_as_anim(a))
+        if not anims:
+            return
+        # As in Manim, play()'s run_time/rate_func/lag_ratio are SET ON EVERY
+        # animation in the call (overriding their own), so opts stays empty.
+        over = _timing({}, {"run_time": run_time, "rate_func": rate_func, "lag_ratio": lag_ratio})
+        encoded = []
+        for a in anims:
+            d = a._anim()
+            d.update(over)
+            encoded.append(d)
+        _call("play", encoded, {})
+        for a in anims:
+            self._keep(a._added())
+        for a in anims:
+            self._drop(a._removed())
+
+    def wait(self, duration=DEFAULT_WAIT_TIME, stop_condition=None, frozen_frame=None):
+        _call("wait", _num(duration))
+
+    pause = wait
+
+    def wait_until(self, stop_condition, max_time=60):
+        self.wait(max_time)
+
+    transition = None        # "crossfade" | "slide_left" | "wipe" | "none"; else config.transition
+    transition_time = None
+
+    def next_section(self, name="unnamed", section_type=None, skip_animations=False, sound=None):
+        _section(name, sound=sound)
+
+    def add_sound(self, sound_file, time_offset=0, gain=None, **kwargs):
+        add_sound(sound_file, time_offset, gain)
+
+    def music(self, sound_file, **kwargs):
+        music(sound_file, **kwargs)
+
+    def wait_for_sound(self, sound=None, extra=0):
+        wait_for_sound(sound, extra)
+
+    def interactive_embed(self):
+        pass
+
+    embed = interactive_embed
+
+
+class MovingCameraScene(Scene):
+    pass
+
+
+class ZoomedScene(MovingCameraScene):
+    pass
+
+
+class ThreeDScene(Scene):
+    def _flat_note(self):
+        _tell("3d", "Note: 3D is not shown yet, so this scene plays in 2D.")
+
+    def set_camera_orientation(self, *a, **k):
+        self._flat_note()
+
+    def move_camera(self, *a, added_anims=(), run_time=None, **k):
+        self._flat_note()
+        if added_anims:
+            self.play(*added_anims, run_time=run_time)
+        else:
+            self.wait(run_time or 1.0)
+
+    def begin_ambient_camera_rotation(self, *a, **k):
+        self._flat_note()
+
+    def stop_ambient_camera_rotation(self, *a, **k):
+        pass
+
+    def set_to_default_angled_camera_orientation(self, *a, **k):
+        self._flat_note()
+
+    def add_fixed_in_frame_mobjects(self, *mobjects):
+        return self.add(*mobjects)
+
+    add_fixed_orientation_mobjects = add_fixed_in_frame_mobjects
+
+
+def _split(group, gone):
+    out = []
+    for k in group._kids or ():
+        if k in gone:
+            continue
+        if any(x in k.get_family() for x in gone):
+            out.extend(_split(k, gone))
+        else:
+            out.append(k)
+    return out
+
+
+def _scene_section(scene, first):
+    tr = scene.transition if scene.transition is not None else config.transition
+    tt = scene.transition_time if scene.transition_time is not None else config.transition_time
+    _section(type(scene).__name__, None if first else tr, tt)
+
+
+def _run_scene_sync(scene):
+    st = _st()
+    _scene_section(scene, not st.scenes_run)
+    st.scenes_run += 1
+    scene.clear()
+    for step in (scene.setup, scene.construct, scene.tear_down):
+        r = step()
+        if hasattr(r, "send"):
+            r.close()
+            raise TypeError("an async construct() is played by Pymations itself; remove the "
+                            "render() call")
+    _end_section_sound()
+
+
+async def _run_scenes(classes):
+    st = _st()
+    _end_section_sound()
+    for cls in classes:
+        scene = cls()
+        _scene_section(scene, not st.scenes_run)
+        st.scenes_run += 1
+        scene.clear()
+        for step in (scene.setup, scene.construct, scene.tear_down):
+            r = step()
+            if hasattr(r, "send"):
+                await r
+        _end_section_sound()
+
+
+def _defined_at(cls):
+    """The line a Scene class starts on, from the functions it defines."""
+    lines = [f.__code__.co_firstlineno for f in vars(cls).values()
+             if getattr(getattr(f, "__code__", None), "co_filename", None) == _rt.USER_FILE]
+    return min(lines) if lines else 0
+
+
+class _Building:
+    """The Scene runner as the runtime drives it: while it runs, commands record
+    the timeline even when a Pyctures loop is live (an async construct resumes
+    from a tick)."""
+
+    def __init__(self, coro):
+        self.coro = coro
+
+    def send(self, value):
+        st = _st()
+        prev, st.building = st.building, True
+        try:
+            return self.coro.send(value)
+        finally:
+            st.building = prev
+
+    def throw(self, *exc):
+        return self.coro.throw(*exc)
+
+    def close(self):
+        self.coro.close()
+
+
+def _after_top_level(ns):
+    """Every Scene the file defines, in order, each its own section."""
+    st = _st()
+    _end_section_sound()   # a bare script's last section(sound=...)
+    classes = [v for v in list(ns.values())
+               if isinstance(v, type) and issubclass(v, Scene) and v.__module__ == ns.get("__name__")
+               and v.construct is not Scene.construct and v not in st.rendered]
+    # In the order they are written: a class reusing a name already in the
+    # namespace (say Picture) would otherwise keep that name's earlier place.
+    classes.sort(key=_defined_at)
+    if classes:
+        return _Building(_run_scenes(classes))
+    return None
+
+
+# ---------------------------------------------------------------- the bare form
+
+def _bare():
+    st = _st()
+    if st.scene is None:
+        st.scene = Scene()
+    return st.scene
+
+
+def play(*animations, **kwargs):
+    """Play animations on the file's timeline (a script without a Scene class)."""
+    return _bare().play(*animations, **kwargs)
+
+
+def wait(duration=DEFAULT_WAIT_TIME, **kwargs):
+    return _bare().wait(duration)
+
+
+def add(*mobjects):
+    return _bare().add(*mobjects)
+
+
+def remove(*mobjects):
+    return _bare().remove(*mobjects)
+
+
+def clear():
+    return _bare().clear()
+
+
+def section(name, sound=None, transition=None, transition_time=None):
+    """Start a named section of the timeline (a tick on the scrubber). With sound=,
+    play that voice-over and make the section last at least as long as it."""
+    _section(name, transition, transition_time, sound)
+
+
+# numpy when the runtime has it, else the little that scene scripts use. Both
+# turn maths on preview values (tracker values, positions, time) into formulas:
+# the stand-in directly, real numpy through Expr.__array_ufunc__.
+def _np_fn(name, py):
+    def f(*args):
+        if any(_is_sym(a) for a in args):
+            return _fn(name, *[_tree_arg(a) for a in args])
+        if any(isinstance(a, (list, tuple)) for a in args):
+            n = max(len(a) for a in args if isinstance(a, (list, tuple)))
+            cols = [[a[i] if isinstance(a, (list, tuple)) else a for a in args] for i in range(n)]
+            out = [py(*c) for c in cols]
+            return Vec.of(out) if len(out) == 3 and isinstance(args[0], Vec) else out
+        return py(*args)
+    f.__name__ = name
+    return f
+
+
+def _tree_arg(a):
+    return Expr(_tree(a), _shape_of(a)) if isinstance(a, (list, tuple)) else a
+
+
+class _NumpyLite:
+    pi = math.pi
+    e = math.e
+    inf = float("inf")
+
+    @staticmethod
+    def array(v, dtype=None):
+        v = list(v)
+        if len(v) in (2, 3) and all(isinstance(x, (int, float)) for x in v):
+            return Vec.of(v)
+        return v
+
+    asarray = array
+
+    @staticmethod
+    def linspace(a, b, n=50, endpoint=True):
+        n = int(n)
+        d = (n - 1) if endpoint else n
+        return [a + (b - a) * i / (d or 1) for i in range(n)]
+
+    @staticmethod
+    def arange(a, b=None, step=1):
+        if b is None:
+            a, b = 0, a
+        out, x = [], a
+        while (x < b) if step > 0 else (x > b):
+            out.append(x)
+            x += step
+        return out
+
+    @staticmethod
+    def zeros(n):
+        return Vec(0, 0, 0) if n == 3 else [0.0] * int(n)
+
+    @staticmethod
+    def ones(n):
+        return Vec(1, 1, 1) if n == 3 else [1.0] * int(n)
+
+    @staticmethod
+    def where(c, a, b):
+        if any(_is_sym(x) for x in (c, a, b)):
+            return Expr(["where", _tree(c), _tree(a), _tree(b)],
+                        "v" if "v" in (_shape_of(a), _shape_of(b)) else "s")
+        return a if c else b
+
+    @staticmethod
+    def dot(a, b):
+        return sum(x * y for x, y in zip(a, b))
+
+    @staticmethod
+    def sum(v):
+        return sum(v)
+
+    @staticmethod
+    def mean(v):
+        v = list(v)
+        return sum(v) / len(v)
+
+    class linalg:
+        @staticmethod
+        def norm(v):
+            if _is_sym(v):
+                return _fn("norm", _tree_arg(v))
+            return math.sqrt(sum(x * x for x in v))
+
+
+for _k, _py in (("sin", math.sin), ("cos", math.cos), ("tan", math.tan), ("arcsin", math.asin),
+                ("arccos", math.acos), ("arctan", math.atan), ("arctan2", math.atan2), ("sinh", math.sinh),
+                ("cosh", math.cosh), ("tanh", math.tanh), ("exp", math.exp), ("log", math.log),
+                ("log10", math.log10), ("log2", math.log2), ("sqrt", math.sqrt), ("abs", abs),
+                ("absolute", abs), ("floor", math.floor), ("ceil", math.ceil), ("round", round),
+                ("sign", lambda x: (x > 0) - (x < 0)), ("clip", lambda x, lo, hi: min(max(x, lo), hi)),
+                ("minimum", min), ("maximum", max), ("hypot", math.hypot), ("degrees", math.degrees),
+                ("radians", math.radians)):
+    setattr(_NumpyLite, _k, staticmethod(_np_fn(_UFUNCS.get(_k, _k), _py)))
+
+
+class _LazyNumpy:
+    """'np' as Manim's star import gives it, loaded on first use."""
+
+    def _real(self):
+        mod = self.__dict__.get("_mod")
+        if mod is None:
+            try:
+                import numpy as mod
+            except Exception:
+                mod = _NumpyLite
+            self.__dict__["_mod"] = mod
+        return mod
+
+    def __getattr__(self, name):
+        if name.startswith("__"):
+            raise AttributeError(name)
+        return getattr(self._real(), name)
+
+
+np = _LazyNumpy()
+
+
+# ---------------------------------------------------------------- install
+
+# time() stays pymations.time(): a star import must not hide the time module.
+__all__ = [n for n in list(globals()) if not n.startswith("_") and n not in (
+    "sys", "math", "types", "inspect", "VERSION", "H_ANIM", "time")]
+
+_rt._on_start[:] = [h for h in _rt._on_start if getattr(h, "__module__", None) != __name__] + [_on_start]
+_rt._after_top_level[:] = [h for h in _rt._after_top_level
+                           if getattr(h, "__module__", None) != __name__] + [_after_top_level]
+_rt._before_frame[:] = [h for h in _rt._before_frame
+                        if getattr(h, "__module__", None) != __name__] + [_before_frame]
+_rt._on_frame[:] = [h for h in _rt._on_frame if getattr(h, "__module__", None) != __name__] + [_on_frame]
+_rt._live_hooks[:] = [h for h in _rt._live_hooks if getattr(h, "__module__", None) != __name__] + [_stays_live]
+_rt._hidden_vars.update({n: globals()[n] for n in __all__})