Saturating integer add calculator
Add two integers and keep the sum inside a fixed bit width: 100 + 50 in a signed 8-bit word gives 127 instead of wrapping to a negative number, with the exact sum of 150 shown alongside. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- A
- 100
- B
- 50
- Bits
- 8
- Result
- 127
- Min
- -128
- Max
- 127
- Sum exact
- 150
Saturating integer addition clamps the mathematical sum of two integers to the extreme values that still fit in a chosen fixed-width word, instead of wrapping around the way modular arithmetic and most machine integer types do. Engineers checking DSP kernels, game damage formulas, colour channels, and safety counters need that clamp behaviour spelled out with an exact min, max, and a clear saturated flag. Students comparing wrap-around overflow with saturation need a deterministic oracle that never invents a modular result. This saturating integer add calculator accepts addends a and b, a bit width from two to sixty-four, and an optional signed flag, returns the clamped result, the exact unclamped sum, the representable range, and whether overflow or underflow saturation occurred.
What saturating add means versus wrap-around overflow
Ordinary fixed-width integer addition is modular: when the true sum leaves the representable interval, the machine result wraps by reducing the sum modulo two to the power of the width, which can jump from a large positive value to a large negative one or from just below zero to a large positive.
Saturating addition takes a different policy that many DSP instruction sets, media codecs, and safety-critical counters prefer: if the true sum is larger than the maximum representable value, the result becomes that maximum; if it is smaller than the minimum, the result becomes that minimum; otherwise the result equals the true sum. No modular wrap occurs.
For a signed width of w bits the closed interval is negative two to the power of w minus one through two to the power of w minus one, minus one—the classic two's-complement range for int8, int16, and int32. For unsigned width w the interval is zero through two to the power of w minus one.
Where saturating addition is useful
Embedded and DSP developers use saturating add to mirror ARM QADD-style behaviour, media pipeline stages, and fixed-point accumulators without standing up a full emulator for a single arithmetic check. Colour and audio tooling often saturates channel or sample sums at eight or sixteen bits when previewing blend modes before committing to shader code. Educators teaching computer representation of integers need a side-by-side contrast between modular wrap and saturation with reproducible numbers for int8 through int64.
Failed validation does not consume balance. Keep requests small, pin result and saturated in tests, and you get reproducible clamps for homework, CI oracles, and edge workers without reinventing fixed-width arithmetic tables.
What you can do with it
DSP and fixed-point firmware checks
Verify saturating add against int8/int16/int32 bounds when modelling QADD-style kernels or fixed-point accumulators without a full emulator.
Game and simulation resource clamps
Clamp health, damage, or score sums at a chosen bit width so overflow saturates at max instead of wrapping into a negative value.
FAQ
How does saturating integer add differ from normal overflow?
Normal fixed-width add wraps (modular arithmetic). Saturating add clamps the true sum to the min or max representable value for the chosen bits and signedness, and never wraps.
What bit widths and signed modes are supported?
bits must be an integer from 2 to 64. signed defaults to true (two's-complement range). Set signed false for unsigned range [0, 2^bits−1].
What do saturated and direction mean?
saturated is true when the result was clamped. direction is overflow when the sum exceeded max, underflow when it fell below min, and none when no clamp was needed.
Can a or b lie outside the word range?
Yes. Operands may be any safe integers; only the sum is clamped to the word min/max. That matches common calculator and teaching use when exploring out-of-range inputs.
Why clamp instead of letting the sum wrap around?
Because a wrapped result can jump from a large positive value to a large negative one, a nasty surprise in audio, colour channels or safety counters. Clamping holds the result at the nearest limit, the way many DSP instruction sets and media codecs do.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/dev/saturating-add \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"a":100,"b":50,"bits":8}'const res = await fetch("https://api.kit.forhosting.com/dev/saturating-add", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"a": 100,
"b": 50,
"bits": 8
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/saturating-add",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"a": 100,
"b": 50,
"bits": 8
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/saturating-add", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"a":100,"b":50,"bits":8}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"a":100,"b":50,"bits":8}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/saturating-add", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"a": 100,
"b": 50,
"bits": 8
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.saturating_add",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
What saturating add means versus wrap-around overflow
This calculator implements exactly that clamp: it forms the exact integer sum of a and b with BigInt arithmetic, compares against min and max for the chosen bits and signedness, and emits the clamped result together with a saturated boolean and a direction field of none, overflow, or underflow so callers can log or branch without recomputing the bounds themselves.
Input contract, response shape, and error behaviour
Optional signed defaults to true for a signed two's-complement word; set signed to false for an unsigned range that starts at zero. POST a JSON body with required fields a and b as finite integers (JSON numbers or digit strings with an optional leading sign) whose absolute values stay within Number.MAX_SAFE_INTEGER, and bits as an integer from two through sixty-four. Boolean-like strings such as true, false, yes, no, signed, and unsigned are accepted for convenience. Missing fields, non-integers, bits outside two to sixty-four, and non-boolean signed values fail with invalid_input naming the problem; those failures are not billed. On success the body echoes a, b, bits, and signed; reports min and max for the word; reports sum_exact as the unclamped mathematical sum; reports result as the clamped value; sets saturated true when clamping occurred; and sets direction to none, overflow, or underflow. Values that exceed JavaScript safe integers in the range endpoints or the exact sum are emitted as decimal strings so JSON stays exact. Example: a equals one hundred, b equals fifty, bits equals eight, signed true yields min negative one hundred twenty-eight, max one hundred twenty-seven, sum_exact one hundred fifty, result one hundred twenty-seven, saturated true, and direction overflow—the classic int8 saturating add case.
Where a saturating integer add API earns its keep
Game and simulation authors clamp health, damage, and resource counters so overflow never wraps a nearly full bar into a negative or near-zero value; a public calculator and API make those clamp rules reviewable in design docs.
Integration use cases
Classroom overflow versus saturation demos
Show students the difference between modular wrap and saturating clamp with deterministic min, max, sum_exact, and result for any width 2–64.
Technical questions
What does the saturating integer add calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.