← Close

MathPad Help

MathPad is an algebraic equation solver. Enter variables and equations, and MathPad automatically detects unknowns and solves using root-finding. Solve forward or backward — give it any combination of knowns and unknowns.

Getting Started

MathPad organizes work into records, each with a formulas editor and a variables panel. Use the sidebar to create, rename, and switch between records. Open multiple records as tabs.

1. Type variable declarations and equations in the formulas editor
2. Click Solve (or press Ctrl+Enter) to compute results
3. Edit values in the variables panel to quickly change inputs and re-solve

For a hands-on walkthrough, open the records in the Tutorial category in the sidebar — they cover the language and the app step by step, from a first equation through tables, dates, and the workflow tools.

Sidebar and Tabs

The sidebar lists every record, grouped by category. On narrower screens it's hidden behind the hamburger menu (☰) in the header.

Category controls

• Click a category header to collapse or expand it.
• A↓ next to the header toggles between insertion order and alphabetical sort.
• ✕ appears only on empty categories (other than Unfiled and Reference) and deletes them.
• The divider between the sidebar and the editor is draggable; the width persists across sessions.

Preview vs persistent tabs

Single-click a record in the sidebar to open it as a preview tab (italicized, single slot — opening another preview replaces it). A preview is promoted to a persistent tab when you edit the record, rename it, change a setting, or double-click it. Persistent tabs survive reloads; previews do not.

Records

• + New Record creates a blank record in Unfiled.
• To rename, double-click the title in the sidebar, or edit the first line of the record in the formulas editor (the title comes from there).
• To move a record to a different category, open the detail panel (⚙) and pick from the Category dropdown; the dropdown includes a "New category…" option.
• Reset offers two options: Refresh built-in records only (the default) restores the tutorials and examples to their latest versions while keeping your own records and your Constants/Functions; Reset everything wipes every record back to the default starter set. Export first if you want to keep anything.

Variables

Variables are declared with a name followed by a marker that determines their behavior:

Input vs Output

Input markers (:, <-, <<-, ::) define variables you provide values for. Output markers (->, ->>, :>, :>>) define variables that MathPad computes. Output variables are cleared before solving so the solver can fill them in.

Definitions

A variable whose value is an expression (not just a number) acts as a definition:

area: length * width
circumference: 2 * pi * radius

Definitions are evaluated in dependency order — out-of-order and chained dependencies are handled automatically.

Equations

An equation is any line with = between two expressions:

distance = speed * time
a**2 + b**2 = c**2

If all variables have values, MathPad checks that both sides balance. If there's an unknown, it solves using Brent's root-finding method.

For systems of equations with multiple unknowns, the solver algebraically rearranges each equation to isolate every possible variable (both directions — x = z/2 yields x and z substitutions), then uses a recursive backtracking search. It tries small combinations of substitutions first, letting Brent's find one-unknown reductions; if a branch doesn't balance, it backtracks and tries another. Declaring answer variables with a range hint (x[low:high]<-) helps pick the desired root when multiple valid solutions exist.

Degree Equality

Use =° for mod-aware comparison (mod 360 in degrees mode, mod 2π in radians):

heading =° target_heading

This correctly handles wraparound — e.g., 359° and 1° are only 2° apart. Also works as a logical operator in expressions, returning 1 (true) or 0 (false).

Multi-line Equations

Wrap long equations in curly braces:

{long_expression_a + long_expression_b
 = long_expression_c + long_expression_d}

Number Formats

Number Literals

Small values in Float

In Float format, the decimal-places setting is a minimum precision for small numbers, not a hard cap. A value below 1 is shown with at least one more significant figure than your places setting, so it isn't crushed to a couple of digits — at 3 places, 0.0284130625 displays as 0.02841, not 0.028. This keeps small results precise enough to stay consistent with larger related values, so an equation and its algebraic rearrangement both balance.

If a number has more leading zeros than your places setting, it switches to scientific notation instead of a long run of zeros — at 3 places, 3.14×10⁻¹⁴ shows as 3.142e-14 rather than 0.0000000000000314. Full-precision outputs (->>) follow the same rules, showing every significant digit the value carries.

Format Prefixes

Add a format prefix before the marker to control display:

Expression Outputs

Format suffixes also work on expression outputs:

total cost: qty * unit_price
(total cost)$->
(rate)%->
(heading)°->
(Now)@d->

Operators

Listed by precedence (highest to lowest):

Built-in Functions

Function arguments are separated by semicolons: f(a; b; c)

Math

Trigonometry

Uses degrees or radians depending on the record's Degrees mode setting.

Date and Time

Dates are stored as epoch seconds (seconds since Jan 1, 1970 UTC). Use @d to format as a date and @t for durations:

• @d-> — date only (locale format)
• @d->> — date and time (HH:MM:SS)
• @d: — input accepts date text (e.g. 4/1/2026 14:30)
• @t-> — duration as H:MM:SS
• @t->> — duration with fractional seconds
• @t: — input accepts duration text (e.g. 1:30:00)

Durations of 24h or more display with a day count (2d 5:30:00 is 2 days plus 5 hours 30 minutes); the parser accepts the same form on input.

Example: start @d: 4/1/2026 14:30 — Days(start; Now)@t-> shows elapsed time

Control Flow

Iteration

Sum or multiply an expression over an integer range. The second argument is the index variable's name; the index runs from start to end inclusive and is in scope only inside expr.

Example: Sum(1/k**2; k; 1; 1000) — partial sum of the Basel series

Other

For financial helpers like pmt and compound, see the Default Functions record below.

User-defined Functions

Define functions in any record using the syntax:

f(x; y) = expression using x and y

Define functions in the special "Functions" record to make them available to all records. Function parameters use semicolons as separators, just like built-in functions.

In the formulas editor, a definition's signature — the name(arg1; arg2; …) part up to the = — is shown with a subtle highlighted band, so a function definition stands out from an ordinary equation at a glance.

Function bodies can reference values from the Constants record and call other user-defined functions and built-ins. They cannot read variables from the calling record — only the function's parameters and the global environment (constants + functions) are visible inside the body. Shadowing a constant locally (e.g. c: 1 in a record that uses a function referencing c) does not change the function's behavior — it always sees the canonical value from the Constants record. This keeps functions self-contained and predictable.

Default Functions record

A fresh MathPad ships with these functions already defined in the Functions record — available everywhere unless you edit or remove them:

Edit the Functions record to add, remove, or modify these.

Special Records

Variables Panel

The variables panel (above the formulas editor) shows a structured view of all variables:

• Editable inputs for variable values — your edit is saved into the formula text whenever you leave the field (click away, Tab, or Enter). Press Tab or Enter to also re-solve; clicking away just saves without solving
• Readonly fields for output values (selectable and copyable)
• Equation highlighting: green = balanced, orange = unbalanced, red = error
• The ⟲ button next to any editable variable clears its value and re-solves — a quick way to ask "what should this variable be?" without manually clearing first. Ctrl+click adds trace output; Shift+click appends the table-outputs text section.
• Press Escape in an input to revert to the previous value

--Variables-- Section

Add a --Variables-- line in the formulas editor. Only lines below this marker appear in the variables panel. Lines above it (formulas, equations) are hidden from the panel.

• Plain text lines become labels in the panel
• Empty lines become spacers
• Lines starting with // are hidden

Comments

Text in double quotes is treated as a comment and ignored by the solver:

"This is a comment"
x: 42    "the answer"

Comments after a variable declaration appear in the variables panel.

Pre-solve Values

Access a variable's value from before the current solve started:

Example: counter: if(counter~?; counter~ + 1; 0) — increments each time you solve

Inside a table, grid, or vectorDraw body, ~ refers to the value from the PREVIOUS ROW (or cell), not the previous solve. The first row sees no pre-solve values (so x~? is 0); subsequent rows inherit from the previous row. This is the foundation of running-total patterns:

table("Investment growth") = {
  year: 1..10
  balance = if(balance~?; balance~; 0) * (1 + rate) + contrib
  ...
}

Tables, Grids, and Vector Diagrams

Use table to iterate a variable over a range and display results in columns. Use tableGraph to render those rows as an SVG line graph. Use grid for 2D cell grids with two iterators. Use vectorDraw to render SVG vector diagrams (navigation, polar, or cartesian).

Table (Columnar Output)

table("Distance vs Time") = {
  distance = speed * time
  speed: 60
  time<- 1..5
  time->
  distance->
}

Multiple iterators iterate as nested loops over the cartesian product. The first-declared iterator is the outermost loop (changes slowest); the last-declared is innermost (changes fastest). Iterator bounds are evaluated once up-front, so inner iterators cannot depend on outer iterator values.

tableGraph (Line Graph)

Same body syntax as table, but rendered as an SVG line graph. Column 0 is the X-axis; remaining columns are Y series (one line each).

With multiple iterators, line grouping is opt-in: an inner iterator becomes a line-grouping variable only if it has a iter-> output column. The column's label is used in the legend (e.g. Y y-> produces Y = 1.0). Without y->, the inner iterator just sweeps silently and only one line is drawn.

tableGraph("z = x^y") = {
  z = x**y
  x: 1..2..0.1
  y: 1..2..0.1
  X x->
  Y y->
  Z z->
}

The above renders 11 lines (one per y value), each plotting z against x, labeled Y = 1.0, Y = 1.1, … Y = 2.0.

Hover the mouse over a graph to get a crosshair and a readout of the (x, y) coordinates at the pointer.

Grid (2D Cell Grid)

grid("Multiplication") = {
  z = x * y
  z<-
  x<- 1..5
  y<- 1..5
  x->
  y->
  z->
}

Inline expressions in titles

Wrap an expression in backslashes inside the title string to interpolate its current value:

table("Loan at \rate%\ over \years\ years") = { ... }

The expression is evaluated against the record's variables and re-rendered each Solve. Useful for self-labeling tables and graphs whose subject depends on the inputs.

Body Declarations

Equations

Include equations inside the body. If the body has no equations, the table inherits equations from the surrounding record. If the body has any equations, only those are used.

Options

An optional font size can be specified as a second argument:

table("Title"; 12) = {
  ...
}

Click a table title to collapse or expand it.

Vector Diagrams

Use vectorDraw to render SVG vector diagrams. The second argument is the coordinate type (required) and selects how each vector's four outputs are interpreted:

Each vector is defined by four outputs: a start pair (absolute position from the origin) and an end pair. For navigation and polar the end pair is the relative displacement — (direction, magnitude) added to the start. For cartesian the end pair is the absolute destination point (x, y).

vectorDraw("Wind Triangle"; navigation) = {
  "equations..."
  tc °->          "start direction (bearing)"
  start_mag ->    "start magnitude"
  Label end_dir °->   "end direction (labels the vector in the legend)"
  end_mag ->      "end magnitude (relative displacement)"
}

Labels on the end pair identify the vector in the legend. Direction columns use the record's degrees/radians mode (cartesian columns are unitless). Collapsible titles and optional font size work just like tables — for vectorDraw the font size is the third argument: vectorDraw("Title"; polar; 12).

The legend and all vector outputs respect the record's decimal places, strip zeros, and group digits settings.

Solve Status Indicator

When a table, grid, or vector diagram doesn't fully solve, its title shows (n/m solved) indicating how many rows, cells, or unknowns were successfully solved. This indicator is hidden when everything solves.

Import / Export

• Export: saves all records to a file in the browser's downloads folder, in your choice of format — a MathPad .json data file (a complete backup that re-imports exactly and matches the Google Drive format), or the .txt text/PalmOS format.
• Import: loads records from a .txt export file, or from a MathPad .json data file (for example one downloaded from your Google Drive). Import REPLACES all existing records, so export first if you want to keep them.
• The .txt format is also accepted by the original 1997 PalmOS MathPad's MpExport utility, so old PalmOS archives can be imported as-is.
• Records are separated by a line of 27 tildes (~~~~~~~~~~~~~~~~~~~~~~~~~~~); each block starts with metadata (Category, Places, Format, etc.) and is followed by the record's raw text. The file is plain text — open it in any editor to trim, fix, or stitch together exports.

Access Import/Export from the sidebar buttons.

Google Drive Sync

Optional cloud sync keeps all your records on Google Drive and across your devices. Use the Drive control in the header (the cloud / your initial) to sign in. Without it, MathPad still works entirely in your browser — Drive is purely additive.

• Cross-device by default: sign in with the same Google account in another browser or on another computer, and your records appear automatically. MathPad keeps one canonical file, MathPad.json, in a MathPad folder on your Drive, and every device syncs to it.
• Automatic saving: edits save to Drive within a few seconds. The status bar (right side) shows when it last synced.
• Staying signed in: your session is kept alive as you work. Renewing the connection happens during normal clicks/keystrokes, so you may notice a brief Google popup flash about once an hour — that's expected.
• Your data, your control: MathPad uses Drive's per-file permission — it can only see files it created. MathPad.json is plain text you can open, download, or back up yourself.

When two devices disagree

If this device's records and the Drive file differ (e.g. you edited on another device), MathPad asks how to combine them — never overwriting silently:

• Load from Drive — replace this device's records with the Drive version.
• Keep both — save this device's records to a new, separate Drive file and sync with that; the original is left untouched.
• Keep mine — overwrite the Drive file with this device's records.

Open, Save As, and deleting the file

• Open (Drive menu) lists your MathPad files; pick one to switch this device to it.
• Save As saves to a named file (.json is added automatically); saving over an existing name asks before overwriting.
• If you delete the synced file in the Drive web interface, MathPad notices and asks whether to recreate it, save to a new file, or stop syncing and sign out.

Keyboard Shortcuts

Cmd substitutes for Ctrl on Mac.

Solve Button Modifiers

Hold modifier keys when you click the Solve button:

While a solve is running, the Solve button turns red and reads Stop — click it (or press Escape) to cancel. Editing the record, or switching to another record, also cancels a running solve. Most solves finish instantly, so you'll usually only see this on a large table or a heavy computation.

Record Settings

Click the gear icon to configure per-record settings:

The settings panel also shows the record's Created and Modified timestamps. Modified updates only when you edit the formulas text directly — not when you solve, clear, or change variable values in the variables panel.

Example: Loan Calculator

"Loan calculator"

--Functions--
pmt(pv; rate; n; fv) = -(pv + fv / (1 + rate)**n) * rate / (1 - (1 + rate)**-n)

--Equations--
pmt = pmt(pv; rate/12; years*12; fv)

--Variables--
pv $<-   $100,000     "present value (loan or annuity)"
fv $<-   $0           "future value (balloon payment)"
rate %<- 6.125%       "annual interest rate %"
years <- 30           "number of years"
pmt $<-               "monthly payment"

How it works:

1. --Functions-- and --Equations-- are visual labels — only --Variables-- is a real section marker (controls what shows in the variables panel)
2. The function definition is reusable from anywhere below it
3. The equation ties the function to the variables MathPad will solve for
4. The variables section lists inputs and outputs — $ formats as money, % as percent
5. Click Solve to calculate pmt: -$607.61
6. To solve backwards, set pmt: -$2,000 and clear pv, then solve — MathPad finds pv: $329,158.21

← Close