Does 0.1 + 0.2 actually show 0.3 here, or the usual floating-point mess?

It shows a clean 0.3. JavaScript computes the raw sum as 0.30000000000000004 because binary floating-point can't represent 0.1 or 0.2 exactly, but this calculator rounds every result to 12 significant digits before displaying it, which hides that artifact for everyday numbers.

If I type 2 + 3 x 4 =, do I get 14 or 20?

You get 20. Pressing an operator while a previous operation is still pending evaluates that pending step immediately (2 + 3 = 5 first), then the next operator applies to that result (5 x 4 = 20). This is standard behavior for ordinary four-function calculators, not a bug — a scientific calculator that applies full order of operations across a typed chain would give 14 instead.

Is there a scientific mode, parentheses, or memory keys (M+/M-/MR)?

No. This is a four-function calculator plus percentage and history — there are no trigonometric functions, exponents, square roots, parentheses, or memory registers in the interface. If you need those, this specific tool isn't built for it.

Does it upload my calculations anywhere?

No. Every calculation happens in your browser and your history is stored only in your browser's localStorage. Nothing is sent to a server, and the tool keeps working with no internet connection at all.

What happens with very large or very precise numbers?

Results are rounded to 12 significant digits before display, which can silently change an exact large integer — for example, the 15-digit number 999999999999999 displays as 1000000000000000. Once a result's magnitude reaches roughly 1e21, the display switches to exponential notation (like 1e+21) regardless of that rounding.

What happens if I divide by zero?

The calculator catches it explicitly and shows a localized 'Error' message instead of Infinity or NaN, then clears the pending operation so you can start a fresh calculation right away.

🧮 Online Calculator — Free, with History & Keyboard Support

Toolio's Calculator handles add, subtract, multiply, divide, and percentage, plus a scrollable history of your last 50 results saved in your browser — nothing scientific, no parentheses, and no memory keys (M+, M-, MR), because none of those buttons exist in the interface. A real operator-precedence parser runs under the hood, but the on-screen buttons only ever feed it one operation at a time, so pressing 2 + 3 x 4 = behaves like an ordinary desk calculator and returns 20, not the 14 you'd get from strict algebraic order of operations. Every result is also rounded to 12 significant digits before display, which is why 0.1 + 0.2 shows a clean 0.3 instead of JavaScript's raw 0.30000000000000004.

Toolio's Calculator is a browser-based four-function calculator — addition, subtraction, multiplication, division, and percentage — with a 50-entry history and full keyboard support, running entirely offline.

No history yet

Private by design. This tool runs entirely in your browser — nothing you enter is uploaded or stored, and it works offline.

About

What this calculator does — and doesn't

The button grid gives you AC, backspace, %, divide, multiply, subtract, add, the digits 0-9, a decimal point, and equals — that's the full feature set. There is no square root, no exponent, no trigonometry, no parentheses, and no memory registers; if you need those, this isn't the tool. The keyboard mirrors the buttons one-for-one: number keys, +, -, *, /, Enter or = for equals, Backspace, Escape to clear, and % for percentage, all wired to a single listener that stays out of the way while you're typing in any other input field on the page.

How the math works

Operator precedence works differently than many people expect from a 'calculator.' Internally, the tool builds an expression string and evaluates it with a proper shunting-yard algorithm that does respect multiplication and division before addition and subtraction — but the button interface only ever hands that evaluator one operator and two numbers at a time. Concretely: press 2, +, 3, x, 4, = and here is what happens step by step — pressing + stores 2 as the pending left-hand value; pressing 3 sets the next number; pressing x forces the pending 2 + 3 to be evaluated immediately (because a new operator arrived while a result was still pending), giving 5, which becomes the new left-hand value; pressing 4 sets the next number; pressing = evaluates 5 x 4 and shows 20. A calculator that applied full order of operations across the whole typed chain would show 14 (2 + 12) instead. This chain-style behavior matches ordinary four-function calculators (the kind built into most phones' standard mode) rather than a scientific or expression-based calculator, and it is the single most common source of 'wrong answer' reports for tools like this.

Floating-point handling is the other place where the visible number and the raw computed number diverge. Binary floating-point cannot represent most base-10 fractions exactly, so JavaScript computes 0.1 + 0.2 as 0.30000000000000004 and 100 x 1.1 as 110.00000000000001. Before anything reaches the display, the tool rounds every result to 12 significant digits, which quietly turns both of those back into the clean 0.3 and 110 a human expects. That fix has real limits, though: a 15-digit whole number like 999999999999999 gets rounded up to 1000000000000000 by the same 12-digit cutoff, changing an exact integer into a different exact integer purely because of display rounding — not a floating-point artifact, but a genuine loss of the value you actually typed. And once a result's magnitude reaches roughly 1e21, JavaScript's own number formatting switches to exponential notation (1e+21) no matter what the 12-digit rounding would otherwise show.

A few smaller guardrails round out the behavior: dividing by zero throws internally and the display shows a localized 'Error' message rather than Infinity or NaN, clearing the pending operation so you can start over; raw digit entry is capped at 15 characters while typing (backspace still works normally down to a single 0); and percentage behaves contextually — pressing % with a pending operation computes a percentage of the stored left-hand value (200, +, 10, % shows 20, so pressing = afterward gives 220), while pressing % on its own just divides the current display by 100.

Calculation history — last 50, saved in your browser

History keeps your most recent 50 calculations in the browser's localStorage under this tool's own namespace; the 51st push silently drops the oldest entry. Clicking any history row recalls that result back into the display and its expression line so you can keep building on it, and Clear History wipes the list immediately with a toast confirming it happened. Because it's localStorage, the history is tied to this specific browser on this specific device — it does not sync across tabs opened in a private/incognito context, across browsers, or across devices.

How to use

Type digits using your keyboard or tap the on-screen number buttons.
Press +, -, x, or / (or the matching keyboard key) to choose an operation; pressing a second operator immediately evaluates the pending one first.
Use % for percentages: with a pending operation, it computes a percentage of the stored value (200, +, 10, % then = gives 220); on its own, it divides the current display by 100.
Press Enter or = to see the final result — it's saved to History automatically and rounded to 12 significant digits for display.
Click any entry in the History panel to recall that result and its expression, then keep calculating from there.
Press Escape or click AC to clear everything, or Backspace to remove the last digit you typed.

FAQ

Does 0.1 + 0.2 actually show 0.3 here, or the usual floating-point mess?: It shows a clean 0.3. JavaScript computes the raw sum as 0.30000000000000004 because binary floating-point can't represent 0.1 or 0.2 exactly, but this calculator rounds every result to 12 significant digits before displaying it, which hides that artifact for everyday numbers.
If I type 2 + 3 x 4 =, do I get 14 or 20?: You get 20. Pressing an operator while a previous operation is still pending evaluates that pending step immediately (2 + 3 = 5 first), then the next operator applies to that result (5 x 4 = 20). This is standard behavior for ordinary four-function calculators, not a bug — a scientific calculator that applies full order of operations across a typed chain would give 14 instead.
Is there a scientific mode, parentheses, or memory keys (M+/M-/MR)?: No. This is a four-function calculator plus percentage and history — there are no trigonometric functions, exponents, square roots, parentheses, or memory registers in the interface. If you need those, this specific tool isn't built for it.
Does it upload my calculations anywhere?: No. Every calculation happens in your browser and your history is stored only in your browser's localStorage. Nothing is sent to a server, and the tool keeps working with no internet connection at all.
What happens with very large or very precise numbers?: Results are rounded to 12 significant digits before display, which can silently change an exact large integer — for example, the 15-digit number 999999999999999 displays as 1000000000000000. Once a result's magnitude reaches roughly 1e21, the display switches to exponential notation (like 1e+21) regardless of that rounding.
What happens if I divide by zero?: The calculator catches it explicitly and shows a localized 'Error' message instead of Infinity or NaN, then clears the pending operation so you can start a fresh calculation right away.