Engineering calculators

Measure first.
Provision with evidence.

Four transparent planning tools for model memory, AI service cost, texture residency and real-time frame budgets.

Precision engineering workbench with interconnected capacity, security and measurement modules — CAPACITY / COST / FIDELITY / LATENCYCALC-04

Calculations stay in this browser Equations and assumptions remain visible Last verified 28 Jul 2026

Planning arithmetic

Turn assumptions
into a budget.

Early estimates do not replace profiling, invoices or target-device tests. They expose the variables that matter, reveal impossible combinations sooner and give teams a more useful starting point for measurement.

Four connected budgets

Plan the constraint
before it plans you.

Every calculator shows its component breakdown, unit system, planning reserve and source basis.

01 / CAPACITY

GPU model memory

Estimate logical weights, KV cache, runtime allowance and per-device memory under an explicit sharding assumption.

Open memory planner ↗ 02 / ECONOMICS

AI service cost

Convert tasks, model calls, token shape, cache use, retries and accepted outcomes into a monthly API estimate.

Open cost planner ↗ 03 / FIDELITY

Texture residency

Calculate every mip level with exact format blocks, then scale across textures, layers, copies and residency.

Open texture planner ↗ 04 / LATENCY

Frame-time budget

Compare CPU and GPU critical paths against hard and reserved deadlines for common real-time targets.

Open frame planner ↗

Four precision calculation instruments connected to a central verification core — INPUTFORMULARESERVERESULT

Visible assumptions

The result is only
as clear as the inputs.

01
Define the unitGiB is not GB. A token price is not a task price. A frame average is not a tail result.
02
Separate componentsWeights, cache, retries, mip levels and pipeline stages remain independently visible.
03
Keep a reservePlanning to the theoretical limit removes room for peaks, fragmentation and change.
04
Measure realityValidate the estimate with representative workloads, production usage and target hardware.

Interactive workbench

Change an input.
See the consequence.

Values update locally as you type. Reset any tool to its documented planning scenario, then copy a concise result for review.

01 / GPU MODEL MEMORY

Estimate the inference working set.

Logical weight storage plus transformer KV cache, a runtime allowance and reserved headroom. The per-device result assumes weights and cache are evenly sharded across the selected accelerators.

Model and devices

Parametersbillion Weight precision Weight metadata allowance% Acceleratorsdevices Available memory per deviceGiB Runtime allowance per deviceGiB Free headroom target%

KV cache shape

Transformer layers KV heads per layer Dimension per head Active tokens per sequencetokens Concurrent sequences KV cache precision

Required memory per device

92.4 GiB

Fits the selected 96 GiB class with 3.6 GiB planned headroom

Logical weights, cluster: 134.3 GiB
KV cache, cluster: 20.0 GiB
Runtime allowance, cluster: 12.0 GiB
Working set, per device: 83.1 GiB
Required memory, cluster: 184.8 GiB
Nearest common class: 96 GiB

Planning estimate only. Quantization metadata, activations, graph capture, kernels, allocator fragmentation, expert routing and runtime-specific sharding can change the measured requirement.

Weightsparameters × bytes per weight × (1 + metadata allowance)

KV cache2 × layers × KV heads × head dimension × tokens × concurrency × bytes

Headroomper-device working set ÷ (1 - reserve)

Primary references: NVIDIA NIM memory guidance ↗ Hugging Face cache structure ↗

02 / AI SERVICE COST

Price the accepted business outcome.

This compact planner reuses the date-stamped API rate catalogue from the AI Cost Atlas, then adds calls per task, retry load and accepted-task yield.

Service demand

API model Business tasks per day Billing days Model calls per task Retry or rework load% Accepted task yield%

Tokens per model call

Input tokenstokens Output tokenstokens Cached input share% Batch or commitment reduction%

OpenAI, United States. $1.00 input, $0.10 cached input and $6.00 output per million tokens. Requests above 272K input tokens use higher rates for the full request. Cache writes cost 1.25x the ordinary input rate.

Official source for OpenAI ↗

Estimated monthly API cost

$1,301

Standard snapshot rates verified 27 Jul 2026

Monthly model calls: 453,600
Cost per model call: $0.0029
Cost per accepted task: $0.0047
Retry cost contribution: $96.3648
Estimated cache saving: $196
Daily API estimate: $43.3642

Taxes, region, service tier, tools, grounding, media, cache writes, storage and provider-specific rules are excluded unless represented in the selected rate. Confirm the live invoice model before committing spend.

Callstasks × days × calls per task × (1 + retry share)

Tokenscalls × input, cached input and output volume

Accepted taskmonthly API cost ÷ accepted business tasks

Rate ledger and deeper break-even modelling: ADOR.IS AI Cost and Economics Atlas ↗

03 / TEXTURE RESIDENCY

Count every mip and compression block.

Each level is rounded to complete format blocks before the result is multiplied across layers, textures, resident copies and the chosen residency share.

Texture shape and format

Widthpx Heightpx GPU format Include full mip chain

Residency and budget

Texture count Faces or array layers Resident copies Resident share% Available texture budgetMiB

Estimated resident payload

853.33 MiB

41.7% of the selected texture budget

Base level per texture: 16 MiB
Complete chain per texture: 21.33 MiB
Mip levels: 13
Nominal format rate: 8 bits per pixel
Remaining selected budget: 1.17 GiB
Maximum equivalent count: 95 textures

This is format payload, not a promise of physical allocation. Driver tiling, row pitch, alignment, metadata, platform substitution and sparse-residency behavior can change actual GPU memory. Disk and transfer compression are different quantities.

Each levelceil(width ÷ block width) × ceil(height ÷ block height) × block bytes

Full chainsum every exact level down to 1 × 1

Residencychain × layers × textures × copies × resident share

Primary references: Khronos KTX 2.0 specification ↗ Vulkan format registry ↗

04 / FRAME-TIME BUDGET

Protect the critical path.

Compare the longest CPU lane and profiled GPU work against a hard display deadline. Add only GPU overlap that has been verified in a profiler.

Target and CPU lanes

Target frame rate Pipeline model Planning reserve% Game or main threadms Render threadms Driver or RHI threadms Other CPU critical lanems

GPU passes and presentation

Geometry and visibilityms Lighting and shadingms Post-process and UIms Other GPU workms Verified GPU overlapms Presentation and syncms

Projected workload frame time

11.4 ms

Within reserved budget

Hard frame deadline: 16.67 ms
Safe working budget: 13.33 ms
CPU critical lane: 7.20 ms
GPU critical path: 10.80 ms
Current bottleneck: GPU
Projected cadence, including sync: 87.7 FPS
Safe headroom: 1.93 ms available

This estimates processing cadence, not complete motion-to-photon latency. VSync, buffering, variable refresh, scheduling and display scan-out affect presentation. Use P95 or P99 profiler measurements on target hardware.

Deadline1000 ÷ target FPS

Overlapped pathmax(CPU critical lane, GPU critical path) + presentation

Projected rate1000 ÷ projected frame time

Primary references: MDN frame timing ↗ Unreal performance profiling ↗

Six precision modules forming a sequential software measurement and delivery pipeline — ESTIMATEINSTRUMENTVALIDATEREVISIT

Measurement loop

Use the estimate.
Then challenge it.

01 / ESTIMATE: Start with explicit dimensions, workload volumes, unit prices and reserves.
02 / INSTRUMENT: Capture memory peaks, token usage, invoice categories and profiler timings.
03 / VALIDATE: Compare the planned result with representative production behavior.
04 / REVISIT: Update the budget when models, formats, traffic, content or hardware change.

Calculation method

Transparent enough
to be challenged.

These tools deliberately avoid hidden recommendations. Inputs, units, component formulas, reserves and known exclusions remain visible beside every result.

Binary memory units

Memory results use powers of 1024 and are labelled MiB or GiB. Decimal parameter counts remain powers of 1000.

Exact block arithmetic

Compressed texture levels round up to complete blocks, including the smallest mip levels.

Date-stamped rates

AI prices come from the same verified ledger as the Cost Atlas and link to the official source.

Critical paths

CPU lanes and GPU passes are treated as pipelines, not blindly added as one serial number.

Visible reserve

Headroom is a first-class input so a theoretical fit is not mistaken for an operational plan.

Measurement wins

A runtime profile, usage export, target-device capture or invoice overrides an early estimate.

Before trusting a result

Six questions for
the engineering review.

Is the workload representative?

Use real context, output length, concurrency, scenes, formats and target hardware.

Are the units consistent?

Separate decimal rates from binary memory and per-call values from per-task outcomes.

What is excluded?

Identify activation peaks, provider extras, driver allocation and presentation behavior.

Is the reserve enough?

Leave room for fragmentation, load spikes, failover, content growth and software change.

Is the source current?

Recheck model specifications, prices, formats and platform guidance before commitment.

What will verify it?

Name the profiler capture, usage export, load test or invoice that will close the loop.

Engineering beyond the estimate

Plan the budget.
Build the measured system.

ADOR.IS designs software, graphics and AI systems around measurable capacity, cost, fidelity, latency and operational constraints.

[email protected] ↗

Measure first.Provision with evidence.

Turn assumptionsinto a budget.

Plan the constraintbefore it plans you.