Components

Manimater never writes animation code. The planner picks from these 91 tested components, across 12 subject areas, and fills in their parameters.

Select a component to see its parameters. 27 of them are built on open-source Manim plugins, credited below.

Missing an animation? Request a component.

Tell us what it should show. We open it as a public issue in the open source library, where anyone can build it, and once it is merged every Manimater video can use it.

or open the issue on GitHub

General14

bar_chartA simple bar chart comparing 2-8 values.
  • title string Chart title
  • labels string[], required Category names
  • values number[], required One number per label
  • unit string Unit shown after each value, e.g. 'rpm'
block_flowA left-to-right chain of labelled blocks joined by arrows, with a bright pulse travelling through it to show how a signal, request or piece of data moves from the first block to the last.
  • blocks string[], required the stages in order (2 to 6 short labels (a few words each))
  • title string optional heading above the chain
bullet_pointsA heading with up to 6 key points revealed one by one. Good for lists of facts or steps.
  • heading string, required Slide heading
  • points string[], required 3-6 short points (under 70 characters each)
calloutA highlighted box for one key takeaway, definition, or warning. Good as the final scene.
  • text string, required The message, one or two sentences
  • kind string Style of the box One of: takeaway, definition, warning.
compare_twoTwo columns comparing two things side by side, each with a title and 2-5 points.
  • left_title string, required Left column title
  • left_points string[], required Left points
  • right_title string, required Right column title
  • right_points string[], required Right points
concept_mapConcept map: a central idea with branches and sub-ideas spreading both ways.Built with manim-extensions (MIT)
  • center string, required the central idea
  • branches string[], required 2-6 items written 'Branch: sub, sub' (up to 4 subs each)
equationShows one formula (LaTeX) with an optional title and a legend explaining each symbol.
  • latex string, required LaTeX without $ delimiters, e.g. N_s = \frac{120 f}{P}
  • title string What the formula gives, e.g. 'Synchronous speed'
  • terms string[] Legend lines like 'f: supply frequency (Hz)'
flowchartA chain of 2-8 labelled boxes connected by arrows (process, signal path, cause and effect).
  • steps string[], required Box labels in order, under 30 characters each
  • title string Chart title
focus_ringA pulsing ring drawn round one idea in a row to say 'look here', optionally moving on to a second one.
  • items string[], required the ideas shown side by side (2 to 6 short labels (a few words each))
  • focus integer which item to ring first, counting from 0
  • then integer optional second item to move the ring to, counting from 0; -1 for none
  • title string optional heading above the row
function_plotPlots y = f(x) on labelled axes. Expression may use x, pi, e, sin, cos, tan, exp, log, sqrt, abs, + - * / ^.
  • expression string, required e.g. 'sin(x)' or 'x^2/4'
  • title string Plot title
  • x_min number Left limit of x
  • x_max number Right limit of x
  • y_min number Bottom limit of y
  • y_max number Top limit of y
  • x_label string x-axis label
  • y_label string y-axis label
hierarchy_treeHierarchy tree (org chart or taxonomy): a root with parents and children below it.Built with manim-extensions (MIT)
  • center string, required the root of the tree
  • branches string[], required 2-6 items written 'Branch: sub, sub' (up to 4 subs each)
spotlightStage-light focus: a row of ideas appears, then everything dims except the one the narration is about, then the lights come back up. Good for 'of all these, this is the one that matters'.
  • items string[], required the ideas shown side by side (2 to 6 short labels (a few words each))
  • focus integer which item to light up, counting from 0
  • title string optional heading above the row
timelineTimeline: events in order, each a year and a short description, highlighted one by one.Built with manim-extensions (MIT)
  • events string[], required 2-8 items written 'year: description'
  • title string title in the middle of the line
title_cardOpening or section title with an optional subtitle. Use as the first scene.
  • title string, required Main title
  • subtitle string Short subtitle

Learning and worked examples4

code_walkthroughShows up to 8 lines of code and highlights them one at a time with a short note per line. Use to explain code or an algorithm line by line. For longer code use several scenes with first_line set so numbering continues; narration should mention the lines in order.
  • lines string[], required 1-8 lines of code, indentation with spaces, each under 60 characters
  • notes string[], required One short plain-words note per line, same order and same count as lines (under 70 chars each)
  • language string Language name shown as a label
  • title string Heading, e.g. 'Binary search'
  • first_line integer Number of the first line shown, so long code can be split across scenes
problem_statementA numerical problem laid out as what is Given and what to Find. Use right after the title in a worked-problem video.
  • given string[], required 2-6 given values, short, e.g. 'Supply frequency f = 50 Hz'
  • find string, required What must be found, e.g. 'Synchronous speed N_s'
  • title string Heading
solution_stepsA worked solution: 2-5 steps (6 at most), each with a name, one formula line and a short note, then a boxed final answer. Use after problem_statement. Put one calculation per step (formula, substitution, result).
  • title string Heading
  • steps object[], required 2-5 steps in order
  • answer string Final answer with its unit, e.g. 'N_s = 1500 rpm'. Leave empty to skip the answer box.
trace_tableA dry-run table that fills in one row per step, to follow how variables change while an algorithm or process runs.
  • columns string[], required 2-6 column headings, e.g. variable names
  • rows string[], required Up to 8 rows, cells separated by '|', e.g. 'lo=0 | hi=6 | mid=3'. Same cell count as columns.
  • title string Heading

Electrical machines9

ac_waveformAnimated sine wave(s) with a moving marker. Use 3 phases to show a balanced three-phase supply.
  • phases integer 1 for single-phase, 3 for three-phase One of: 1, 3.
  • frequency_hz number Supply frequency, used for the period note
  • title string Heading
circuitA closed loop circuit with 1-6 elements and animated current flow. Element format 'type:label'; types: battery, ac_source, resistor, capacitor, inductor, lamp, switch.
  • elements string[], required e.g. ['battery:12 V', 'resistor:R = 4 Ω', 'capacitor:C']
  • title string Heading
circuit_diagramCircuit schematic of 1-6 standard symbols. Types: cell, resistor, variable_resistor, capacitor, inductor, switch, closed_switch, diode, zener, thermistor.Built with manim-eng (MIT, no AI-model training)
  • elements string[] 'type:label' round the loop, e.g. ['cell:12 V', 'resistor:R_1']
  • current string current arrow label, e.g. 'I'
phasor_diagramRotating phasor arrows on a circle. Shows magnitude and phase angle of voltages or currents (empty list = balanced three-phase set).
  • phasors object[] Up to 6 phasors
  • rotate boolean Spin the phasors counter-clockwise
  • title string Heading
power_triangleRight triangle of real power P, reactive power Q and apparent power S with the power-factor angle. Use for power factor and reactive power.
  • real_power_kw number Real power P in kW, above 0
  • power_factor number Power factor cos(phi), between 0.1 and 1
  • lagging boolean True for an inductive (lagging) load, false for a capacitive (leading) load
  • title string Heading
rotating_fieldStator cross-section showing how three-phase currents create a rotating magnetic field, with the synchronous speed formula Ns = 120 f / P.
  • poles integer Number of poles One of: 2, 4, 6.
  • frequency_hz number Supply frequency in Hz
synchronous_motorCross-section of a synchronous motor: the rotor locks onto the rotating stator field and turns at exactly synchronous speed; a dial and torque meter show the load angle growing as load increases.
  • poles integer Number of poles One of: 2, 4, 6.
  • frequency_hz number Supply frequency in Hz
torque_speed_curveTorque versus speed characteristic of a motor with a marker sliding along it. Use for comparing how motors behave under load.
  • motor string Motor type One of: induction, dc_shunt, dc_series, synchronous.
  • title string Heading
transformerTwo windings on an iron core: flux links them and the voltage scales by the turns ratio Vs/Vp = Ns/Np. Shows step-up or step-down.
  • turns_ratio number Ns/Np, between 0.1 and 10 (above 1 steps up, below 1 steps down)
  • primary_volts number Primary voltage in volts, 1 to 1000000
  • title string Heading

Power systems6

damper_windingsDamper (amortisseur) windings in a synchronous machine's rotor: how slip makes bars cut flux and the induced current pulls the rotor back in step.
  • poles integer number of poles, an even number from 2 to 8
  • slip number starting slip, 0 to 0.5
dc_dc_converterDC-DC converter (buck, boost, buck-boost): the switching schematic, the inductor current ramping up and down, and the output-to-input ratio curve as the duty cycle changes.
  • topology string converter type One of: buck, boost, buck_boost.
  • vin number input voltage in volts, 1 to 1000
  • duty number fraction of each period the switch is on, 0.1 to 0.9
  • view string which pictures One of: schematic, waveforms, both.
foc_transformField-oriented (vector) motor control: Clarke and Park transforms turning three sine currents into flat d and q values, the rotating d-q frame, torque from the q-axis current, or the full control block diagram.
  • view string which picture One of: clarke_park, dq_frame, torque, block_diagram.
  • frequency_hz number electrical frequency in Hz, 1 to 400
power_gridAn electrical grid: generator, buses, lines and loads with power-flow arrows and a fault that breakers isolate, or substation bus layouts (single bus, double bus, breaker ring) with the route the current takes.
  • layout string grid or substation layout One of: radial, ring, single_bus, double_bus, ring_bus.
  • loads integer loads or feeders, 1 to 4
  • show_fault boolean show a fault and the breakers clearing it
power_stabilityPower-system stability: the rotor angle swinging after a disturbance, the equal-area criterion for a fault cleared at a chosen angle, or a generator's short-circuit current decaying from subtransient to steady state.
  • view string which picture One of: swing, equal_area, fault_current.
  • inertia_h number inertia constant H in seconds, 1 to 12 (swing view)
  • mechanical_power number mechanical power in per unit, 0.1 to 1.2
  • clearing_angle_deg number angle at which the fault is cleared, 20 to 80 degrees (equal_area view)
  • dc_offset boolean include the decaying DC offset (fault_current view)
pwm_inverterPulse-width modulation: a triangle carrier racing a sine reference to make switching pulses, driving a single-phase H-bridge (bipolar or unipolar) or a three-phase inverter.
  • circuit string what to show One of: pwm, h_bridge, three_phase.
  • modulation string H-bridge switching style (only for h_bridge) One of: bipolar, unipolar.
  • modulation_index number reference amplitude over carrier amplitude, 0.1 to 1
  • carrier_ratio integer carrier frequency over reference frequency, 9 to 31

Control systems and signals7

block_diagramControl block diagrams: a feedback loop with signal pulses, a PID controller's three parallel paths, a state-space diagram, or a cascade with a summing junction and live scopes.
  • preset string which diagram One of: feedback, pid, state_space, cascade.
  • show_scopes boolean animate signals through the cascade diagram
bode_plotBode plot (magnitude and phase against frequency) with straight-line asymptotes, a frequency sweep, and the gain and phase margins.
  • poles number[] poles as pairs real, imaginary, real, imaginary (up to 4 values); [-1, 0] is the single pole at -1
  • zeros number[] zeros as pairs real, imaginary, real, imaginary (up to 4 values); [-1, 0] is the single pole at -1
  • gain number loop gain
  • asymptotes boolean draw the straight-line approximation
nyquist_plotNyquist plot of a loop transfer function traced around the critical point minus one, with its mirror image and the encirclement count that decides stability.
  • poles number[] poles as pairs real, imaginary, real, imaginary (up to 4 values); [-1, 0] is the single pole at -1
  • zeros number[] zeros as pairs real, imaginary, real, imaginary (up to 4 values); [-1, 0] is the single pole at -1
  • gain number loop gain
pid_responsePID tuning on a plant's step response: proportional gain alone leaves an offset and ringing, integral action closes the gap, derivative action damps the overshoot.
  • plant string the system being controlled One of: first_order, second_order, integrator.
  • kp number proportional gain, 0 to 20
  • ki number integral gain, 0 to 20
  • kd number derivative gain, 0 to 20
pole_zero_mapPole-zero map in the s-plane (stable on the left) or the z-plane (stable inside the unit circle), with a pole sliding to show how stability changes.
  • poles number[] poles as pairs real, imaginary, real, imaginary (up to 4 values); [-1, 0] is the single pole at -1
  • zeros number[] zeros as pairs real, imaginary, real, imaginary (up to 4 values); [-1, 0] is the single pole at -1
  • domain string s for continuous time, z for discrete time One of: s, z.
root_locusRoot locus: the closed-loop poles walking across the s-plane as the gain increases from zero, with the critical gain where they cross into instability.
  • poles number[] open-loop poles as pairs real, imaginary, real, imaginary (up to 4 values); [-1, 0] is the single pole at -1
  • zeros number[] open-loop zeros as pairs real, imaginary, real, imaginary (up to 4 values); [-1, 0] is the single pole at -1
  • k_max number largest gain to sweep, 0.5 to 200
time_responseStep or impulse response of a system from its poles and zeros, with rise time, overshoot and settling time marked and the pole-zero map beside it.
  • poles number[] poles as pairs real, imaginary, real, imaginary (up to 4 values); [-1, 0] is the single pole at -1
  • zeros number[] zeros as pairs real, imaginary, real, imaginary (up to 4 values); [-1, 0] is the single pole at -1
  • gain number overall gain
  • kind string input signal One of: step, impulse.

Microelectronics and computer architecture7

branch_predictionBranch prediction: the predicted path versus the real one, the flush penalty on a miss, and the saturating-counter state machine.
  • predictor string predictor type One of: static, 1bit, 2bit.
  • outcomes number[] branch outcomes in order, 1 = taken, 0 = not taken (up to 8)
cache_accessSet-associative cache: each address is split into tag, index and offset, the set is searched, and the access hits or replaces a line (LRU or FIFO).
  • addresses number[] byte addresses 0-255 to look up in order (up to 8)
  • sets integer number of sets (1, 2, 4 or 8)
  • ways integer ways per set, 1 to 4
  • policy string replacement policy One of: lru, fifo.
cpu_pipeline5-stage CPU pipeline (IF ID EX MEM WB) as a cycle-by-cycle grid: stall bubbles labelled with their cause, forwarding arrows, and branch flushes.
  • program string instruction sequence One of: raw_hazard, load_use, independent, branch.
  • forwarding boolean forward results between stages instead of stalling
  • branch_policy string how branches are handled One of: stall, predict_not_taken, predict_taken.
memory_systemMemory system: the cache hierarchy with latencies and average access time, the address and data buses with RAM row/column selection, or DMA moving a block while the CPU stays free.
  • view string which picture One of: hierarchy, bus, dma.
  • levels integer cache levels in the hierarchy view, 1 to 3
  • words integer words moved in the dma view, 1 to 8
mosfet_channelMOSFET cross-section: the inversion channel forms as VGS passes the threshold and pinches off as VDS rises, with the drain current. Views: cross-section, or the I_D-V_DS characteristics.
  • kind string transistor type (voltages are magnitudes for pmos) One of: nmos, pmos.
  • vgs number starting gate-source voltage in volts
  • vds number starting drain-source voltage in volts
  • view string which picture One of: cross_section, characteristics.
pn_junctionPN junction: electrons and holes diffusing across the junction, a depletion region that widens in reverse bias and narrows in forward bias. Views: carriers, band diagram, I-V curve.
  • bias_v number bias voltage in volts, -1 (reverse) to 0.65 (forward)
  • view string which picture One of: carriers, bands, iv.
serial_busSerial bus waveforms with the sampling instants and frame fields: SPI (all four modes), I2C, UART, USB (NRZI and bit stuffing), CAN (with arbitration), and a differential pair that cancels noise.
  • variant string protocol One of: spi, i2c, uart, usb, can, diff.
  • data number[] bytes to send, 0-255 (at most 2)
  • mode integer SPI mode 0-3 (CPOL, CPHA); for UART 0 = no parity, 1 = even, 2 = odd

Physics6

electric_fieldField arrows around 1-4 point charges.Built with manim-physics (MIT)
  • charges number[] signed strengths, 1-4 values in -3..3, e.g. [1, -1]
falling_objectsShapes dropped under gravity, bouncing off floor and walls.Built with manim-physics (MIT)
  • objects integer shapes, 1-5
  • bounciness number 0 (dead) to 0.95 (very bouncy)
gear_trainTwo meshing gears; the tooth counts set the speed and torque ratio.Built with manim-extensions (MIT)
  • driver_teeth integer teeth on the driving gear, 8 to 40
  • driven_teeth integer teeth on the driven gear, 8 to 60
lens_raysParallel rays through a convex or concave lens.Built with manim-physics (MIT)
  • kind string lens type One of: converging, diverging.
  • rays integer rays, 3-9
pendulumSimulated pendulum; 2-3 bobs are chaotic with a traced path.Built with manim-physics (MIT)
  • bobs integer number of bobs One of: 1, 2, 3.
  • length number length in metres, 1-3.4
  • angle_degrees number start angle in degrees, 5-90
standing_waveAnimated standing waves for chosen harmonics.Built with manim-physics (MIT)
  • harmonics number[] 1-4 numbers from 1-6, e.g. [1, 2, 3]

Chemistry3

bohr_atomBohr model of an atom (H to Ar): nucleus and orbiting electron shells, counts labelled.Built with manim-chemistry (MIT)
  • element string symbol, H to Ar
chemical_equationA chemical equation with atom counts per element, showing whether it is balanced.Built with manim-chemistry (MIT)
  • equation string e.g. '2H2 + O2 -> 2H2O'
molecule_structureSkeletal structure of a small organic molecule.Built with manim-chemistry (MIT)
  • molecule string molecule One of: methanol, ethanol, acetic acid, acetone, ethene, ethyne, benzene, cyclohexane, glycine.

Computer science14

array_sortBubble, selection or insertion sort of a short array, step by step.Built with manim-dsa (MIT)
  • values number[] 2-8 whole numbers 0-99, e.g. [5, 2, 8, 1, 9]
  • algorithm string algorithm One of: bubble, selection, insertion.
big_o_growthPlots how the work grows with input size n for several Big-O classes (O(1), O(log n), O(n), O(n log n), O(n^2), O(2^n)), so the gap between them is obvious.
  • functions string[] 2-6 of: '1', 'log n', 'n', 'n log n', 'n^2', '2^n'
binary_representationShows how a number from 0 to 255 is written in binary: eight bits with place values 128 to 1, deciding each bit by subtraction, then adding the lit places back up.
  • value integer, required a whole number from 0 to 255
binary_searchBinary search in a sorted array: look at the middle, discard the half that cannot hold the target, repeat. Shows why it takes about log2(n) steps.
  • values number[], required 3-8 whole numbers 0-99 (sorted for you), e.g. [3, 8, 15, 23, 42, 57, 71]
  • target integer, required the number to look for, 0-99
binary_search_treeBinary search tree from inserted values, optionally traversed.Built with manim-dsa (MIT)
  • values number[] 2-8 different numbers 0-99, in insertion order
  • traversal string walk to animate One of: none, inorder, preorder, postorder.
dp_tableDynamic programming on the longest common subsequence of two short words: the table is filled cell by cell from smaller sub-problems, then traced back to read the answer.
  • a string, required first word, 2-6 letters, e.g. 'ABCBD'
  • b string, required second word, 2-6 letters, e.g. 'BDCAB'
file_treeFolder and file tree of a project, with chosen files highlighted in turn.Built with manim-extensions (MIT)
  • paths string[], required 2-8 file paths such as 'src/main.py'
  • highlight string[] up to 4 of those paths (folders or files) to point out
graph_traversalBFS or DFS on a small undirected graph, showing the visit order.Built with manim-dsa (MIT)
  • edges string[] 1-8 edges like 'A-B'
  • start string start node
  • algorithm string search strategy One of: bfs, dfs.
hash_tableHash table with chaining: each key is hashed to a bucket (sum of character codes mod table size) and collisions form a chain. Shows O(1) lookup and what a collision is.
  • keys string[], required 2-6 short keys (1-10 ASCII characters), e.g. ['cat', 'dog', 'bee', 'ant']
  • size integer number of buckets, 4-8 One of: 4, 5, 6, 7, 8.
linked_list_reverseReverses a singly linked list in place with the prev / curr / next pointers, flipping one arrow per step.
  • values string[], required 3-6 short node values (1-4 characters), e.g. ['1', '2', '3', '4']
queue_operationsA queue of capacity 5 starting with 1, 2, 3: enqueue at the back, dequeue from the front (first in, first out).Built with manim-extensions (MIT)
  • operations string[], required up to 8 steps: 'enqueue 4' or 'dequeue' (never more than 5 items, never empty)
recursion_treeCall tree of the naive recursive Fibonacci fib(n): the tree is built level by level, then the repeated sub-calls are highlighted to show why plain recursion is wasteful (and why memoization helps).
  • n integer which Fibonacci number to compute, 2-5 One of: 2, 3, 4, 5.
sequence_diagramSequence diagram: 2-5 participants with lifelines and up to 8 messages in order (requests solid, replies dashed). For TCP handshakes, HTTP requests, login flows, API calls.
  • actors string[], required 2-5 participant names, left to right, e.g. ['Client', 'Server']
  • messages string[], required up to 8 messages: 'Client->Server: SYN' for a request, 'Server-->Client: SYN-ACK' (two dashes) for a reply
  • title string Heading
stack_operationsA stack (LIFO) as values are pushed on and popped off.Built with manim-dsa (MIT)
  • operations string[] 1-8 of 'push N' or 'pop'

Databases2

btree_indexB-tree index built from keys, then one key inserted or searched.Built with manim-databases (MIT)
  • keys number[] 3-12 different numbers 0-99
  • then string after building One of: none, insert, search.
  • key number key to insert or search, 0-99
database_tableA table as rows are inserted, updated, deleted or selected, with the SQL shown.Built with manim-databases (MIT)
  • columns string[] 2-5 column names; the first is the key
  • rows string[] 1-6 rows like '1, alice, shipped'
  • operations string[] 'insert a, b' | 'update row 2 col value' | 'delete row 1' | 'select row 2'

AI and machine learning6

attention_headOne self-attention head: project each word into a query, key and value, score every pair, then mix the values by the scores. With several heads it shows the split into parallel heads and the concatenation back.
  • tokens string[] the sentence as tokens (words or sub-words, 2 to 8, each a short string)
  • causal boolean hide future words, as a language model does while generating
  • heads integer 1 shows a single head in three stages; 2 to 4 shows several heads side by side
attention_heatmapAttention as a grid of who looks at whom: raw scores, scaling, the causal mask, then softmax turning each row into shares that add to one. Optionally with arcs from one word to the words it attends to.
  • tokens string[] the sentence as tokens (words or sub-words, 2 to 8, each a short string)
  • causal boolean mask out future words
  • view string which picture One of: heatmap, arcs, both.
  • query_index integer which word the arcs start from, counting from 0; -1 means the last word
kv_cacheThe KV cache in LLM decoding: each new token writes its key and value into a slot (a sliding window overwrites the oldest), or a timeline comparing the work with and without the cache.
  • view string slots filling up, or the work saved One of: cache, timeline.
  • steps integer tokens generated, 3 to 12
  • window integer sliding-window size; 0 keeps every token
neural_networkFeed-forward neural network, layer by layer, with an optional forward pass.Built with ManimML (MIT)
  • layers number[] neurons per layer, 2-6 layers of 1-8, e.g. [3, 5, 4, 2]
  • forward_pass boolean animate data flowing through
positional_encodingPositional encoding in a transformer: sine and cosine waves of different speeds giving every position a unique pattern, how that pattern is added to a word's embedding, or the whole table seen from above as a heatmap.
  • view string which picture One of: waves, sum, heatmap.
  • tokens string[] the words for the sum view (words or sub-words, 2 to 8, each a short string)
  • d_model integer embedding size, an even number from 4 to 16
  • n_positions integer how many positions to draw, 4 to 24
qkv_projectionQuery, key and value: the same word embedding multiplied by three weight matrices, lighting up each word's row in Q, K and V.
  • tokens string[] the sentence as tokens (words or sub-words, 2 to 8, each a short string)
  • d_head integer size of each query, key and value vector, 2 to 4

Finance13

ad_as_modelAggregate demand and supply: a demand or supply shock, then the long-run return to potential output.Built with manim-extensions (MIT)
  • event string which shock One of: positive_demand_shock, negative_demand_shock, adverse_supply_shock, positive_supply_shock.
  • long_run boolean also show the long-run adjustment
binomial_treeRecombining price tree and a European call valued by working backward from the last step with risk-neutral probability.
  • steps integer steps, 2 to 4
  • up number up factor per step, 1.02 to 1.5
  • down number down factor per step, 0.5 to 0.98
  • rate number interest rate per step, e.g. 0.02
  • strike number strike price (start price is 100), 50 to 200
bond_price_yieldBond price against yield (inverse, convex); or duration tangent vs convexity parabola vs the real curve.
  • view string price curve, or duration and convexity One of: price_yield, duration_convexity.
  • coupon number coupon in percent, 0.5 to 12
  • maturity integer years to maturity, 1 to 30
  • yield_pct number starting yield in percent, 2 to 10
brownian_motionRandom walk, Brownian motion or geometric Brownian motion (prices): many paths, and the histogram of where they end.
  • variant string random_walk, brownian or gbm (price model) One of: random_walk, brownian, gbm.
  • paths integer paths drawn, 3 to 16
  • volatility number yearly volatility, 0.02 to 1
  • drift number yearly drift, -0.5 to 0.5
garch_volatilityVolatility clustering: returns over a band that widens after big moves (GARCH), or how volatility fades after one shock.
  • view string bands over returns, or decay after one shock One of: bands, shock.
  • alpha number reaction to the last move, 0.01 to 0.3
  • beta number memory of past volatility, 0.3 to 0.97
  • shock_at integer day of the big move (bands view), 5 to 80
is_lm_ad_asIS-LM and AD-AS side by side, linked: one policy or supply shock moves both diagrams.Built with manim-extensions (MIT)
  • policy string which change One of: monetary_expansion, monetary_contraction, fiscal_expansion, fiscal_contraction, adverse_supply_shock, positive_supply_shock.
is_lm_modelIS-LM diagram: a monetary or fiscal policy change shifts one curve and moves interest rate and output.Built with manim-extensions (MIT)
  • policy string which policy One of: monetary_expansion, monetary_contraction, fiscal_expansion, fiscal_contraction.
option_greeksOption value curve sharpening toward its payoff as time runs out, with delta tangent and a Greek (delta, gamma, theta, vega) beside it.
  • greek string which Greek to profile One of: delta, gamma, theta, vega.
  • option_type string call or put One of: call, put.
  • strike number strike price
  • volatility number yearly volatility, 0.05 to 1
option_payoffOption profit or loss at expiry as a hockey stick with break-even and max gain/loss; also straddle, bull spread, collar.
  • kind string call or put One of: call, put.
  • strategy string position shape One of: single, straddle, bull_spread, collar.
  • strike number strike price
  • premium number price paid per share
  • side string long (buy) or short (sell) One of: long, short.
order_book_matchingLimit order book with bids, asks and spread: a buy order sweeps price levels, partly fills, or joins the queue (price-time priority).
  • scenario string what the incoming order does One of: market_buy, partial_fill, limit_joins_queue.
  • depth integer price levels per side, 3 to 5
solow_growthSolow growth model: change savings, population growth or depreciation and watch the steady state move.Built with manim-extensions (MIT)
  • change string what changes One of: increase_savings, decrease_savings, population_growth, increase_depreciation.
supply_demandSupply and demand curves; one curve shifts and the equilibrium price and quantity move.Built with manim-extensions (MIT)
  • event string what happens One of: demand_increase, demand_decrease, supply_increase, supply_decrease.
  • size number how far the curve shifts, 1 to 3
yield_curve_shiftYield curve (3M to 30Y) morphing under a parallel shift, steepening, flattening or inversion, with what it means.
  • shift string how the curve moves One of: parallel_up, parallel_down, steepen, flatten, invert.
  • size_bps number size in basis points, 10 to 250

Built with community plugins

These components draw with open-source plugins for Manim, the animation library. Each plugin keeps its own licence and belongs to its authors. Thank you to them.

  • manim-chemistryMITbohr_atom, chemical_equation, molecule_structure
  • manim-databasesMITbtree_index, database_table
  • manim-dsaMITarray_sort, binary_search_tree, graph_traversal, stack_operations
  • manim-engMIT, no AI-model trainingcircuit_diagram
  • manim-extensionsMITconcept_map, hierarchy_tree, timeline, file_tree, queue_operations, ad_as_model, is_lm_ad_as, is_lm_model, solow_growth, supply_demand, gear_train
  • manim-physicsMITelectric_field, falling_objects, lens_rays, pendulum, standing_wave
  • ManimMLMITneural_network