Price history
Recorded standalone sale prices and the latest available store price, in USD. Historical dots use the sale start date and its recorded offer price. Prices can change during a sale; this is not a daily price log. Bundle prices and upcoming offers are excluded. History covers up to the 100 most recent recorded offers.
Lowest recorded standalone price in this history: $74.50. The latest store price is $149.
View 4 recorded prices
| Sale start / price check | Price | Observation |
|---|---|---|
| $149 | Latest store price | |
| $149 | Unity First Price 2026-06-19 2026-06-26 | |
| $74.50 | Unity New Release Discount 2026-06-17 2026-07-01 | |
| $74.50 | Unity New Release Discount 2026-06-17 2026-07-01 |
Sale and bundle history
The 3 most recent recorded offers including this asset. Past offers may no longer be available. Bundle prices cover a package, not this asset alone.
About RevFramework: Currency & Economy
- Tools, Systems & Learning > Game Templates & Systems
- Tools, Systems & Learning > Learning & Tutorials
If something fails, it tells you why. That is the rule every RevFramework system is built around. Explicit APIs. Deterministic rounding. Real failure codes. No guesswork.
Money is the part of a game where "it silently did nothing" is least acceptable, so this is the package where that rule matters most.
RevFramework is for developers comfortable writing C# in Unity. It is not a no-code tool. There are no drop-in prefabs that "just work" and there is no inspector-only configuration path.
Two systems:
- Currency — ledger-based credit, debit and transfer with overflow-safe execution, balance caps and policies, escrow and holds with commit, release and TTL expiry, rollback-safe transaction staging, request-ID replay protection so a retried call cannot double-charge, exchange with rates, fees, limits and deterministic rounding, batched multi-operation blocks with structured audit logs, and awaiters for balance conditions
- Economy — shop services with all-or-nothing delivery and charge refund on failure, crafting cost integration with refund and restore, and reward distribution flows
Economy is built on Currency and requires it. Where Inventory is also present, Economy's item-store integration compiles in automatically; where it is not, that integration compiles out and Economy runs on currency alone.
Plus a save layer: a coordinator, a file store, participant ordering, and carry-over — so loading a save written by a build that had a system you have since removed does not discard that data permanently.
Not included: Inventory, Pickups, Crafting, Loot, Health and Status Effects. Those ship in their own packages, or all eight systems together in RevFramework Complete.
You are not buying a prefab kit. You are buying gameplay architecture.
Most Unity assets give you templates and hope the pieces fit together. RevFramework gives you systems and explanations. Every Currency and Economy operation returns a result object: a success flag, a machine-readable reason code, and an optional message. When a transaction does not go through, the system tells you exactly what happened.
That matters more here than anywhere else in the framework. A refused escrow refund keeps the money recoverable rather than destroying it. A reversal that cannot be applied reports rather than being swallowed. An affordability check that cannot read the wallet answers no, not yes. Reusing a request ID for a different amount is refused rather than reported as success.
If something fails, you know why. If a rollback occurs, you can trace it. If authority validation rejects a mutation, it is explicit. By design, not by luck.
Teachable Panels: Interactive panels built into the framework, already placed in the sample scenes. Press Play, read what the panel is teaching, toggle the edge cases, press the buttons, and watch live results — balances, caps, escrow states, batch outcomes, exchange rounding, failure reasons. When it makes sense, copy the service calls into your own UI and delete the panel.
Most are written as hostile consumers: restricted to the public API and nothing else. No internal namespaces, no reflection, no undocumented helpers, no sample-only utilities. That constraint is the point. If they compile and run, the public API is genuinely sufficient to build on.
They teach the framework and verify its API surface at the same time.
Documentation:
- Public MkDocs site, freely readable before you buy
- Each system has an Overview, Mental Model, Integration Surfaces, Public API, System Guarantees Matrix, Testing Philosophy, System Boundaries and FAQ
- Folder-level READMEs beside the source, explaining intent and reasoning rather than restating what the code says
- A guarantees matrix per system that lists what it does NOT promise as plainly as what it does
Where a page has been wrong, the correction says so instead of quietly replacing the text. Where a design costs you something, the documentation lists the cost.
Testing and Reliability:
RevFramework is built test-first. Across the whole framework, including these systems:
- EditMode 2519 tests 36 assemblies
- PlayMode 402 tests 19 assemblies
Both green, run on every push against a clean Unity project in CI. The counts are stated rather than summarised because a number you can check is worth more than an adjective.
Four kinds: Hostile Consumer tests that exercise the public API through supported surfaces only; Internal Truth tests that pin documented behaviour so a refactor cannot silently change it; PlayMode tests for Unity lifecycle; and Convention tests that stop a fixed bug class from quietly returning.
Test assemblies are not shipped — you get clean runtime, editor, sample and teaching assemblies with no NUnit dependency and no compile overhead. The suite is a free download for owners instead.
Modularity:
Modularity is enforced at the assembly level, not just by folders. Integration lives in optional, define-gated layers rather than hard references, and scripting symbols update automatically as systems are added or removed. Currency runs on its own; Economy is the layer above it.
No prefabs. No required singletons — every service is an instance you create, own and can substitute. No MonoBehaviour soup.
Multiplayer and Networking:
Stated plainly because it is the likeliest mistaken assumption. RevFramework is netcode-agnostic: it does not implement networking, replication, prediction or rollback.
Authority binders let you gate mutations through your own ownership and permission rules, using NGO, Mirror, Photon, Fusion, or something you wrote. For a server-authoritative economy that is the seam you want: the framework refuses a mutation your authority does not allow, and reports why.
We give you the rules; your netcode drives the simulation.
UI:
Reference UI is included — currency bars for both uGUI and UI Toolkit. It shows you how to talk to the systems correctly; it is not your game UI. Build your own with Canvas, UI Toolkit, or whatever fits.
What this is not:
- Not an IAP or payments integration.
- Not an inventory system.
- Not a quest system.
- Not a visual node editor.
- Not a drag-and-drop template.
- Not a locked UI workflow.
RevFramework gives you the foundations. You build the game.
Requirements:
- Unity 6.0 or later
- Built-in, URP and HDRP — runtime systems are render-pipeline agnostic
- Dimension-agnostic — no physics, controller or camera assumptions
- No third-party dependencies
- Full C# source included
Some sample scenes reference the Input System and Universal RP. Neither is a dependency of the framework, only of those scenes — and opening one without them names the objects and packages responsible rather than silently doing nothing.
Only the Runtime folder is required for a build. Documentation, Samples and Teaching are optional, and Pre-Build Clean archives them rather than deleting them.
The other packages:
- Inventory, Pickups & Crafting
- Health & Status Effects
- RevFramework Complete — all eight systems
All share the same architecture, documentation standard and testing philosophy.
Support:
Reach out before leaving a review. If it is broken, it gets fixed.
Every system. Every failure. If something fails, it tells you why. That is not a feature. It is the foundation everything else is built on.
Money is the part of a game where "it silently did nothing" is least acceptable, so this is the package where that rule matters most.
RevFramework is for developers comfortable writing C# in Unity. It is not a no-code tool. There are no drop-in prefabs that "just work" and there is no inspector-only configuration path.
Two systems:
- Currency — ledger-based credit, debit and transfer with overflow-safe execution, balance caps and policies, escrow and holds with commit, release and TTL expiry, rollback-safe transaction staging, request-ID replay protection so a retried call cannot double-charge, exchange with rates, fees, limits and deterministic rounding, batched multi-operation blocks with structured audit logs, and awaiters for balance conditions
- Economy — shop services with all-or-nothing delivery and charge refund on failure, crafting cost integration with refund and restore, and reward distribution flows
Economy is built on Currency and requires it. Where Inventory is also present, Economy's item-store integration compiles in automatically; where it is not, that integration compiles out and Economy runs on currency alone.
Plus a save layer: a coordinator, a file store, participant ordering, and carry-over — so loading a save written by a build that had a system you have since removed does not discard that data permanently.
Not included: Inventory, Pickups, Crafting, Loot, Health and Status Effects. Those ship in their own packages, or all eight systems together in RevFramework Complete.
You are not buying a prefab kit. You are buying gameplay architecture.
Most Unity assets give you templates and hope the pieces fit together. RevFramework gives you systems and explanations. Every Currency and Economy operation returns a result object: a success flag, a machine-readable reason code, and an optional message. When a transaction does not go through, the system tells you exactly what happened.
That matters more here than anywhere else in the framework. A refused escrow refund keeps the money recoverable rather than destroying it. A reversal that cannot be applied reports rather than being swallowed. An affordability check that cannot read the wallet answers no, not yes. Reusing a request ID for a different amount is refused rather than reported as success.
If something fails, you know why. If a rollback occurs, you can trace it. If authority validation rejects a mutation, it is explicit. By design, not by luck.
Teachable Panels: Interactive panels built into the framework, already placed in the sample scenes. Press Play, read what the panel is teaching, toggle the edge cases, press the buttons, and watch live results — balances, caps, escrow states, batch outcomes, exchange rounding, failure reasons. When it makes sense, copy the service calls into your own UI and delete the panel.
Most are written as hostile consumers: restricted to the public API and nothing else. No internal namespaces, no reflection, no undocumented helpers, no sample-only utilities. That constraint is the point. If they compile and run, the public API is genuinely sufficient to build on.
They teach the framework and verify its API surface at the same time.
Documentation:
- Public MkDocs site, freely readable before you buy
- Each system has an Overview, Mental Model, Integration Surfaces, Public API, System Guarantees Matrix, Testing Philosophy, System Boundaries and FAQ
- Folder-level READMEs beside the source, explaining intent and reasoning rather than restating what the code says
- A guarantees matrix per system that lists what it does NOT promise as plainly as what it does
Where a page has been wrong, the correction says so instead of quietly replacing the text. Where a design costs you something, the documentation lists the cost.
Testing and Reliability:
RevFramework is built test-first. Across the whole framework, including these systems:
- EditMode 2519 tests 36 assemblies
- PlayMode 402 tests 19 assemblies
Both green, run on every push against a clean Unity project in CI. The counts are stated rather than summarised because a number you can check is worth more than an adjective.
Four kinds: Hostile Consumer tests that exercise the public API through supported surfaces only; Internal Truth tests that pin documented behaviour so a refactor cannot silently change it; PlayMode tests for Unity lifecycle; and Convention tests that stop a fixed bug class from quietly returning.
Test assemblies are not shipped — you get clean runtime, editor, sample and teaching assemblies with no NUnit dependency and no compile overhead. The suite is a free download for owners instead.
Modularity:
Modularity is enforced at the assembly level, not just by folders. Integration lives in optional, define-gated layers rather than hard references, and scripting symbols update automatically as systems are added or removed. Currency runs on its own; Economy is the layer above it.
No prefabs. No required singletons — every service is an instance you create, own and can substitute. No MonoBehaviour soup.
Multiplayer and Networking:
Stated plainly because it is the likeliest mistaken assumption. RevFramework is netcode-agnostic: it does not implement networking, replication, prediction or rollback.
Authority binders let you gate mutations through your own ownership and permission rules, using NGO, Mirror, Photon, Fusion, or something you wrote. For a server-authoritative economy that is the seam you want: the framework refuses a mutation your authority does not allow, and reports why.
We give you the rules; your netcode drives the simulation.
UI:
Reference UI is included — currency bars for both uGUI and UI Toolkit. It shows you how to talk to the systems correctly; it is not your game UI. Build your own with Canvas, UI Toolkit, or whatever fits.
What this is not:
- Not an IAP or payments integration.
- Not an inventory system.
- Not a quest system.
- Not a visual node editor.
- Not a drag-and-drop template.
- Not a locked UI workflow.
RevFramework gives you the foundations. You build the game.
Requirements:
- Unity 6.0 or later
- Built-in, URP and HDRP — runtime systems are render-pipeline agnostic
- Dimension-agnostic — no physics, controller or camera assumptions
- No third-party dependencies
- Full C# source included
Some sample scenes reference the Input System and Universal RP. Neither is a dependency of the framework, only of those scenes — and opening one without them names the objects and packages responsible rather than silently doing nothing.
Only the Runtime folder is required for a build. Documentation, Samples and Teaching are optional, and Pre-Build Clean archives them rather than deleting them.
The other packages:
- Inventory, Pickups & Crafting
- Health & Status Effects
- RevFramework Complete — all eight systems
All share the same architecture, documentation standard and testing philosophy.
Support:
Reach out before leaving a review. If it is broken, it gets fixed.
Every system. Every failure. If something fails, it tells you why. That is not a feature. It is the foundation everything else is built on.