The current revision is undergoing manual validation. This page describes its capabilities and boundaries; screenshots will follow once the editor workflows have been checked.
From a calculation to your game’s systems.
Explore the areas that fit what you are building: an incremental economy, a readable interface, protected values or integration with native systems. Each section links to its usage guide.
- Blueprint arithmetic
A calculation graph with its inputs, result and error branch.
Capture pending manual validationKeep calculating beyond the range of a double.
Build and combine large values directly in Blueprint. Scientific notation keeps the mantissa and decimal exponent separate, so gameplay can keep growing without converting every result back to a float.
- Create, parse and normalize numbers; add, subtract, multiply and divide.
- Use powers, roots, logarithms, comparisons and array operations.
- Inspect success and error outputs before committing a result.
A wider range is not arbitrary precision. The mantissa uses double precision; Idle Mode controls whether negative values and nonzero fractions are allowed.
Explore numbers and errors - Resource production and purchases
A playable wallet beside the Blueprint that produces and spends resources.
Capture pending manual validationBuild an economy that can grow with your game.
Connect resource production, increasing prices and bulk purchases to your own gameplay. Use the returned values to decide what the player can buy and when to update their balance.
- Calculate production from a rate and elapsed time.
- Compute purchase costs and the maximum affordable quantity.
- Connect a wallet to your own UMG buttons and feedback.
Purchase formulas calculate values. Your game validates the action and commits the balance and ownership changes together.
Build a resource counter - Components in gameplay
An Actor component, its change event and a connected display.
Capture pending manual validationGive each value an owner.
Add a value component to an Actor and react when its value changes. Keep the graph that owns a resource separate from the widgets and systems that display it.
- Read and update a Normal component through its public operations.
- Use OnValueChanged to refresh a display when the value changes.
- Replicate Normal values with a replicated, relevant owning Actor.
The server must authorize gameplay changes. Safe components do not automatically replicate their protected state.
Understand components and replication - Safe and context-bound values
Initialization, a checked mutation and the visible response to a rejected operation.
Capture pending manual validationAuthenticate the value before you trust it.
Use Safe storage for values that need integrity checks in memory. Choose context-bound values when a protected number must belong to a particular gameplay context.
- Initialize protected values during the appropriate game lifecycle.
- Check authentication and operation success before consuming a value.
- Keep the previous value when a protected mutation is rejected.
Safe storage does not replace server authority or provide a complete anti-cheat system. In-memory handles are not portable save data.
Work with Safe values - Save and recover a balance
A save, a restarted session and the recovered value with a revision conflict example.
Capture pending manual validationCarry protected values across sessions.
Build a save and recovery flow around authenticated records, stable identities and explicit revisions. Your application owns the keys and storage policy.
- Bind a saved record to its owner, domain and slot.
- Handle revision conflicts instead of silently overwriting a newer record.
- Choose local portable storage or integrate a trusted server store.
Persistence requires native key management and session bootstrap. It is not a Blueprint-only setup; local storage cannot guarantee rollback protection against the machine owner.
Plan persistence and recovery - Custom number formatting
A formatter asset and the same values displayed with different notation.
Capture pending manual validationMake large values readable in your game.
Choose how players see a value without changing the number behind it. Author formatter assets for your notation and reuse them across your interface.
- Define suffixes and formatting rules for the scale of your economy.
- Preview output and check invalid or ambiguous rules.
- Register the assets your packaged game needs.
Display formatting can round a value. Keep the numeric value or the appropriate persistence record for storage.
Create a formatter - Materials and Niagara
The parameter graph beside the material or particle effect consuming it.
Capture pending manual validationConnect your numbers to what players see.
Pass a checked Packed representation to materials and Niagara. Use the mantissa and exponent as explicit inputs to effects that you design.
- Convert to Packed and handle conversion failure.
- Transport checked channels to a material vector parameter.
- Supply separate float and integer parameters to Niagara.
Packed trades precision and range for graphics transport. Keep authoritative balances in ordinary or Safe numbers, and validate the effect with a real renderer.
Connect materials and Niagara - Native batch calculations
A native consumer and its inspected batch outputs.
Capture pending manual validationBring batch calculations into your C++ systems.
Use the native batch API when your systems operate on collections of Scientific Numbers. Inspect the available capabilities on the hardware you intend to ship.
- Add batches and multiply them by a scalar.
- Compare values, normalize batches and reduce with sum, minimum or maximum.
- Handle output buffers and tail elements through the native API.
SIMD operations are a C++ interface. Performance depends on the operation, data, hardware and build; no universal speedup is promised.
Explore the native batch API - Numeric configuration in DataTables
A table update with matching and missing rows, followed by Undo.
Capture pending manual validationAuthor numeric configuration in the editor.
Use Scientific Number rows for the values you maintain as data: starting resources, prices or progression settings. Review CSV updates before saving the resulting asset.
- Validate input before modifying a table.
- Add missing rows or update matching rows according to the chosen mode.
- Use editor Undo and Redo, then explicitly save the asset.
Updating matching rows does not delete rows absent from the CSV. This is an authoring workflow; gameplay calculations do not require DataTables.
Review the CSV workflow - Optional AI integration
Registered tools and a concrete operation with its result in Unreal.
Capture pending manual validationLet an assistant work through the plugin’s tools.
The AI adapter is included in Scientific Number Tools. Connect a compatible client through Unreal’s Toolset Registry and Unreal MCP when you want an assistant to inspect or invoke exposed operations.
- Discover the available operations through the tool catalog.
- Work with supported numeric operations and formatter assets.
- Keep asset creation, configuration and saving explicit.
The core works without AI. AI workflows require the relevant Unreal integration plugins and a configured client, but no separate studio companion plugin or system Python installation.
Set up the AI integration
Frequently asked questions
What is Scientific Number Tools for?
Scientific Number Tools is an Unreal Engine plugin for large-number gameplay: Blueprint calculations, resource economies, value components, Safe storage, formatting and native integration.
Is it arbitrary-precision arithmetic?
No. A Scientific Number separates a double-precision mantissa from an int64 decimal exponent. This increases the representable range without providing unlimited precision.
Can I use it entirely in Blueprint?
Blueprint supports many everyday calculations, components and formatting operations. Portable Safe persistence requires native key management and session bootstrap, while the SIMD batch API is C++.
Does Safe make a multiplayer economy cheat-proof?
No. Safe values authenticate protected storage. Your game still needs server authority, purchase validation and an appropriate persistence policy.
Are Android and Linux supported?
The current source revision targets Unreal Engine 5.8 on Win64 and is undergoing manual validation. Android and Linux require compatibility work and separate build and runtime validation.
Is the AI integration a separate download?
No. The optional adapter is included in the plugin. Enable the relevant Unreal integrations and configure a compatible client if you want to use AI. The core works without an AI account.
Before integrating it into your project
- Unreal Engine
- 5.8
- Current platform
- Windows / Win64
- Access
- Blueprint + C++
- Documented revision
- 1.0.0
Android and Linux still require enablement and validation. Persistence needs native integration, and SIMD batches use C++. Check coverage before choosing your shipping platforms.
Read coverage and compatibility