What Is Simple Idle Forge?

Simple Idle Forge is a complete toolkit for building idle and incremental games in Unity. It gives you five interconnected wizard tools that handle everything — resources, generators, upgrades, prestige systems, and achievements — without writing a single line of code.

You design your game through guided, step-by-step wizards inside the Unity Editor. Pick a genre template that matches your game (Cookie Clicker, Factory Tycoon, Survival, RPG, Gacha, or Prestige-heavy), customize your entries, click Generate, and your game database is ready to use. The toolkit handles cost scaling formulas, offline progress calculations, number formatting, bonus stacking, prestige resets, and every other system that makes idle games tick.

Simple Idle Forge also ships with four complete, playable demo games that you can study, modify, or use as a starting point for your own project. Each demo was built entirely with the toolkit — the same wizards and JSON pipeline that you get access to.

No Code Required

Every feature in Simple Idle Forge is designed to work without writing C#. The five forge wizards walk you through building your game's data from start to finish:

If you do want to write code, every generated database comes with a clean runtime API. But the entire point is that you don't have to. The wizards, the JSON pipeline, and the demo games give you everything you need to ship an idle game.

The Five Forges

Each forge handles one pillar of your idle game. They link together automatically — your generator forge knows about your resources, your upgrade forge knows about your generators and resources, and so on up the chain.

What Makes It Different

Four Complete Games Included

Simple Idle Forge ships with four fully playable demo games, each built entirely with the toolkit. They aren't just tech demos — they're complete idle games with resources, generators, upgrades, multiple prestige layers, achievements, and polished UI. Each one demonstrates a different genre and teaches different features of the toolkit.

Every demo includes both its generated game databases and its JSON source data, so you can see exactly how the JSON-to-game pipeline works from start to finish. You can study them, modify them, or use them as a starting point for your own project.

The JSON Pipeline

Every forge can export its complete structure as a JSON file — definitions, entries, costs, prerequisites, milestones, rewards, and all custom properties. This JSON file serves as both a backup of your work and a template for bulk content generation.

The workflow is simple:

This pipeline is how the four demo games were created. Each demo's JSON source data is included in the package, so you can study the exact format and workflow that produced complete, playable idle games.

Runtime Features

Beyond the wizard tools, Simple Idle Forge includes a full set of runtime components that power your game's live systems. These are the engines running under the hood of every demo game.

Getting Started

The Forge Ecosystem

Simple Idle Forge is part of a family of no-code database generators for Unity. Each one handles a different domain, and they all work together through optional bridges that detect each other automatically — no setup, no configuration, no dependencies.

Install any companion package and its data automatically appears in your forge wizards. The RPG Idle demo showcases this integration — it detects which packages you have installed and enriches its UI accordingly. If you only own Simple Idle Forge, everything works perfectly standalone.

Requirements

Simple Idle Forge has exactly one requirement: Unity 2021.3 or later. That is the Long-Term Support release that most production projects target, and everything from 2021.3 through the latest Unity 6 tech stream is fully supported.

There are no external dependencies. No third-party plugins to install first. No custom render pipeline requirements. No paid add-ons that you need to buy separately before the toolkit works. Import the package, wait for Unity to compile, and you are ready to go.

Simple Idle Forge is a pure editor-and-runtime toolkit. It does not touch your rendering pipeline, your input system, your physics settings, or your project configuration. It sits alongside whatever you already have and generates game data that you wire into your own UI and game loop.

Import from Asset Store

The most common way to install Simple Idle Forge is through the Unity Asset Store. If you purchased it there, this is your path.

The package installs to Assets/Simple IDLE Forge/ inside your project. Everything the toolkit needs is inside that folder — runtime scripts, editor wizards, demo scenes, and this documentation.

Import via Package Manager (UPM)

If you received Simple Idle Forge as a UPM package (for example, through a Git URL or a local package reference), installation goes through Unity's Package Manager instead of the Asset Store import flow.

Option A — Git URL

Option B — manifest.json

You can also add the package directly to your project's Packages/manifest.json file. Open the file in a text editor and add this line to the "dependencies" block:

"com.livingfailure.simple-idle-forge": "1.0.0"

Save the file and return to Unity. The package resolves automatically on the next domain reload.

Verify Installation

After importing, verify that everything is working correctly. This takes about ten seconds.

Folder Structure

Understanding where things live helps you navigate the toolkit and know what each folder contains. Here is what you get after importing Simple Idle Forge:

Runtime

Contains all the game logic that ships with your built game. This is the code that runs on your players' devices — resource pools, generator managers, upgrade trackers, prestige managers, achievement trackers, the buff system, the offline progress calculator, number formatting, cost scaling formulas, bonus stacking, condition evaluation, and the snapshot system for save/load. None of this code depends on the Unity Editor, so it compiles cleanly for every build target.

Editor

Contains the five forge wizards and all their supporting tools — the setup steps, definition editors, builder panels, settings pages, code generators, genre templates, JSON schema export and import, cross-forge bridge detection, and the shared helpers that the wizards use internally. This code only runs inside the Unity Editor and is automatically excluded from your game builds.

Generated

This is where your databases go after you click Generate. Each forge creates three files — a type-safe enum, a database class, and a custom editor — plus one asset file containing your actual data. You can configure the output path in each forge's Settings step, but by default everything lands in a Generated folder organized by forge type. You will typically have one folder per database you create.

Documentation

The pages you are reading right now. Fourteen HTML files covering installation, a quick start tutorial, detailed guides for each forge, the JSON workflow, the runtime API reference, demo walkthroughs, troubleshooting, and the about page. All offline, all included in the package.

Scenes

The Hub scene and four complete demo games. The Hub is a launcher that lets you jump into any demo with a single click. Each demo has its own scene, its own generated databases, and its own runtime manager that wires everything together. The demos are fully playable idle games that you can study, modify, or use as starting points for your own projects.

Play the Demos First

Before you create anything, take five minutes to play the included demo games. This is the single most valuable thing you can do after installing the toolkit, because it shows you what Simple Idle Forge produces — not in theory, but as actual running games you can click through and explore.

Every one of these demos was built with the same five forge wizards and the same JSON pipeline that you have access to. There is no hidden code, no special editor magic, nothing that you cannot reproduce yourself. The demos exist so you can see the finish line before you start building.

Companion Packages

Simple Idle Forge works completely standalone. It has zero required dependencies. You can build a full idle game — resources, generators, upgrades, prestige, achievements, offline progress, and everything else — without installing anything else.

However, Simple Idle Forge is part of a family of no-code database generators called the Simple Forge Ecosystem. If you own other forges, Simple Idle Forge detects them automatically and enriches its wizard dropdowns with their data. No configuration, no setup steps, no toggling anything on. Install a companion package, and its codes and names appear in your forge wizards the next time Unity reloads.

How Detection Works

Simple Idle Forge uses two detection methods that work together seamlessly:

• UPM detection: The assembly definition files include versionDefines entries that set scripting define symbols (like SIMPLE_ATTRIBUTE_FORGE, SIMPLE_ITEM_FORGE, etc.) when companion packages are present in the Package Manager. This handles UPM-installed packages.
• Reflection detection: Bridge classes probe for companion types at runtime using safe reflection lookups. This handles Asset Store imports and manual installations where UPM version defines do not apply.

Between these two methods, every installation scenario is covered. It does not matter how you installed the companion package — Simple Idle Forge will find it.

Assembly Definitions

Simple Idle Forge uses two assembly definitions to keep runtime and editor code properly separated. This is standard Unity practice and ensures that editor-only code never ends up in your game builds.

Referencing Simple Idle Forge in Your Code

If your project uses assembly definitions (which most production projects do), you need to add a reference to the runtime assembly so your scripts can access the toolkit's types.

In your runtime .asmdef file, add SimpleIdleForge.Runtime to the references list:

{
  "name": "MyGame.Runtime",
  "references": [
    "SimpleIdleForge.Runtime"
  ]
}

For editor scripts that need access to forge wizard types (which is uncommon — you typically only need the runtime types), reference both assemblies:

{
  "name": "MyGame.Editor",
  "references": [
    "SimpleIdleForge.Runtime",
    "SimpleIdleForge.Editor"
  ]
}

No Assembly Definitions in Your Project?

If your project does not use assembly definitions at all (everything compiles into Assembly-CSharp), you do not need to do anything. Unity automatically resolves references to packaged assemblies, and you can use using SimpleIdleForge; in any script without additional setup.

Before You Start

This tutorial assumes you have already imported Simple Idle Forge into your Unity project. If you have not done that yet, head to the Installation page first — it takes about a minute.

By the end of this tutorial, you will have created:

• 3 resources — Gold, Gems, and Prestige Points
• 2 generators — a Mine that produces Gold and a Jeweler that produces Gems
• 2 upgrades — a production multiplier and an automation trigger
• 1 prestige layer — a Rebirth cycle that resets progress and awards permanent bonuses
• 3 achievements — milestone goals with resource and multiplier rewards

That is a complete idle game loop: earn resources, buy producers, upgrade them, hit a wall, prestige for permanent bonuses, and chase achievements along the way. Every idle game ever made — from Cookie Clicker to Adventure Capitalist to Melvor Idle — is a variation on this exact loop.

Let's build one.

Step 1: Create Your Resources

Every idle game starts with resources. Gold to spend, gems to hoard, prestige points to earn on reset. The Resource Forge is where you define every currency and material in your game.

Open the Resource Forge

Go to Window → Living Failure → Simple Idle Forge → Resource Forge. The wizard opens to Step 1: Setup.

Step 1 of 5: Setup

Click Next to move to Step 2.

Step 2 of 5: Definitions

The Classic Incremental template has already filled in your property definitions — categories for resource types, flags for visibility and premium status, numerics for display order, and text fields for short names and descriptions. For this tutorial, you do not need to change anything here. The defaults work perfectly for our three resources.

Click Next to move to Step 3.

Step 3 of 5: Build Your Resources

This is where you create the actual resource entries. The builder is a split-panel interface — the list of entries on the left, the detail editor on the right.

Click Next to move to Step 4.

Step 4 of 5: Settings

This step lets you choose where the generated files will be saved. The defaults work fine — the wizard previews every file it will create, so you can see exactly what is going where. For this tutorial, keep the defaults and click Next.

Step 5 of 5: Generate

Review the summary. You should see 3 resources listed. Click Generate.

The toolkit generates your enum, database, and editor files (Phase 1), Unity recompiles, and then the toolkit automatically creates your data asset and populates it with all three resources (Phase 2). The log panel shows each step as it happens.

Your resource database is now generated and ready to use. You can find the .asset file in your project and inspect it — the custom editor shows all three resources in a searchable, filterable split-panel view.

Step 2: Create Your Generators

Generators are the buildings, workers, and producers that generate resources over time. A mine that produces gold every second. A jeweler that turns gold into gems. A factory that manufactures goods. This is the engine that makes your idle game run while the player is away.

Open the Generator Forge

Go to Window → Living Failure → Simple Idle Forge → Generator Forge.

Step 1 of 5: Setup

Click Next to Step 2 (Definitions), keep the template defaults, and click Next again to reach Step 3 (Builder).

Step 3 of 5: Build Your Generators

Click Next through Step 4 (Settings) keeping the defaults, then click Generate on Step 5. Wait for the two-phase generation to complete.

Step 3: Create Your Upgrades

Upgrades are one-time or repeatable purchases that make the player's existing generators more powerful. Double your Mine output. Automate your Jeweler. Grant a flat bonus to all production. Upgrades are what turn a simple clicker into a game with real decisions — do you save up for the big multiplier or buy more generators now?

Open the Upgrade Forge

Go to Window → Living Failure → Simple Idle Forge → Upgrade Forge.

Step 1 of 5: Setup

Click Next through Step 2 (Definitions) keeping the template defaults, then Next to Step 3 (Builder).

Step 3 of 5: Build Your Upgrades

Click Next through Step 4 (Settings) and Generate on Step 5.

Step 4: Create Your Prestige Layer

Prestige is what gives an idle game its long-term hook. The player reaches a point where progress slows to a crawl, and the game offers a deal: reset everything you have built, but earn permanent bonuses that make the next run faster. The further you pushed before resetting, the bigger the bonus. This creates a "one more run" loop that keeps players engaged for weeks and months.

Open the Prestige Forge

Go to Window → Living Failure → Simple Idle Forge → Prestige Forge.

Step 1 of 5: Setup

Click Next through Step 2 (Definitions) and into Step 3 (Builder).

Step 3 of 5: Build Your Prestige Layer

Click Next through Step 4 (Settings) and Generate on Step 5.

Step 5: Create Your Achievements

Achievements are the milestones that give players direction. They answer the question "what should I do next?" — earn 1,000 Gold, reach Mine level 50, prestige for the first time. Each one has a condition to check and a reward to grant when completed. They keep players motivated through the slow parts of the game and celebrate their progress through the fast parts.

Open the Achievement Forge

Go to Window → Living Failure → Simple Idle Forge → Achievement Forge.

Step 1 of 5: Setup

Click Next through Step 2 (Definitions) and into Step 3 (Builder).

Step 3 of 5: Build Your Achievements

Click Next through Step 4 (Settings) and Generate on Step 5.

What You Just Built

Take a step back and look at what you have created in roughly ten minutes, without writing a single line of code:

This is a complete idle game loop. A player starts with nothing, clicks to earn Gold, buys Mines to automate Gold production, unlocks the Jeweler at Mine level 5, purchases upgrades to boost output, earns achievements along the way, hits a wall around the 1M Gold mark, prestiges to earn permanent bonuses, and starts the cycle again with a stronger foundation. Every run goes faster. Every prestige makes the next run more rewarding.

And you built the entire data layer for it without touching a code editor.

What's Next

You have the foundation. Here is where to go from here to turn this proof-of-concept into a real game:

What Are Resources?

Resources are the foundation of every idle game. They are the currencies, materials, energies, and prestige points that your players earn, spend, and track throughout their entire playthrough. Every other system in your game — generators, upgrades, prestige layers, achievements — ultimately revolves around resources. Generators produce them. Upgrades cost them. Prestige resets them. Achievements check them. Without resources, there is no game.

A resource can be anything your design needs:

• Currencies — Gold, Gems, Cash, Coins. The things players earn and spend to buy generators, upgrades, and unlocks.
• Materials — Wood, Iron, Steel, Circuits. Raw and processed goods in crafting and factory games.
• Energy — Stamina, Mana, Fuel, Power. Limited pools that gate actions and regenerate over time.
• Prestige Currencies — Souls, Tokens, Shards, Stars. Earned through prestige resets, spent on permanent bonuses.
• Vital Resources — Food, Water, Warmth, Health. Resources that drain over time and must be maintained to survive.
• Tracking Resources — Population, Morale, Reputation. Counters that gate progress or unlock new content.

Here are real examples from the four demo games included with Simple Idle Forge:

The Resource Forge is always the first forge you use. Every other forge in the toolkit reads resource codes from your resource databases — it is the foundation that everything else builds on. Take your time here. Get your resources right, and the rest of your game flows naturally.

Opening the Resource Forge

Open the Resource Forge wizard from the Unity menu bar:

Window → Living Failure → Simple Idle Forge → Resource Forge

The wizard opens as a dockable editor window. You can dock it alongside your Scene, Inspector, or any other panel. The Resource Forge walks you through five steps, displayed as tabs along the top of the window:

1. Setup — Name your database and pick a genre template
2. Definitions — Define the custom properties that every resource will have
3. Builder — Create and edit individual resource entries
4. Settings — Choose where your generated files will be saved
5. Generate — Review everything and create your database

You move between steps using the tab bar at the top. Each step validates your data before letting you proceed to the next one, so you always know if something needs attention.

Step 1: Setup

The Setup step is where you give your resource database its identity. Three fields control what your generated files will be named:

As you type, the wizard shows a Generated Names Preview below the fields. This shows you the exact file names that will be created — the enum file, the database file, and the editor file — so you always know what to expect before you generate anything.

Genre Templates

Below the naming fields, you will find a row of template buttons. Templates pre-fill Step 2 (Definitions) with property schemas that are standard for a particular genre of idle game. They give you a running start instead of building everything from scratch.

Selecting a template replaces any existing property definitions with the template's defaults. A confirmation dialog appears before anything is overwritten, so you cannot lose work by accident. You can always modify the template's definitions after applying them — they are a starting point, not a constraint.

Simple Idle Forge includes six genre templates:

Step 2: Definitions

The Definitions step is where you design the custom properties that will appear on every resource in your database. Think of it as designing a form — every resource entry in Step 3 will have the exact same set of fields that you define here.

If you selected a genre template in Step 1, this step is already filled in with sensible defaults. You can use them as-is, modify them, add more, or remove ones you do not need.

There are four types of properties:

Categories

A category is a dropdown selector — a named field with a list of possible values. Each resource picks exactly one value from the list.

Example: A "Resource Type" category with entries Currency, Premium, Prestige, Material. When you create a resource in Step 3, you pick one of those four types from a dropdown. At runtime, you can filter all resources by type: "give me all Premium resources" or "give me all Prestige resources".

Categories are managed through a reorderable list. Click the + button to add a new category. Each category has a foldout that expands to show its name and its nested list of entries. You can add, remove, and reorder entries within each category. There is also a default value selector that controls which entry is selected by default when you create a new resource.

Flags

A flag is a simple on/off toggle — a boolean that is either true or false.

Example: An "Is Premium" flag. When checked, the resource is considered premium currency (gems, diamonds, crystals). An "Persists Through Prestige" flag. When checked, this resource is not reset when the player prestiges. At runtime, you can query: "give me all resources where Is Premium is true".

Each flag has a name and a default value (on or off). When you create a new resource in Step 3, the flag starts at its default value and you can toggle it per entry.

Numerics

A numeric is a number field — either an integer or a floating-point value, with optional minimum and maximum constraints.

Example: A "Display Order" numeric (integer, min 0, max 999) that controls the sort order of resources in your UI. A "Decay Rate" numeric (float, min 0) that defines how many units per second this resource loses naturally. At runtime, you can read these values and use them however your game logic needs.

Each numeric definition has five fields, each displayed on its own row in the wizard: Name, Is Integer (toggle), Min Constraint, Max Constraint, and Default Value. If you do not need min/max constraints, leave them at their defaults and the value will be unconstrained.

Texts

A text is a free-form string field. It can be a single line or a multi-line text area.

Example: A "Short Name" text for abbreviated display (Gold → "Au", Diamonds → "Dia"). A "Flavor Text" text with 3 lines for lore descriptions that appear in tooltips. At runtime, you read these as plain strings.

Each text definition has a Name and a Line Count. A line count of 1 creates a single-line text field in Step 3. A line count greater than 1 creates a multi-line text area with that many visible lines.

JSON Schema Export and Import

At the bottom of the Definitions step, you will find the JSON Schema section. This lets you export your complete property schema (and optionally your existing entries) as a structured JSON file. You can then edit the JSON externally, add dozens of entries at once, and import them back into the wizard. See the JSON Workflow page for the full walkthrough of this pipeline.

Step 3: Builder

The Builder is where you actually create your resources. It uses a split-panel layout with a 280-pixel entry list on the left and a detail editor on the right.

Left Panel: Entry List

The left panel is your resource inventory. It shows every resource in your database as a scrollable, selectable list. Click a resource to select it and edit it in the right panel.

The list panel includes:

• Search bar — Filter resources by name or code. Type "gold" to find any resource with "gold" in its name or code.
• Category filter — If you have a "Resource Type" category defined, a dropdown appears that lets you filter the list to show only Currency resources, only Premium resources, etc.
• Sort options — Sort alphabetically by name, by code, or by category.
• Pagination — For large databases, resources are paginated so the list stays fast and manageable.
• Bulk operations — Select multiple resources with checkboxes, then delete or duplicate them all at once.
• Count display — Shows the total number of resources in your database.
• Category indicator — Each entry shows its primary category in brackets (e.g., [Currency], [Premium]) so you can scan the list at a glance.
• Status bar — Shows the current filter state and entry count.

Use the + button at the bottom to add a new resource. Use the - button to remove the selected resource. The Duplicate button creates a copy of the selected resource with a new code.

Right Panel: Entry Editor

When you select a resource in the left panel, the right panel shows its complete editor. The editor is organized into foldout sections:

Identity

The core identity of the resource:

• Code — The unique identifier for this resource, in SCREAMING_SNAKE_CASE. This is what other forges reference when they need to specify a resource. Examples: GOLD, PREMIUM_GEMS, PRESTIGE_SOULS. Codes must be unique across all resources in this database.
• Display Name — The human-readable name shown to players. "Gold", "Premium Gems", "Prestige Souls".
• Description — A text description, typically shown in tooltips or info panels.
• Icon — A Sprite reference for the resource's icon in your UI.

Resource Settings

The gameplay configuration for this resource:

• Starting Amount — How much of this resource the player starts with. This is a double value, so it can handle numbers from 0 all the way up to 1.7×10³⁰⁸. Most resources start at 0, but you might start the player with some gold or food.
• Max Cap — The maximum amount the player can hold. Set to 0 for no cap (unlimited growth). This is also a double. When the player reaches the cap, the behavior depends on the Cap Mode setting below.
• Cap Mode — What happens to production as the resource approaches its cap. Five modes are available, each explained in detail in the Cap Modes section below.
• Display Format — How numbers are formatted when shown to the player. Four formats are available, explained in the Display Formats section below. The wizard shows a live preview of how a sample number looks in your chosen format.
• Display Precision — The number of decimal places shown. A precision of 1 shows "1.5K", a precision of 2 shows "1.50K", and so on. Adjustable via a slider.
• Display Color — A color picker for this resource's UI color. Use consistent colors to help players instantly recognize resource types — gold for currency, purple for premium, green for materials, red for health.

Dynamic Properties

Below the resource settings, you will see foldout sections for each property type you defined in Step 2: Categories, Flags, Numerics, and Texts. Each resource gets its own values for every property. For example, if you defined a "Resource Type" category, each resource gets a dropdown where you pick whether it is Currency, Premium, Prestige, or Material.

Cap Modes Explained

When a resource has a max cap (any value greater than 0), the Cap Mode controls what happens to production as the resource fills up. This is a game design lever — different cap modes create different player experiences.

None

The resource has no cap behavior at all. Even if you set a Max Cap value, the None mode ignores it and lets the resource grow without limit. Production always runs at 100% efficiency. Use this when you want to track a max cap for display purposes (e.g., "500/1000 energy") but do not want it to actually limit production.

Hard

The most common mode. Production runs at full speed until the resource hits its cap, then stops completely. If the player has 999/1000 gold and production is 50/sec, they get exactly 1 gold and then production halts at 1000. Simple, predictable, and familiar to players from every mobile game with stamina bars.

Flat

Production runs at full speed until the resource reaches a threshold percentage, then drops to a flat efficiency for the remainder. When the resource actually hits the cap, production stops entirely.

You configure two values:

• Threshold — The fill percentage where the slowdown kicks in (0.0 to 1.0). Default is 0.8 (80% full).
• Efficiency — The production rate after the threshold (0.0 to 1.0). Default is 0.5 (50% production speed).

Example: Cap is 1000, threshold is 0.8, efficiency is 0.5. The resource produces at full speed until 800, then at half speed from 800 to 1000. This creates a gradual "full feeling" instead of an abrupt wall. Players notice production slowing down and are motivated to spend before hitting the hard limit.

Curve

Production efficiency follows a smooth animation curve based on how full the resource is. The X axis represents fill ratio (0.0 = empty, 1.0 = full) and the Y axis represents production efficiency (0.0 = no production, 1.0 = full production).

The wizard provides a curve editor where you can draw any shape you want. The default curve is a straight line from 100% efficiency at empty to 0% efficiency at full — a perfectly smooth linear ramp-down. But you can create concave curves (fast drop-off near cap), convex curves (slow drop-off until the very end), S-curves, or anything else.

Use this when you want precise control over the production feel. Curve mode is especially useful for vital resources in survival games where you want the "pressure" of a filling resource to ramp up gradually.

Step

Production efficiency changes at specific breakpoints that you define. Each breakpoint has a fill threshold and an efficiency value. The wizard shows these as a reorderable list of threshold/efficiency pairs.

Example:

Step mode is the clearest to communicate to players. You can show the breakpoints directly in your UI: "Production slows at 50%, 80%, and 95% capacity." Players know exactly what to expect and can plan their spending around the thresholds. The Survival Idle demo uses Step mode for its vital resources.

Display Formats

Every idle game needs to turn enormous numbers into readable text. Simple Idle Forge includes a built-in number formatter with four display modes. You choose a format per resource, and the formatter handles everything automatically at runtime.

Short (Suffix Notation)

The most common format for idle games. Large numbers are abbreviated with letter suffixes:

1,500       →  1.5K
1,500,000   →  1.5M
1,500,000,000  →  1.5B
1.5 trillion   →  1.5T
1.5 quadrillion  →  1.5Qa
1.5 quintillion  →  1.5Qi

The formatter supports 57 suffix tiers, covering every value up to 10¹⁷¹. Beyond that, it falls back to scientific notation. For most games, K through Qi covers everything your players will ever see.

The wizard shows a live preview of your chosen format and precision. As you adjust the display precision slider, you can see exactly how "1,234,567" renders as "1.2M" (precision 1) or "1.23M" (precision 2).

Scientific

Standard scientific notation, familiar to players of Antimatter Dimensions and other math-heavy incrementals:

1,500       →  1.50e3
1,500,000   →  1.50e6
1.5 trillion   →  1.50e12

Engineering

Like scientific notation but with a superscript exponent for a cleaner look:

1,500       →  1.50×10³
1,500,000   →  1.50×10&sup6;
1.5 trillion   →  1.50×10¹²

Full

The complete number with comma separators:

1500        →  1,500
1500000     →  1,500,000
1500000000  →  1,500,000,000

Full format works well for small numbers and for resources where the exact count matters (population, units owned). It becomes unwieldy for large numbers, so it is best suited for resources that stay in the thousands or below.

Step 4: Settings

The Settings step controls where your generated files are saved. By default, the wizard saves everything to a single output folder. You can also enable custom paths to save scripts and assets to separate locations.

• Output Path — The default folder for all generated files. Typically something like Assets/GeneratedDatabases/Resources/. Click Browse to pick a folder visually.
• Use Custom Paths — When enabled, two additional path fields appear: one for scripts (.cs files) and one for assets (.asset files). This is useful if your project has a specific folder structure where scripts and data live in different directories.

Below the path fields, the wizard shows a File Preview listing every file that will be created when you generate. You can see the exact file names and paths before committing to anything. This includes:

• {Prefix}Type.cs — The enum file with one entry per resource
• {Prefix}Database.cs — The database file with all your resource data
• {Prefix}DatabaseEditor.cs — The custom editor for browsing your database in the Inspector
• {Prefix}Database.asset — The actual data asset

A descriptive summary box at the bottom shows a quick overview of your database: how many resources you have, how many property definitions of each type, and the total file count.

Step 5: Generate

The Generate step is the final review before creating your database. The wizard shows a complete summary of everything that will be generated: file names, entry count, property counts, and output paths. Review this carefully, then click the Generate button.

Generation happens in two phases:

A scrollable log at the bottom of the step shows the progress of both phases. When generation is complete, you will see a success message along with post-generation actions:

• Select in Project — Highlights the generated asset in the Project window
• Open in Inspector — Opens the asset in the Inspector with the custom editor (split-panel with search, filtering, and pagination)

What Gets Generated

After both phases complete, you have a complete, ready-to-use resource database:

• A type-safe enum with one entry per resource (GOLD, GEMS, PRESTIGE_SOULS, etc.). Use this in your game code for safe, typo-proof resource references.
• A database asset that implements the IIdleResourceDataSource interface. This gives you full query access: get a resource by code, by enum value, by category, by flag, by numeric range, or by text match. The database contains static metadata arrays for property names and entries, so you can build dynamic UIs without hard-coding anything.
• A custom editor that displays your database in the Inspector with a split-panel layout, search bar, category filtering, and pagination. You can browse and verify your data without opening the wizard.

Tips for Resource Design

Building the right set of resources is the most important design decision in your idle game. Here is practical advice drawn from hundreds of successful idle games and the four demo games included with Simple Idle Forge.

Start Small, Expand Later

Begin with 3 to 5 core resources. A primary currency (Gold), a secondary currency or material (Wood), and maybe a premium currency (Gems). You can always add more resources later as you add generators and content tiers. The Simple Kingdom demo started with just Gold and Food, then expanded to 7 resources as generators and prestige layers were added.

Use Caps Sparingly

Most idle games let numbers grow freely — that is the entire appeal of the genre. Use caps only where they serve a specific design purpose: energy systems that gate actions (100 Stamina, regenerates over time), storage limits in factory games (warehouse holds 10,000 ore), or vital resources in survival games (100 Food max until you build a granary). If you are not sure whether a resource needs a cap, leave it at 0 (unlimited) and add one later if the economy feels too loose.

Use Display Colors Consistently

Pick a color language and stick with it across your entire game:

• Yellow/Gold for primary currencies
• Purple/Violet for premium currencies
• Blue for prestige currencies
• Green for materials and organic resources
• Red for health, danger, or vital resources
• Orange for energy and stamina
• White/Silver for secondary or neutral resources

When players see a purple number, they should instantly know it is premium currency. Consistent colors reduce cognitive load and make your UI feel polished.

Prestige Resources Deserve Their Own Category

If your game has prestige systems, give prestige currencies their own category (or at least flag them with an "Is Prestige" flag). This makes it trivial to filter them in your UI, exclude them from certain displays, and handle them differently during prestige resets. The Generator and Upgrade forges let you filter by category, so having a clean "Prestige" category means you can instantly see "which generators produce prestige currencies" or "which upgrades cost prestige currencies".

Plan for Number Scale

Idle games are defined by their number scale. A typical Cookie Clicker clone goes from 1 to 10¹⁵ in a single prestige cycle. Simple Idle Forge uses double for all game values, which handles up to 1.7×10³⁰⁸ — far beyond what any player will reach. But you should still think about your progression curve: what numbers will the player see in the first minute? The first hour? After their first prestige? Pick display formats that match your scale. Short (suffix) notation is almost always the right choice for the primary currency.

Name Codes Clearly

Resource codes appear throughout every other forge — in generator production entries, upgrade costs, prestige formulas, achievement conditions. Use clear, descriptive codes that you will recognize months later. GOLD is better than G. PRESTIGE_SOULS is better than PS. Codes are in SCREAMING_SNAKE_CASE by convention. The extra characters cost nothing and save enormous confusion.

What Are Generators?

Generators are the engine of every idle game. They are the buildings, workers, factories, mines, farms, heroes, and machines that produce resources automatically over time. When you buy a generator, it starts producing — and it keeps producing whether the player is watching or not. That is the core promise of the idle genre: progress happens even when you are not playing.

Every idle game you have played is built on generators. Cookie Clicker calls them Grandmas and Farms. Adventure Capitalist calls them Lemonade Stands and Pizza Deliveries. Realm Grinder calls them Farms and Inns. The names change but the mechanic is universal: spend resources to buy a generator, it produces resources over time, you use those resources to buy more generators.

Here are real examples from the four demo games included with Simple Idle Forge:

The Generator Forge is the most feature-rich forge in Simple Idle Forge. It handles multi-resource production, multi-resource costs with five scaling formulas, two production modes (continuous and timer), prerequisites for unlock chains, milestones that grant bonuses at specific levels, and a two-level property system. This page walks through every feature in detail.

Opening the Generator Forge

Open the Generator Forge wizard from the Unity menu bar:

Window → Living Failure → Simple Idle Forge → Generator Forge

The wizard opens as a dockable editor window, just like the Resource Forge. The five steps are the same pattern: Setup, Definitions, Builder, Settings, Generate. But the Generator Forge has more to configure at every step because generators are the most complex data structure in the toolkit.

Linking Resource Databases

Before you can build generators, the Generator Forge needs to know what resources exist in your game. This is handled by linking resource databases in Step 1.

In the Setup step, below the naming fields and template selector, you will see a Linked Resource Databases section. This is a reorderable list where you drag and drop your generated resource database assets. Once linked, every resource code from those databases becomes available as a dropdown option throughout the Generator Forge — in production entries, cost entries, and prerequisite conditions.

You can link multiple resource databases. If your game uses separate databases for different resource categories (one for currencies, one for materials, one for prestige currencies), link all of them. The forge merges their resource codes into a single combined list, with duplicate detection to catch overlaps.

Each linked database shows its resource count next to its name, so you can verify at a glance that the right databases are connected. The forge validates that each linked asset actually implements the resource data interface — if you accidentally drag in something that is not a resource database, it tells you.

Step 1: Setup

The Setup step works just like the Resource Forge: name your database, optionally set a namespace and class prefix, and pick a genre template. But the Generator Forge has two additional features that the Resource Forge does not.

Naming

The Generated Names Preview shows you the enum file, database file, and editor file names as you type, just like the Resource Forge.

Genre Templates

The same six genre templates are available, but they populate different properties for generators. Each template fills in both generator-level and milestone-level property definitions appropriate for that genre:

Two-Level Properties

Here is the single biggest difference between the Generator Forge and every other forge: two-level properties. Most forges define one set of properties that applies to each entry. The Generator Forge defines properties at two independent levels:

• Generator-Level Properties — Apply to the generator as a whole. Things like Building Type, Era, Power Cost, Is Automated. These describe the generator itself.
• Milestone-Level Properties — Apply to each individual milestone within a generator. Things like Milestone Tier, Reward Description, Bonus Icon. These describe specific level thresholds within the generator.

This means a generator and its milestones can have completely different sets of properties. A generator might have a "Zone Type" category (Combat, Gathering, Crafting), while its milestones have a "Reward Type" category (Production Boost, Unlock, Cosmetic). The two levels are defined independently in Step 2 and populated independently in Step 3.

Step 2: Definitions

The Definitions step for generators has two clearly labeled sections: "Generator-Level Properties" at the top and "Milestone-Level Properties" below it. Each section has the same four property types as every other forge:

• Categories — Dropdown selections (e.g., "Building Type" with entries Production, Utility, Prestige)
• Flags — Boolean toggles (e.g., "Is Automated", "Is Boss Zone")
• Numerics — Number fields (e.g., "Power Cost", "Stamina Drain")
• Texts — String fields (e.g., "Flavor Text", "Unlock Message")

You define each level's properties independently. Generator-level properties appear on the generator in Step 3. Milestone-level properties appear on each milestone within that generator. They do not need to match — you can have three categories at the generator level and one at the milestone level, or numerics at one level and none at the other.

If you selected a genre template in Step 1, both sections are already populated with sensible defaults. You can modify, add, or remove definitions freely. When you change definitions, the wizard automatically syncs all existing generator entries and their milestones to match the new schema.

JSON Schema Export and Import

Like the Resource Forge, the bottom of the Definitions step has a JSON Schema section for exporting and importing generator data. The Generator Forge's JSON schema includes both property levels, all production and cost entries, prerequisites, and milestones with their own properties. See the JSON Workflow page for details.

Step 3: Builder

The Builder step is the heart of the Generator Forge. This is where you create, configure, and fine-tune every generator in your game. It uses the same split-panel layout as the Resource Forge: a 280-pixel entry list on the left and a detail editor on the right.

Left Panel: Entry List

The left panel works identically to the Resource Forge's list panel: search bar, category filter, sort options, pagination, bulk select/delete/duplicate, count display, and category indicators on each entry. Click a generator to select it and edit it in the right panel.

Right Panel: Entry Editor

The right panel is where generators get interesting. Each generator has substantially more configuration than a resource. The editor is organized into foldout sections:

Identity

Same as resources: Code (SCREAMING_SNAKE_CASE), Display Name, Description, and Icon (Sprite). Generator codes must be unique across all generators in this database.

Examples: PEASANT_HUT, STEEL_FOUNDRY, GRAVEYARD_PATROL, FORAGER.

Production

The production section defines what resources this generator produces and how much. It is a reorderable list where each entry has two fields:

• Resource Code — A dropdown populated from your linked resource databases. Pick which resource this generator produces.
• Base Amount Per Second — How much of that resource one level of this generator produces per second. This is the base rate before any bonuses, multipliers, or milestones.

A generator can produce multiple resources. The Steel Foundry might produce both STEEL and a small amount of CASH. The Dragon Nest might produce SOULS, TITANITE, and EMBER simultaneously. Add as many production entries as you need.

The total production at any given time is: baseAmountPerSecond × generatorLevel × allBonuses. Bonuses come from upgrades, milestones, prestige layers, achievements, and temporary buffs — all resolved automatically through the bonus stacking pipeline.

Production Mode

Below the production list, you choose the production mode for this generator. This is one of the most impactful design decisions you will make. See the dedicated Timer vs Continuous Production section below for a thorough explanation, but here is the quick version:

• Continuous — Resources flow every frame at a smooth rate. The player sees numbers ticking up constantly. This is what Cookie Clicker uses.
• Timer — Resources arrive in batches every N seconds. The player sees a progress bar fill up, then all the resources arrive at once when the timer completes. This is what Adventure Capitalist uses.

When you select Timer mode, an additional field appears:

• Production Interval — How many seconds between each batch. The wizard provides quick presets: Fast (5s), Medium (15s), Slow (30s), Very Slow (60s). You can also type any custom value.

Costs

The cost section defines what the player spends to buy one level of this generator. Like production, it is a reorderable list where each entry has four fields:

• Resource Code — Dropdown from your linked resource databases. Which resource does this generator cost?
• Base Cost — The cost to buy the first level. This is a double, so it can be anything from 10 to 10¹⁰⁰.
• Scaling Type — How the cost increases per level. Five formulas available, each explained in detail in the Understanding Cost Scaling section below.
• Scaling Factor — The numeric parameter for the scaling formula. For Exponential scaling, this is the multiplier per level (1.15 is the industry standard). For Polynomial, this is the exponent. For Linear, this is the flat increase per level.

A generator can cost multiple resources. The Steel Foundry might cost both CASH and ORE. The Dragon Nest might cost SOULS and BLOOD_ECHOES. When the player buys a level, all costs are deducted atomically — either all resources are spent or none are. No partial transactions.

Scaling Presets

Each cost entry shows a row of quick preset buttons that fill in common scaling configurations with a single click:

Formula Display and Cost Preview

Below the scaling presets, each cost entry shows a formula display in an info box that describes the exact mathematical formula being used. For example: cost(n) = 100 × 1.15^n. This updates live as you change the scaling type and factor.

Below the formula, an interactive cost preview slider lets you drag from level 1 to level 200 and see two numbers update in real time:

• Cost at Level N — What it costs to buy level N
• Total to Level N — The cumulative cost of all levels from 1 to N

This preview is invaluable for tuning your economy. You can see immediately whether a generator becomes prohibitively expensive too early, or stays too cheap for too long. Drag the slider to level 50 and check: does this cost feel right for mid-game? Drag to level 100: is late-game still achievable? The preview uses the exact same formulas that the runtime will use, so what you see is what your players will experience.

Max Level

An optional cap on how high this generator can be leveled. Set to 0 for unlimited levels. Most idle games leave generators uncapped, but some designs benefit from level limits — particularly when milestones grant powerful bonuses at specific thresholds and you want to prevent infinite scaling.

Prerequisites

Prerequisites are conditions that must be met before this generator becomes available to the player. Until all prerequisites are satisfied, the generator is locked. This is how you create progression chains — the second generator unlocks after the first reaches level 5, the third unlocks after you have 1,000 gold, and so on.

Each prerequisite is a condition with four parts:

• Condition Type — What kind of thing to check:
  • ResourceAmount — The player has at least N of a resource
  • GeneratorLevel — Another generator is at least level N
  • UpgradePurchased — A specific upgrade has been bought
  • PrestigeCount — The player has prestiged N times with a specific layer
  • MilestoneCompleted — A specific achievement or milestone has been earned
• Target Code — A context-aware dropdown. If the condition type is ResourceAmount, this shows resource codes from your linked databases. If it is GeneratorLevel, it shows other generator codes from this wizard (with self-reference validation — the forge warns you if a generator requires itself). If it is UpgradePurchased, it shows upgrade codes from linked upgrade databases.
• Comparison — Equals, NotEquals, GreaterThan, LessThan, GreaterOrEqual, or LessOrEqual.
• Value — The threshold number. For "GeneratorLevel GreaterOrEqual 5", the value is 5.

Each prerequisite shows a human-readable summary below it: "Requires: PEASANT_HUT Level ≥ 5" or "Requires: GOLD ≥ 1.0K". You can add multiple prerequisites to a single generator — all of them must be met for the generator to unlock.

Milestones

Milestones are level thresholds that grant bonuses or trigger events when the generator reaches a specific level. They are the "every 25 levels, something cool happens" feature that gives idle games their sense of progression. Without milestones, leveling a generator from 50 to 75 feels identical to leveling it from 75 to 100. With milestones, level 75 might grant "x2 Production" and level 100 might grant "+50% Global Output" — giving the player meaningful targets to work toward.

Each milestone is a foldable entry in a reorderable list. A milestone has:

• Level Threshold — The level that triggers this milestone. Examples: 10, 25, 50, 75, 100, 150, 200.
• Bonus Type — What kind of bonus this milestone grants:
  • Multiply — Multiply production by this value (e.g., x2, x3)
  • AddFlat — Add a flat amount to production per second
  • AddPercent — Add a percentage bonus to production (e.g., +50%)
• Bonus Value — The numeric value of the bonus. For Multiply x2, the value is 2. For AddPercent +50%, the value is 0.5.
• Description — A text description shown to the player. "Production x2", "+50% Output", "Unlocks Auto-Buy".
• Target Code — Optional. If empty, the bonus applies to this generator. If set to a resource code or another generator code, the bonus applies to that target instead. This is how you create milestones that have global effects: "At level 100, this generator boosts ALL generators by +10%."

Below the milestone's core fields, you will see milestone-level dynamic properties — the properties you defined in the "Milestone-Level Properties" section of Step 2. Each milestone gets its own independent values for these properties.

Dynamic Properties (Generator-Level)

At the bottom of the entry editor, foldout sections appear for each generator-level property type you defined in Step 2. Each generator gets its own values for these properties, just like resources get their own values for resource-level properties.

Step 4: Settings

Identical in structure to the Resource Forge. Choose your output paths (default folder, or custom separate paths for scripts and assets), review the file preview, and check the descriptive summary.

The summary for generators is more detailed than for resources — it includes the total number of generators, total milestones across all generators, and a property breakdown for both generator-level and milestone-level (how many categories, flags, numerics, and texts at each level).

Step 5: Generate

The generation process is the same two-phase system as the Resource Forge: Phase 1 writes the C# files, Unity recompiles, then Phase 2 creates the data asset.

The Generator Forge generates:

• {Prefix}Type.cs — A type-safe enum with one entry per generator (PEASANT_HUT, STEEL_FOUNDRY, etc.)
• {Prefix}Database.cs — The database class implementing IIdleGeneratorDataSource. This provides full query access plus generator-specific methods:
  • GetGeneratorsProducing(resourceCode) — Find all generators that produce a specific resource
  • GetGeneratorsCosting(resourceCode) — Find all generators that cost a specific resource
  • Type-safe enum access for every generator
  • Two-level property accessors for both generator-level and milestone-level queries
• {Prefix}DatabaseEditor.cs — A custom editor with split-panel layout, search, and filtering. The editor also displays prerequisite chains as human-readable text so you can verify your progression flow from the Inspector.
• {Prefix}Database.asset — The data asset with all generators, their production entries, cost entries, prerequisites, milestones (with milestone-level properties), and generator-level properties.

Timer vs Continuous Production

Every generator in Simple Idle Forge operates in one of two production modes. This is not just a cosmetic difference — the two modes create fundamentally different player experiences. Understanding when to use each one (and how to mix them) is one of the most important decisions in your game's design.

Continuous Production

In continuous mode, the generator produces resources every frame at a smooth, steady rate. The formula is straightforward:

production per frame = baseRate × level × bonuses × deltaTime

The player sees their resource counter ticking up constantly. There is no waiting, no progress bar, no "collect" moment. Resources just flow. This is the production model that Cookie Clicker, Clicker Heroes, and Realm Grinder use.

Continuous production feels effortless. The player buys a generator and immediately sees numbers going up. It creates a satisfying, always-growing sensation that is the hallmark of classic idle games. The downside is that it can feel samey — every generator just makes numbers tick faster.

Timer Production

In timer mode, the generator accumulates production over a fixed interval, then delivers all the resources at once when the timer completes. The player sees a progress bar fill up over N seconds, and when it reaches 100%, the batch is collected.

batch amount = baseRate × level × bonuses × interval
effective interval = baseInterval / (1 + totalSpeedBonus)

The player sees a progress bar filling up over 5, 15, 30, or 60 seconds. When it completes, a satisfying batch of resources arrives all at once. Speed bonuses from upgrades make the timer tick faster — an upgrade that grants +100% Speed to the Steel Foundry cuts its 15-second cycle down to 7.5 seconds.

Timer production feels more engaging. Each collection is a small event. The player watches multiple timers ticking at different speeds, waits for the big ones to complete, and makes strategic decisions about which timers to speed up with upgrades. This is the model that Adventure Capitalist, Idle Miner Tycoon, and many mobile idle games use.

The wizard provides four interval presets for quick setup:

When to Use Which

• Continuous for basic resource gathering: farms, mines, passive income, anything that "just happens" in the background. These are your bread-and-butter generators that keep the economy flowing.
• Timer for activities that feel like distinct actions: crafting stations, manufacturing lines, combat encounters, expeditions, research projects. Anything where the player should feel the "weight" of the process.

Mixing Both Modes

You absolutely can — and probably should — use both modes in the same game. The Factory Tycoon demo is the perfect example: its Ore Extractor and Lumber Mill use continuous production (raw materials flow constantly), while the Steel Foundry, Circuit Fab, and Luxury Workshop use timer production (processing takes time). This creates a natural supply-chain feel where raw materials accumulate smoothly but processed goods arrive in satisfying batches.

The Survival Idle demo uses a similar pattern: five basic gatherers (Forager, Well Digger, Fire Keeper, Woodcutter, Stone Mason) run continuously, while seven crafting buildings (Tanner, Weaver, Tool Smith, Herbalist, Shelter Builder, Morale Booster, Militia Trainer) use timer mode. Gathering is passive; crafting is active.

The RPG Idle demo takes it further: combat zones use timer mode with varying intervals (10s for easy zones, 30s for bosses), while passive regeneration generators use continuous mode. The player watches their combat timers tick while health and endurance regenerate smoothly in the background.

Understanding Cost Scaling

Cost scaling is the mathematical foundation of every idle game's economy. It controls how quickly generators become more expensive as the player buys more levels, which directly determines the pace of your game. Too gentle and the player reaches endgame in minutes. Too aggressive and mid-game feels like a wall. The scaling formula you choose defines your game's progression curve.

Simple Idle Forge offers five scaling formulas. Each one creates a different economic feel.

None (Constant Cost)

cost(n) = baseCost

The cost never changes. Level 1 costs the same as level 100. This is rarely used for generators (it would make the game trivially easy) but can make sense for one-time upgrades or for generators that are designed to be spammed freely, like basic training dummies.

Linear

cost(n) = baseCost + (n × factor)

The cost increases by a flat amount each level. If the base cost is 100 and the factor is 10, level 1 costs 100, level 2 costs 110, level 10 costs 190, level 100 costs 1,090. Linear scaling grows slowly and predictably. It feels generous to the player — the 50th level is not dramatically more expensive than the 10th.

Use Linear scaling when you want a gentle, approachable curve. It works well for early-game generators where you do not want the player to feel punished for buying levels.

Exponential

cost(n) = baseCost × factorn

The cost multiplies by the factor each level. This is the industry standard for idle games. Cookie Clicker uses 1.15, Clicker Heroes uses 1.07, Adventure Capitalist uses 1.07 to 4.0 depending on the business. Almost every successful idle game on the market uses exponential scaling for its generators.

Here is what Exponential 1.15 looks like with a base cost of 10:

Notice how the cost grows modestly at first (10 to 40 over the first 10 levels) but becomes enormous later (nearly 14 trillion at level 200). This creates the signature idle game rhythm: buy levels quickly at first, then slowly as costs climb, then prestige to reset and start the cycle again with bonuses that make the early levels even faster.

The four exponential presets cover the full range of common idle game pacing:

• Gentle (1.07) — Slow cost growth. Clicker Heroes uses this. Players can reach high levels without prestige. Good for games with many prestige layers where each layer needs room to breathe.
• Standard (1.15) — The Cookie Clicker standard. Fast enough to create pressure, slow enough that progress feels steady. If you are not sure, use this.
• Steep (1.30) — Aggressive cost growth. Players hit a wall quickly and must prestige or buy upgrades to push further. Good for prestige-heavy designs.
• Aggressive (1.50) — Very fast cost growth. Each level costs 50% more than the previous one. Use this sparingly — for late-game generators or challenge content.

Polynomial

cost(n) = baseCost × nfactor

The cost follows a power curve. Unlike exponential scaling (which multiplies), polynomial scaling raises the level number to a power. This creates a curve that grows faster than linear but slower than exponential at high levels.

• Sub-Quadratic (^1.5) — Gentle power curve. Sits between linear and quadratic.
• Quadratic (^2) — Costs grow with the square of the level. Level 10 costs 100x base, level 100 costs 10,000x base.
• Cubic (^3) — Steep power curve. Level 10 costs 1,000x base.

Polynomial scaling is less common in mainstream idle games but appears in math-heavy incrementals and in games that want a "middle ground" curve that feels different from the standard exponential.

Logarithmic

cost(n) = baseCost × (1 + factor × ln(n + 1))

The cost increases sharply at first and then flattens out at higher levels. This is the opposite pattern from exponential: early levels see meaningful cost increases, but late-game levels become relatively cheap. The natural logarithm compresses large numbers, so the difference between level 100 and level 200 is much smaller than the difference between level 1 and level 10.

Logarithmic scaling is ideal when you want late-game to feel generous — when the player has already invested heavily and you want to reward continued play with easier leveling rather than harder leveling. Some idle games use this for utility generators that are meant to reach very high levels.

The three logarithmic presets control how aggressive the early-game scaling is:

• Gentle (0.5) — Very mild scaling. Costs barely increase over hundreds of levels.
• Standard (1.0) — Moderate logarithmic curve. Noticeable early cost increases that flatten by level 50.
• Steep (2.0) — Stronger early scaling that still flattens at high levels.

The Interactive Preview

You do not need to memorize any of these formulas. The wizard's interactive cost preview slider lets you see the exact cost at any level from 1 to 200, updating in real time as you adjust the scaling type, factor, and base cost. Drag the slider back and forth and watch the numbers change. If the curve feels wrong, tweak the factor and check again. This iterative, visual tuning process is far more effective than trying to imagine what 1.15⁷⁵ looks like.

Tips for Generator Design

Generators define the rhythm of your idle game. Here is practical advice from successful idle games and the four demos.

Your First Generator Should Be Cheap

The player's first purchase should cost almost nothing — 10 or 15 of the primary currency. This first generator teaches the core loop: buy a thing, watch it produce, buy another thing. If the first generator is expensive, the player stares at a blank screen for too long and bounces. Every successful idle game makes the first purchase nearly instant. Cookie Clicker's Cursor costs 15. Adventure Capitalist's Lemonade Stand costs 4.

Chain Prerequisites for Natural Progression

Do not make all generators available from the start. Use prerequisites to create a progression chain: Generator 2 unlocks when Generator 1 reaches level 5. Generator 3 unlocks when Generator 2 reaches level 3 and the player has 1,000 Gold. This creates a natural discovery flow where new content appears as the player progresses, keeping the game fresh for hours instead of overwhelming them with 12 options on the first screen.

The Simple Kingdom demo chains its generators linearly: Peasant Hut is free, Wheat Farm unlocks at Peasant Hut level 5, Quarry unlocks at Wheat Farm level 5, and so on up the chain. The RPG Idle demo uses a more complex web where combat zones unlock based on both generator levels and resource amounts.

Use Milestones Every 25 Levels

Milestones every 25 levels (25, 50, 75, 100, 125, ...) is the sweet spot for most idle games. It gives the player a visible goal to work toward at all times. "I'm at level 38, just 12 more to the x2 Production milestone" is a powerful motivator. Without milestones, there is no difference between levels 38 and 50 — and the player has no reason to target either one.

A common milestone progression pattern:

Timer Mode Works Great for Crafting Stations

If your game has any kind of crafting or processing, use timer mode for those generators. "Iron Smelter: converts Ore into Iron every 15 seconds" is inherently more interesting than "Iron Smelter: produces 2 Iron per second." The timer creates anticipation, gives the player something to watch, and makes Speed upgrades feel meaningful. The Factory Tycoon demo is built entirely around this pattern.

Multi-Resource Production Creates Depth

Do not limit generators to producing just one resource. A combat zone in an RPG might produce SOULS (primary), TITANITE (crafting material), and a small amount of EMBER (prestige currency). This creates interesting trade-offs: leveling the Dragon Nest is expensive, but it produces three valuable resources at once. Players who invest in multi-output generators feel smart, and their economy diversifies naturally.

Match Production Mode to Fantasy

Ask yourself: does this generator represent something that runs continuously or something that happens in discrete events? A farm grows crops continuously. A blacksmith forges swords one at a time. A patrol returns from a mission after a delay. A mine drips ore steadily. Let the fantasy guide the mode, and the game will feel cohesive.

What Are Upgrades?

Upgrades are the things players buy to make everything go faster. They are the connective tissue between your resources, generators, and prestige layers — the purchases that turn a slow early game into a satisfying avalanche of numbers. A well-designed upgrade tree is what keeps players making meaningful decisions for hours instead of minutes.

In Simple Idle Forge, an upgrade is anything a player can purchase that changes the way the game behaves. That includes:

• Production multipliers — "Double the output of all Mines" or "x3 Gold production globally"
• Flat bonuses — "+100 Gold per second to Lumberjacks" or "+500 base production"
• Percentage boosts — "+50% Iron production" or "+25% to all generators"
• Automation triggers — "Auto-buy Iron Mines whenever you can afford them"
• Feature unlocks — "Reveal the Blacksmith generator" or "Enable the Enchanting tier"
• Resource grants — "Receive 10,000 Gold immediately" as a one-time care package

Upgrades can be one-time purchases (buy it once and the effect is permanent) or repeatable (buy it as many times as you can afford, with costs scaling each time). A one-time upgrade like "Double Miners" is a milestone moment. A repeatable upgrade like "Mining Efficiency +1%" is a steady drip of power that scales with your economy.

Here are some examples from the four included demo games:

The Upgrade Forge is the third forge in the chain, after Resources and Generators. It knows about both of them — it pulls resource codes for costs (what the upgrade costs to buy) and generator codes for targets (what the upgrade affects). By the time you open the Upgrade Forge, you should already have your resources and generators defined so the wizard can connect everything together.

Opening the Upgrade Forge

Open the Upgrade Forge wizard from the Unity menu bar:

Window → Living Failure → Simple Idle Forge → Upgrade Forge

The wizard window opens with a tab bar across the top showing all five steps. You can click any tab to jump directly to that step, and the wizard validates your work in real time — if something needs attention, you will see it immediately. The Upgrade Forge is the third forge in the menu (after Resource Forge and Generator Forge), reflecting the natural order of building an idle game: define your currencies first, then your producers, then the boosts that accelerate them.

Linking Databases

The Upgrade Forge links to two types of databases: resource databases and generator databases. This is because upgrades sit at the intersection of your game's economy — they cost resources to buy and they modify generators (or resources, or the whole game) when purchased.

Why Resource Databases?

Every upgrade has a cost. That cost is expressed in resource codes — "costs 1,000 GOLD" or "costs 500 IRON and 200 WOOD". The Upgrade Forge needs access to your resource databases so that when you set up costs, you get a dropdown of valid resource codes instead of typing them manually. This eliminates typos and ensures every cost references a real resource that exists in your game.

Resource databases are also needed for the ResourceGrant effect type. When an upgrade grants a one-time dump of resources to the player, the target code is a resource code. And for upgrades that target a specific resource (like "+50% Gold production"), the target code dropdown is populated from your linked resource databases.

Why Generator Databases?

Most upgrades in an idle game affect a specific generator: "Double the output of Mines", "Automate Lumberjacks", "Unlock the Blacksmith". The Upgrade Forge needs your generator databases so it can populate the target code dropdown with valid generator codes. When you set an upgrade's target type to Generator and pick a target code, you are telling the system exactly which producer this upgrade modifies.

Generator databases also feed into the prerequisites system. If you want an upgrade to require "Mines at level 10 before it becomes available", the wizard needs to know what generators exist so it can offer them in the condition dropdown.

Linking in the Wizard

Step 1 of the wizard has two sections for linking databases: one for resource databases and one for generator databases. Each section shows a list where you can drag and drop databases from your project, or click the add button to browse. The wizard validates each database you add — it must implement the correct data source interface. Duplicate databases are automatically detected and flagged.

You can link multiple resource databases and multiple generator databases. This is useful if your game separates resources into different databases (one for currencies, one for materials, one for prestige currencies) or generators into different tiers. The wizard merges all codes from all linked databases into a single unified dropdown, so you always see every valid code regardless of which database it lives in.

The 5 Steps

The Upgrade Forge follows the same five-step wizard pattern as every forge in the toolkit. You work through them in order (though you can jump between tabs at any time), and each step builds on the one before it.

The Builder in Detail

Step 3 is where you spend most of your time in the Upgrade Forge. The split-panel layout gives you a master list on the left and a full detail editor on the right. Here is everything you can configure on each upgrade entry, in the order it appears in the editor.

Identity

Every upgrade starts with four identity fields:

• Code — A unique string identifier used in code and cross-references. Must be a valid identifier (letters, numbers, underscores). Examples: MINE_BOOST, AUTO_IRON, GLOBAL_SPEED_UP. This becomes an entry in the generated enum.
• Display Name — The human-readable name shown to players. "Improved Mining", "Iron Automation", "Time Warp".
• Description — A text description of what the upgrade does. This is what players read in your upgrade shop: "Doubles the output of all Iron Mines" or "Automatically purchases Lumberjacks whenever you can afford them".
• Icon — An optional sprite reference for your UI.

Costs

Upgrades can cost multiple resources. Each cost entry has four fields:

• Resource Code — A dropdown populated from your linked resource databases. Pick which resource this cost is paid in (GOLD, IRON, GEMS, etc.).
• Base Cost — The starting price. For one-time upgrades, this is the flat price. For repeatable upgrades, this is the price of the first purchase.
• Scaling Type — How the cost changes with each purchase. The same five formulas available in the Generator Forge:

• Scaling Factor — The number used in the formula. For Exponential, 1.15 is gentle, 1.5 is standard, 2.0 is steep. For Linear, this is the flat amount added per purchase.

For one-time upgrades (maxPurchases = 1), scaling does not matter since the upgrade is only ever bought once. But for repeatable upgrades, the scaling formula determines how quickly the price ramps up. The wizard provides preset buttons for common configurations:

• Exponential presets: Gentle (1.07), Standard (1.15), Steep (1.5), Aggressive (2.0)
• Linear presets: +10, +baseCost
• Polynomial presets: Quadratic (2.0), Sub-Quadratic (1.5), Cubic (3.0)
• Logarithmic presets: Gentle (0.5), Standard (1.0), Steep (2.0)

Each cost entry also includes a formula display in a help box that shows the exact formula being used, and an interactive cost preview slider (range 1–200) that lets you see the cost at any purchase count. The preview shows both the cost at the selected level and the cumulative total cost to reach that level. This lets you tune your economy before generating anything — if level 50 of a repeatable upgrade costs 10 trillion Gold and your players only have millions, you know the scaling factor needs to come down.

Max Purchases (Limits)

This single field controls whether an upgrade is one-time or repeatable:

• 1 — One-time purchase. The player buys it once, the effect applies permanently, and it disappears from the shop (or shows as "Purchased"). This is the most common type for named upgrades like "Double Miners" or "Unlock Blacksmith".
• 0 — Unlimited repeatable. The player can buy it as many times as they can afford. Each purchase applies the effect again (stacking additively or multiplicatively depending on the effect type). Costs scale with each purchase according to the scaling formula. This is the bread and butter of idle game progression — upgrades like "Mining Efficiency +1%" that the player buys dozens or hundreds of times.
• Any other number — Limited repeatable. The player can buy it up to that many times. For example, maxPurchases = 5 means the upgrade can be purchased five times before it is fully exhausted. Useful for powerful upgrades you want available in limited quantities.

The Six Effect Types

The effect is the core of every upgrade — it defines what actually happens when a player buys it. Simple Idle Forge provides six effect types that cover every scenario an idle game needs. Each effect type combines with a target type and target code to determine exactly what gets modified and how.

Target Type and Target Code

Before diving into the effects, understand how targeting works. Every upgrade has a target type that determines the scope of its effect:

• Generator — The upgrade affects a single, specific generator. Set the target code to the generator's code (e.g., IRON_MINE). The effect applies only to that generator's production.
• Resource — The upgrade affects a single, specific resource. Set the target code to the resource's code (e.g., GOLD). The effect applies to all production of that resource, regardless of which generator produces it.
• Global — The upgrade affects everything. Leave the target code blank. The effect applies universally to all generators and all resources across your entire game. Use this for powerful, game-wide boosts.

Now, the six effect types:

1. Multiply

Multiplies the target's output by the effect value. An effect value of 2 means "double the production". An effect value of 3 means "triple it". This is the most dramatic and satisfying upgrade type for players — buying a x2 multiplier and watching all your numbers instantly double is the core dopamine hit of idle games.

Example: Target Type = Generator, Target Code = IRON_MINE, Effect Value = 2. Result: Iron Mine production is multiplied by 2.

Stacking behavior: Each Multiply bonus is applied independently. If you have two x2 multipliers targeting the same generator, the total multiplier is 2 × 2 = 4, not 2 + 2 = 4. This means stacking multipliers gets very powerful very fast — three x2 multipliers give x8 total. Design accordingly.

2. AddFlat

Adds a flat amount to the target's base production. An effect value of 100 means "+100 per second" added to the base before any multipliers apply. This is less flashy than Multiply but very important for early-game progression when multiplying a tiny base does not move the needle much.

Example: Target Type = Generator, Target Code = LUMBERJACK, Effect Value = 50. Result: Every Lumberjack produces 50 more per second on top of its base production.

Stacking behavior: All AddFlat bonuses sum together. If you have +100 and +50 flat bonuses targeting the same generator, the total flat bonus is 150. Flat bonuses are added to the base value before percentage and multiply bonuses are applied, which means they get amplified by everything that comes after them in the stacking pipeline.

3. AddPercent

Adds a percentage bonus to the target. An effect value of 0.5 means "+50% production". This is applied after flat bonuses but before multipliers. AddPercent is the middle ground between the dramatic power of Multiply and the steady consistency of AddFlat.

Example: Target Type = Resource, Target Code = GOLD, Effect Value = 0.25. Result: All Gold production is increased by 25%.

Stacking behavior: All AddPercent bonuses sum together, then apply as a single multiplier. If you have +50% and +30% percentage bonuses, the combined effect is ×(1 + 0.5 + 0.3) = ×1.8, not ×1.5 × 1.3 = ×1.95. This additive stacking means percentage bonuses become less impactful as you accumulate more of them, which is a natural balancing mechanism. Your tenth +10% upgrade is less exciting than your first.

4. Unlock

Reveals a locked generator or feature. The effect value is not used (typically set to 1). This upgrade type changes the game's structure rather than its numbers — it makes something available that was not available before.

Example: Target Type = Generator, Target Code = BLACKSMITH, Effect Value = 1. Result: The Blacksmith generator becomes available for purchase. Before this upgrade, the Blacksmith is hidden or greyed out in your UI.

Design note: Unlock upgrades work best as one-time purchases that gate progression. "Spend 10,000 Gold to unlock the Enchanting tier" is a satisfying milestone that gives the player a clear goal to work toward. You control the gating entirely through the unlock upgrade's cost and prerequisites.

5. Automate

Enables automatic purchasing for a specific generator. Once purchased, the auto-purchase system will buy levels of the target generator whenever the player can afford them — no manual clicking required. This is one of the most satisfying upgrade types in idle games because it fundamentally changes how the player interacts with that generator.

Example: Target Type = Generator, Target Code = IRON_MINE, Effect Value = 1. Result: Iron Mines are now auto-purchased. The auto-purchase system buys one level whenever the player has enough resources.

How it works: When an Automate upgrade is purchased, the runtime automatically registers the target generator with the auto-purchase system. You do not need to write any code or configure anything else. The auto-purchase system supports four strategies (Cheapest first, Most Expensive first, Round Robin, or Disabled), and the player or your UI can switch between them at any time. But the key insight is that Automate upgrades are the opt-in mechanism — a generator only gets auto-purchased if the player has bought the corresponding Automate upgrade for it.

6. ResourceGrant

Gives the player a one-time dump of a resource when purchased. The target code is the resource code (not a generator code), and the effect value is the amount granted. This is useful for "care package" upgrades that give stuck players a boost, or for premium/prestige-tier purchases that reward the player with a large infusion of a specific currency.

Example: Target Type = Resource, Target Code = GOLD, Effect Value = 50000. Result: The player receives 50,000 Gold immediately when they buy this upgrade.

Design note: ResourceGrant upgrades are most useful as one-time purchases. Making them repeatable can trivialize your economy if the grant amount is large. But a repeatable ResourceGrant with exponentially scaling costs can work as an "exchange" mechanic — "Spend Gems to get Gold" where the Gem cost increases each time.

Quick Presets in the Wizard

The Upgrade Forge builder provides six quick preset buttons that configure the effect section with a single click. These are starting points — you can modify any field after applying a preset:

Effect Preview

Below the effect configuration, the wizard shows a live preview in a help box. This preview includes the formula description ("Multiplies IRON_MINE production by 2.00"), the stacking behavior for repeatable upgrades ("At 5 purchases: total multiplier = 32.00"), and a description of how this effect interacts with the bonus stacking pipeline. For repeatable upgrades, an interactive slider lets you see how the effect compounds at different purchase counts — so you can verify that 10 purchases of a +10% AddPercent upgrade gives +100% total (not +159% like it would with multiplicative stacking).

Dynamic Properties

Below the effect section, foldouts for your custom dynamic properties appear — categories, flags, numerics, and text fields, exactly as you defined them in Step 2. These are single-level properties that appear on every upgrade entry. Use them for anything your game needs that the built-in fields do not cover: visual tier indicators, sort priorities, flavor text, UI hints, unlock animations, sound effect keys, or any other metadata your upgrade shop UI needs.

How Bonus Stacking Works

Understanding how bonuses stack is critical to designing a balanced idle game economy. Simple Idle Forge uses a single, transparent stacking pipeline for all bonuses in the game — from upgrades, prestige layers, achievements, milestones, and temporary buffs. Everything feeds into the same formula, in the same order, every time. No hidden interactions, no mysterious order-of-operations bugs.

The pipeline is:

finalValue = (base + sumOfAllFlatBonuses) × (1 + sumOfAllPercentBonuses) × multiplier1 × multiplier2 × ...

In plain English:

A Concrete Example

Let's trace through a real scenario. You have an Iron Mine with base production of 10 per second, and the following bonuses targeting it:

• Upgrade "Better Pickaxes": AddFlat +5
• Upgrade "Mining Efficiency": AddPercent +50% (effect value 0.5)
• Upgrade "Double Miners": Multiply x2

Here is the pipeline in action:

The final production is 45 per second, up from 10. Notice how the flat bonus of +5 ends up contributing much more than 5 to the final result — it gets amplified by both the percentage bonus and the multiplier. This is why AddFlat upgrades are more powerful than they might seem at first glance, and why the order of the pipeline matters so much.

This stacking pipeline is the same one used by prestige permanent bonuses, milestone rewards, achievement rewards, and temporary buffs. Everything in the game that modifies production feeds into the same formula, so you always know exactly what the final number will be.

Prerequisites

Prerequisites are conditions that must be met before an upgrade becomes available for purchase. They let you create a progression tree where powerful upgrades are gated behind earlier achievements, resource thresholds, or generator milestones. A game without prerequisites is a game where the player buys the strongest upgrade first and skips everything else. Prerequisites force meaningful progression.

Each prerequisite has four fields:

• Condition Type — What kind of check to perform. The available types are:

• Target Code — The specific resource, generator, upgrade, or milestone code to check against. The wizard provides context-aware dropdowns: when the condition type is ResourceAmount, you see resource codes from your linked databases. When it is GeneratorLevel, you see generator codes. When it is UpgradePurchased, you see codes of other upgrades in the current wizard (excluding the upgrade you are editing, to prevent self-referencing).
• Comparison — The comparison operator: Equals, Not Equals, Greater Than, Less Than, Greater or Equal, Less or Equal.
• Value — The threshold to compare against. For "requires Gold >= 5000", the value is 5000.

An upgrade can have multiple prerequisites. All of them must be satisfied simultaneously (they are ANDed together). For example, "Warrior Training" might require:

• MINE level >= 10
• GOLD >= 5000
• BASIC_MINING_BOOST purchased (UpgradePurchased, value >= 1)

All three conditions must be true before Warrior Training appears in the upgrade shop.

The wizard shows a human-readable summary below each prerequisite entry: "Requires: MINE Level >= 10" or "Requires: GOLD Amount >= 5.0K". This makes it easy to verify at a glance that your prerequisites make sense without mentally parsing condition types and codes.

Tips for Upgrade Design

Upgrades are the levers that control your game's pacing. Get them right and your idle game sings. Get them wrong and players either stall out (upgrades are too expensive) or blast through everything in minutes (upgrades are too powerful). Here are design principles drawn from the best idle games ever made:

Mix One-Time and Repeatable Upgrades

One-time upgrades are milestones — they feel like events. "You just unlocked Double Mining!" is a moment the player remembers. Repeatable upgrades are steady progression — they feel like investment. "Mining Efficiency is now level 47" is a number the player watches grow. The best idle games use both: one-time upgrades for dramatic power spikes and unlock moments, repeatable upgrades for the steady drip of incremental improvement between those spikes.

A good ratio to start with: about 60% one-time upgrades and 40% repeatable. The one-time upgrades provide structure and goal posts. The repeatable upgrades fill in the gaps between them.

Automation Upgrades Feel Great as Milestone Rewards

There is a reason every successful idle game gates automation behind progression. When a player manually buys 50 levels of Iron Mine and then purchases "Auto Iron Mine", it feels like a reward for their effort. The manual clicking was the journey; the automation is the destination. Do not give automation upgrades away cheaply or early. Make them something the player earns after meaningfully engaging with the generator they automate.

A common pattern: place the Automate upgrade for each generator at roughly the same progression point where that generator starts to feel tedious to manage manually. If a player has been clicking "Buy Lumberjack" for 15 minutes, the Automate Lumberjack upgrade should appear right around that 15-minute mark. The game reads the player's mind: "This is getting repetitive" — and immediately offers the solution.

Use Prerequisites to Gate Powerful Upgrades

An idle game without gating is an idle game where the player buys the best thing immediately. Prerequisites force progression through your intended path. The player cannot buy "x3 Global Production" until they have bought "x2 Mine Production" and reached generator level 25. This creates a breadcrumb trail of goals that keeps the player engaged for hours instead of minutes.

Layer your prerequisites: the first tier of upgrades has no prerequisites (available immediately). The second tier requires first-tier upgrades or low generator levels. The third tier requires second-tier upgrades and medium resource thresholds. This creates a cascading unlock system where every purchase brings new options into view.

ResourceGrant Upgrades Work as Care Packages

Every idle game has moments where the player gets stuck. Maybe they are saving for an expensive generator but the progress is painfully slow. A one-time ResourceGrant upgrade — "Receive 50,000 Gold" — acts as a release valve. It gives the stuck player a burst of resources to push through the bottleneck. Place these strategically at points in your progression where you know players might stall, priced just below the "frustration threshold".

ResourceGrant upgrades are also perfect for premium/prestige mechanics: "Spend 10 Gems to receive 100,000 Gold" where Gems are a premium currency. This gives Gems a concrete value without breaking the core economy, because you control exactly how much Gold each Gem purchases.

Think About Reset Interactions

If your game has a prestige system (and most idle games should), think about which upgrades survive a reset and which get wiped. The Prestige Forge controls this through reset rules, but you should design your upgrades with resets in mind from the start. Automation upgrades that survive prestige make each subsequent run much smoother. Production multipliers that reset create a reason to buy them again each run, which drives engagement with the upgrade shop.

A common pattern: early upgrades reset on prestige (so the player re-buys them each run, faster each time thanks to permanent bonuses). Late-game upgrades survive prestige (so the player does not feel punished for investing in expensive purchases). This creates a satisfying loop where each prestige run starts easy, accelerates through the upgrade tree faster than before, and pushes further into new territory.

Preview Your Economy Before Generating

The Upgrade Forge's cost preview slider and effect preview are not just convenience features — they are design tools. Before you click Generate, scroll through your upgrades and check: Is the 20th purchase of Mining Efficiency still affordable when the player has 1 billion Gold? Does the x2 Global Production upgrade cost enough to feel like a meaningful investment? Are your Automate upgrades priced at the right progression point? The preview tools give you these answers before you leave the wizard.

What Is Prestige?

Prestige is the mechanic that gives idle games infinite replay value. It is the single most important system that separates a throwaway 2-hour distraction from a 200-hour obsession that players keep coming back to for weeks. The concept is deceptively simple: when you reach a certain point in the game, you voluntarily reset most of your progress in exchange for a permanent currency that makes you stronger forever. The next time you play through, you start from scratch — but everything is faster, everything produces more, and you reach even further before resetting again.

Every great idle game has some version of this mechanic. Cookie Clicker calls them Heavenly Chips — when you ascend, you lose all your cookies and buildings but earn permanent multipliers based on how many cookies you baked in total. Adventure Capitalist calls them Angel Investors — resetting wipes your businesses but grants angels that boost everything by 2% each. Realm Grinder has Abdications. Idle Miner Tycoon has Super Managers. Melvor Idle has multiple prestige-like reset layers. The names change but the loop is the same: accumulate, reset, grow permanently, repeat.

Without prestige, an idle game has a ceiling. The player buys all the generators, purchases all the upgrades, and hits the number cap. There is nothing left to do. With prestige, there is always a reason to keep playing. Each prestige run is a cycle:

This is the engine of long-term engagement in idle games. It solves the biggest design problem in the genre: how do you keep a game interesting when the core mechanic is "watch numbers go up"? The answer is prestige. You give the player a reason to restart, a reward for restarting, and the promise that each restart brings them closer to something bigger.

Here are examples from the four demo games included with Simple Idle Forge:

The Prestige Forge is the fourth forge in the chain, after Resources, Generators, and Upgrades. It knows about all three because it controls what gets reset and what survives. By the time you open the Prestige Forge, you should have your resources, generators, and upgrades defined so the wizard can reference them when configuring reset rules and bonus targets.

Opening the Prestige Forge

Open the Prestige Forge wizard from the Unity menu bar:

Window → Living Failure → Simple Idle Forge → Prestige Forge

The wizard window opens with a tab bar across the top showing all five steps: Setup, Definitions, Builder, Settings, and Generate. You can click any tab to jump directly to that step, and the wizard validates your work in real time — if something is missing or misconfigured, you see it immediately. The Prestige Forge is the fourth forge in the menu (after Resource, Generator, and Upgrade), reflecting the natural order of building an idle game: define your currencies, build your producers, add the boosts that accelerate them, and then design the reset-and-earn loop that gives the whole system infinite depth.

Linking Databases

The Prestige Forge links to three types of databases: resource databases, generator databases, and upgrade databases. This is because prestige sits at the very top of your game's hierarchy — it needs to know about everything, because it controls what gets destroyed and what survives when the player resets.

Why Resource Databases?

Every prestige layer involves two resources: the source resource (what the formula reads from, usually your primary currency like Gold) and the prestige currency (what gets awarded on reset, like Prestige Points or Heavenly Chips). Both of these are resource codes. The Prestige Forge needs access to your resource databases so that when you configure a prestige layer, you get dropdowns of valid resource codes instead of typing them by hand. Resource databases also feed into reset rules — when you want a prestige to "reset all resources to zero" or "reset GOLD to zero but keep GEMS", those codes come from your linked resource databases.

Why Generator Databases?

Most prestige layers reset generators. "Lose all your buildings and start over" is the core of the prestige loop. The Prestige Forge needs your generator databases so it can populate reset rule dropdowns with valid generator codes. You might want to reset ALL generators, or you might want a softer reset that only wipes specific ones. Either way, the forge needs to know what generators exist in your game. Generator codes also appear in permanent bonus targets — "Each Prestige Point gives +1% to all IRON_MINE production" needs to know that IRON_MINE is a real generator.

Why Upgrade Databases?

Upgrades are often the most interesting part of prestige design, because deciding which upgrades survive a reset and which get wiped defines the feel of each prestige cycle. A "soft prestige" might keep all upgrades intact — the player only loses generator levels and resources. A "hard prestige" wipes everything, including all the upgrades the player bought. The Prestige Forge needs your upgrade databases so it can offer specific upgrade codes in reset rules: "Reset ALL upgrades" or "Reset only MINE_BOOST but keep AUTO_IRON".

Linking in the Wizard

Step 1 of the wizard has three separate sections for linking databases: one for resource databases, one for generator databases, and one for upgrade databases. Each section shows a reorderable list where you can drag and drop databases from your project, or click the add button to browse. The wizard validates each database you add — it must implement the correct data source interface. Duplicate databases are automatically detected and flagged with a warning.

You can link multiple databases of each type. If your game separates resources into different databases (one for normal currencies, one for prestige currencies, one for premium currencies) or generators into different tiers, link all of them. The wizard merges all codes from all linked databases into a single unified set of dropdowns, so you always see every valid code regardless of which database it came from.

Step 1: Setup

The Setup step follows the same pattern as every forge: name your database, optionally set a namespace and class prefix, and pick a genre template. But the Prestige Forge adds the triple database linking sections described above, making this the most connection-heavy Setup step in the toolkit.

Naming

Below the naming fields, the wizard shows a generated names preview so you can see exactly what files will be created before you go any further. You will see the enum type name (e.g., MyGamePrestigeType), the database class name (e.g., MyGamePrestigeDatabase), and the editor class name (e.g., MyGamePrestigeDatabaseEditor).

Genre Templates

Six genre templates are available, each pre-filling your property definitions with genre-appropriate categories, flags, numerics, and text fields. Picking a template is a starting point — you can modify, add, or remove any definition after applying it. Or start from scratch with no template at all.

Step 2: Definitions

Define the custom properties that describe your prestige layers. These are single-level properties — unlike the Generator Forge which has two levels (generator-level and milestone-level), the Prestige Forge uses one flat set of properties per prestige entry. You get four property types:

Each property type is managed through a reorderable list with foldouts. Categories have a nested list for their entries. Flags show name and default value on separate rows. Numerics have five rows: name, is-integer toggle, minimum constraint, maximum constraint, and default value. Texts have name and line count. All fields use a plain foldout style — vertically stacked, no dark headers.

Properties defined here appear on every prestige entry you create in Step 3. Use them for anything your game needs that the built-in prestige fields do not cover: visual themes per prestige layer, sound effect keys for the reset animation, UI color overrides, lore descriptions, sort priorities, or any other metadata your prestige panel needs to display properly.

This step also includes JSON schema export and import buttons. You can export your current property definitions to a structured JSON file for backup, sharing across projects, or JSON-assisted content generation. Importing from a JSON file populates the wizard with definitions from the file, giving you options to replace existing definitions or merge them.

Step 3: Builder

Step 3 is the heart of the Prestige Forge — this is where you design every prestige layer in your game. The split-panel layout gives you a master list on the left (280 pixels wide) and a full detail editor on the right. The left panel supports search, category filtering, sorting, bulk selection and deletion, duplication, and pagination. Each entry shows its code, a checkbox for bulk operations, and a category indicator if you defined any categories in Step 2.

When you select an entry in the left panel, the right panel shows every configurable field for that prestige layer. Here is everything, in the order it appears.

Identity

Every prestige layer starts with four identity fields:

• Code — A unique string identifier used in code and cross-references. Must be a valid identifier (letters, numbers, underscores). Examples: REBIRTH, ASCENSION, NEW_GAME_PLUS, COSMIC_RESET. This becomes an entry in the generated enum.
• Display Name — The human-readable name shown to players: "Rebirth", "Ascension", "New Game+", "Cosmic Reset".
• Description — A text description of what this prestige layer does. This is what players read in your prestige panel: "Sacrifice all progress to earn Crown Points. Each Crown Point permanently increases all production by 1%."
• Icon — An optional sprite reference for your UI. A prestige icon often conveys the weight of the action — a phoenix for rebirth, a star for ascension, a cosmic spiral for the deepest reset.

Prestige Currency

This is the resource that gets awarded when the player triggers this prestige layer. It is a dropdown populated from your linked resource databases. You pick the resource code that represents your prestige currency — for example, PRESTIGE_POINTS, HEAVENLY_CHIPS, CROWN_POINTS, or ASCENSION_TOKENS.

This resource must already exist in one of your linked resource databases. If you have not created the prestige currency resource yet, go back to the Resource Forge and add it. A common pattern is to define all your prestige currencies alongside your normal currencies in the Resource Forge, marking them with a "Prestige Currency" category or flag so your UI knows to display them separately from normal resources like Gold and Iron.

Source Resource

This is the resource that the prestige formula reads from to calculate how many prestige points to award. It is also a dropdown from your linked resource databases. Typically this is your primary currency — GOLD, COOKIES, COINS — the one that represents overall game progress. The more of this resource the player has accumulated, the more prestige points they earn.

For multi-layer prestige systems, each deeper layer often reads from the previous layer's currency. Layer 1 reads from GOLD. Layer 2 reads from REBIRTH_POINTS (which are earned from Layer 1). Layer 3 reads from ASCENSION_TOKENS (earned from Layer 2). This creates a cascading hierarchy where each layer depends on the one below it.

Formula Type

The formula determines how the source resource amount is converted into prestige points. Simple Idle Forge provides four formulas, each with different growth curves suited to different game designs. This is one of the most important decisions you will make for your prestige system, because the formula controls the pace at which players earn permanent power:

Formula Parameters

Three parameters control the formula's behavior:

• Base — The divisor in the formula. This sets the "cost" of the first prestige point. A base of 1,000,000 (1M) means you need roughly 1M of the source resource to earn your first point (with Sqrt, you would need exactly 1M for 1 point). A higher base makes prestige harder to reach. A lower base makes the first prestige come sooner. This is the primary knob for controlling when in the game the player first encounters prestige.
• Scale — A multiplier on the formula's result. A scale of 1 gives the raw formula output. A scale of 2 doubles all prestige point rewards. A scale of 0.5 halves them. Use this to fine-tune the quantity of prestige points without changing the growth curve. If the first prestige grants 5 points and you want it to grant 10, double the scale instead of halving the base (which would change when prestige first becomes available).
• Exponent — Only used by the Polynomial formula. Controls the power curve. Values less than 1.0 give diminishing returns (0.5 = square root, 0.33 = cube root). A value of exactly 1.0 gives linear growth. Values greater than 1.0 give accelerating returns (use with extreme caution). This parameter is hidden for Sqrt, Linear, and Log formulas since they have fixed curves.

Minimum to Prestige

This is the threshold of the source resource that must be reached before the prestige button becomes available. Even if the formula would theoretically award points at lower amounts, the prestige option stays locked until the player crosses this line. Set this to a meaningful milestone in your game — the point where you want the player to think "I have accomplished something significant, and now I have a new option."

For example, if your base is 1M, you might set the minimum to prestige at 1M as well — meaning the player needs exactly enough for 1 prestige point before the button appears. Or you might set it to 500K to let players see the prestige option slightly before they can earn a full point, building anticipation. The design choice is yours.

Preview Slider

Below the formula configuration, the wizard provides an interactive preview slider that lets you see exactly how many prestige points the formula would award at various source amounts. Drag the slider to explore different scenarios: "At 5M Gold, I would earn 2 points. At 50M, I would earn 7. At 1B, I would earn 31." The preview also shows inverse lookups — it tells you how much source resource is needed to earn specific point targets. This lets you verify your formula's pacing before generating anything.

Reset Rules

Reset rules define what gets wiped when this prestige layer is triggered. This is where prestige design gets interesting, because the choice of what to reset and what to keep defines the entire feel of each prestige cycle. Each reset rule has three fields:

• Target Type — What kind of thing to reset. Three options: Resource (reset a resource amount to a value), Generator (reset generator levels), or Upgrade (reset upgrade purchase counts).
• Target Code — Which specific thing to reset. This is a dropdown populated from your linked databases based on the target type. For resources, you see all resource codes (GOLD, IRON, GEMS, etc.). For generators, all generator codes. For upgrades, all upgrade codes. There is also a special value: ALL. Setting the target code to ALL resets every resource, generator, or upgrade of that type.
• Reset To Value — What value to reset to. Usually 0 (meaning "wipe it completely"). But you can set it to any value. Resetting a resource to 100 means the player starts each prestige run with 100 of that resource instead of zero — a small head start that makes early runs feel less punishing.

A prestige layer can have multiple reset rules. A typical setup might look like:

This is the "nuclear option" — reset everything. But you have full control. Maybe you want to keep certain resources untouched (like premium currencies or prestige currencies from other layers). Maybe you want generators reset but upgrades kept. The reorderable list lets you mix and match any combination of rules, and the wizard provides quick presets for common configurations:

• Reset Everything — Adds three ALL rules: resources, generators, and upgrades all reset to 0.
• Keep Upgrades — Resets resources and generators to 0 but leaves upgrades untouched.
• Resources Only — Only resets resources to 0. Generators keep their levels, upgrades stay purchased.
• Clear — Removes all reset rules. Nothing gets reset (useful as a starting point for building custom rules).

Each reset rule entry shows a human-readable summary below it: "Reset ALL resources to 0" or "Reset IRON_MINE generator to 0". This makes it easy to verify your reset configuration at a glance.

Permanent Bonuses

Permanent bonuses are the reward — the reason the player gives up their progress. Each bonus defines a lasting benefit that scales with the amount of prestige currency earned. The fields are:

• Target Type — What the bonus affects. Three options: Generator (boost a specific generator), Resource (boost all production of a specific resource), or Global (boost everything in the game).
• Target Code — The specific generator or resource code, populated from your linked databases. For Global bonuses, this is left blank since the bonus applies to everything.
• Bonus Type — How the bonus is applied. Three options matching the standard bonus stacking pipeline:
  • Multiply — Multiplies the target's output. Each prestige point contributes to a multiplicative bonus.
  • AddFlat — Adds a flat amount to the target's base production. Each prestige point adds this much raw output.
  • AddPercent — Adds a percentage bonus. Each prestige point contributes a percentage increase that stacks additively with other percentage bonuses.
• Per Unit Amount — The bonus granted per unit of prestige currency earned. If you set this to 0.01 with AddPercent, each prestige point gives +1% production. If you earn 50 prestige points, that is +50% total. This is the primary balance knob for prestige rewards.
• Description — A human-readable description for your UI: "Each Prestige Point gives +1% to all production" or "+5 base Iron per Crown Point".

A prestige layer can have multiple permanent bonuses. A single layer might give both a global percentage bonus and a targeted flat bonus for a specific generator. The wizard shows a preview slider below the bonus list, letting you see how the bonuses stack at different prestige point amounts. For example: "At 10 points: +10% global production. At 50 points: +50%. At 200 points: +200%." This preview helps you verify that your bonus-per-unit value produces the growth curve you intend.

All permanent bonuses from all prestige layers feed into the same bonus stacking pipeline used by upgrades, milestones, achievements, and temporary buffs. The formula is always:

finalValue = (base + sumOfAllFlatBonuses) × (1 + sumOfAllPercentBonuses) × multiplier1 × multiplier2 × ...

Prestige bonuses do not get any special treatment — they are processed through the same pipeline as every other bonus in the game. This means you always know exactly how a prestige bonus interacts with upgrades and other bonuses: it is transparent and predictable.

Dynamic Properties

Below the permanent bonuses section, foldouts for your custom dynamic properties appear — categories, flags, numerics, and text fields, exactly as you defined them in Step 2. These are single-level properties that appear on every prestige entry. Use them for anything your game needs that the built-in fields do not cover: visual themes, animation triggers, sound effects, prestige shop metadata, layer gating conditions, UI color overrides, or lore text displayed during the reset sequence.

Stacking Prestige Layers

A single prestige layer is powerful. Multiple prestige layers are what turn a good idle game into one that players sink hundreds of hours into. Each deeper layer resets more aggressively, takes longer to reach, and grants bigger permanent rewards. This creates a fractal structure where the game has loops within loops, each one operating on a different timescale.

How Multi-Layer Prestige Works

Consider a game with two prestige layers:

This is the pattern. Each deeper layer:

• Resets everything below it, including the currencies earned by shallower layers
• Takes much longer to earn, because the source resource requirement is higher or the formula grows slower
• Grants much bigger rewards per unit, making it worth the deeper reset
• Operates on a longer timescale — if Layer 1 is earned every 30 minutes, Layer 2 might be earned every few hours

Configuring Layers in the Wizard

Each prestige layer is simply an entry in the Prestige Forge builder. To create a two-layer system, you create two entries. To create four layers, you create four entries. Each entry has its own source resource, formula, reset rules, and permanent bonuses. The key is in the reset rules — Layer 2's reset rules should include resetting the Layer 1 prestige currency to zero.

For example, in a two-layer system:

Notice how Layer 2's source resource is PRESTIGE_POINTS — the currency earned by Layer 1. And Layer 2's reset rules include ALL resources, which wipes PRESTIGE_POINTS. This creates the cascading hierarchy: to do Layer 2, you need lots of Layer 1 currency, and doing Layer 2 wipes the Layer 1 currency. You are spending your accumulated Layer 1 progress to earn Layer 2 progress.

Demo Examples

The Four Prestige Formulas

Choosing the right formula is one of the most impactful decisions in your prestige system design. Each formula produces a fundamentally different growth curve, which determines how quickly players accumulate permanent power and how long each prestige cycle feels. Let's look at each one with concrete numbers.

Sqrt (Square Root)

points = floor(scale × sqrt(source / base))

This is the safe default and the most widely used formula in the idle game genre. Cookie Clicker's Heavenly Chips work on a square root curve. The key property is diminishing returns: to earn your second prestige point, you need 4x as much source as your first. To earn your third, you need 9x. The tenth point requires 100x the source of the first point. This naturally slows prestige point accumulation and prevents runaway power growth.

Example: base = 1,000,000 (1M), scale = 1

Notice the pattern: going from 1M to 100M (100x increase) only gives 10 points. Going from 1M to 1B (1000x increase) gives 31 points. The diminishing returns are severe, which is exactly what you want — it means each additional prestige point requires meaningfully more progress, keeping the game interesting for a long time.

Linear

points = floor(scale × source / base)

The simplest formula: double the source, double the points. There are no diminishing returns and no accelerating returns — growth is perfectly proportional. This makes prestige rewards very predictable and easy for players to understand, but it can lead to exponential power growth when combined with permanent bonuses that compound over time.

Example: base = 1,000,000 (1M), scale = 1

Compare this to Sqrt: at 100M source, Linear gives 100 points while Sqrt gives 10. At 1B, Linear gives 1,000 while Sqrt gives 31. Linear is far more generous, which means you need to be careful with permanent bonus values to avoid your economy spiraling out of control.

Log (Logarithmic)

points = floor(scale × log10(source / base + 1))

The slowest growth formula. Logarithmic growth means that each additional order of magnitude in the source resource gives the same fixed number of additional points. Going from 1M to 10M gives the same gain as going from 10M to 100M, which gives the same gain as going from 100M to 1B. This makes each prestige point extraordinarily expensive at higher levels, creating very long and meaningful prestige cycles.

Example: base = 1,000,000 (1M), scale = 10

With a scale of 10, the player earns only about 6 additional points per order-of-magnitude increase in source resource. Going from 1M to 1T (a million-fold increase) earns just 23 additional points. This extreme diminishing returns makes Log ideal for deep prestige layers where you want each point to represent a massive amount of accumulated progress.

Polynomial

points = floor(scale × (source / base)exponent)

The fully tunable option. By adjusting the exponent, you can create any growth curve between ultra-slow and ultra-fast:

• Exponent 0.33 (cube root) — Slower than Sqrt. Very strong diminishing returns. Good for secondary prestige layers.
• Exponent 0.5 — Identical to Sqrt.
• Exponent 0.75 — Between Sqrt and Linear. A moderate middle ground.
• Exponent 1.0 — Identical to Linear.
• Exponent 1.5 — Accelerating returns. Points grow faster than the source. Use with extreme caution — this can quickly produce astronomical point counts.

Example: base = 1,000,000 (1M), scale = 1, exponent = 0.33 (cube root)

With a cube root curve, earning 10 points requires 1B source — compare to Sqrt where 1B gives 31 points, or Linear where 1B gives 1000. Cube root is the most restrictive standard curve, making it excellent for very deep prestige layers.

Choosing the Right Formula: A Decision Guide

Reset Rules in Depth

Reset rules are where prestige design gets nuanced. The difference between a prestige system that feels punishing and one that feels exciting often comes down to exactly what you reset and what you preserve. Here are the common patterns and when to use each one.

Pattern 1: Reset Everything (Nuclear Option)

Everything is wiped. Resources, generators, upgrades — all gone. The player starts from absolute zero with nothing but their permanent prestige bonuses. This is the classic Cookie Clicker approach and works well for single-layer prestige systems where the permanent bonus is strong enough to make the restart feel fast rather than tedious.

When to use: Simple, single-layer prestige. Games where each run should feel like a clean restart with a growing permanent advantage. Works best when your permanent bonus is at least +1% per point — enough that the player immediately notices the difference.

Pattern 2: Keep Upgrades (Soft Prestige)

Resources and generators are wiped, but upgrades are preserved. The player keeps all their purchased upgrades — multipliers, automation, unlocks — and only has to rebuild generators from scratch. This creates a much gentler prestige cycle because the early game is trivialized by the surviving upgrades. The player does not have to re-buy "Double Mining" every run; they only have to rebuild their generator levels.

When to use: When you want prestige to feel relatively painless. Good for casual games or as the first (softest) layer in a multi-layer system. Players who hate losing progress respond well to this pattern because their upgrade investments persist. The downside is that runs become very samey after a few prestiges — re-buying generators in the same order each time. Consider adding a deeper prestige layer that eventually wipes upgrades too for long-term variety.

Pattern 3: Reset Specific Generators Only

Only specific generators and resources are reset. Others are left untouched. This lets you create "tier-based" prestige where early-game content resets but late-game content is preserved. In the example above, the three basic generators reset but later generators (IRON_MINE, GEM_CAVE, etc.) keep their levels. This rewards players who invested in late-game content by not making them re-buy it each cycle.

When to use: Games with clear tiers or zones where early content becomes irrelevant. Factory games where basic resource extractors reset but advanced fabricators persist. RPG idle games where training grounds reset but high-level dungeons keep their clear count.

Pattern 4: Selective Upgrade Reset with Flags

One of the most elegant patterns is to use a custom flag property on your upgrades — something like "Resets On Prestige" (a boolean flag defined in the Upgrade Forge's Step 2). Then in your game's prestige logic, you read that flag to decide which upgrades to wipe. The Prestige Forge reset rules handle the broad strokes (ALL or specific codes), and your runtime code uses the flag for fine-grained control.

For example, you might set "Resets On Prestige" to true on all basic production multipliers but false on automation upgrades and premium purchases. When prestige fires and resets ALL upgrades, your runtime checks the flag and re-applies the ones that should survive. This gives you maximum flexibility without needing to list every individual upgrade code in your reset rules.

Pattern 5: Non-Zero Reset Values

Reset rules default to resetting things to zero, but you can set the "Reset To Value" to any number. This opens up creative possibilities:

• Starting Gold: Reset GOLD to 100 instead of 0. Each prestige run starts with 100 Gold, enough to immediately buy the first generator. This removes the awkward "click for 30 seconds to earn your first generator" phase that makes early prestige runs feel tedious.
• Generator head starts: Reset PEASANT_HUT to 5 instead of 0. Each run starts with 5 Peasant Huts already purchased, immediately producing resources. This accelerates the early game without changing the late-game dynamics.
• Partial upgrade resets: If you have a repeatable upgrade with purchase counts, you could reset it to 5 instead of 0, preserving some of the player's investment while still requiring them to rebuild toward higher levels.

Tips for Prestige Design

Prestige is the make-or-break mechanic for idle game longevity. Get it right and your game has hundreds of hours of engaging content. Get it wrong and the reset feels like punishment instead of progression. Here are design principles drawn from the most successful idle games ever made.

First Prestige at 30-60 Minutes of Play

The first time a player encounters the prestige option, it should feel like a discovery — a new dimension of the game opening up. If the first prestige takes 5 hours to reach, most players will quit before they ever see it. If it takes 5 minutes, it feels trivial and unearned. The sweet spot for most idle games is 30 to 60 minutes of active play before the first prestige becomes available.

Use the formula preview slider in the wizard to verify this. Set your minimum-to-prestige threshold at the resource amount you expect the player to reach after about 30 minutes of play. Then check that the formula awards enough points to feel meaningful — at least 1, ideally 2-5 on the first prestige. A first prestige that awards 0 points is a broken prestige. A first prestige that awards 50 points means your base is too low.

The Permanent Bonus Must Feel Impactful

The entire prestige loop depends on the player feeling a tangible difference after resetting. If they prestige, earn 3 points, and cannot tell the difference in their production rates, the reset felt like pure loss. The bonus must be noticeable immediately after resetting.

A +1% global production bonus per prestige point is a solid starting point for Sqrt formulas. After the first prestige with 3 points, the player has +3% production — enough to notice that generators are producing faster than they did on the first run. After 10 prestiges with 50 total points, the player has +50% — everything is 1.5x faster. After many more prestiges with 200 points, the player has +200% — everything is 3x faster. The progression feels satisfying at every stage.

For AddFlat bonuses, the per-unit value should be meaningful relative to early-game production rates. "+5 base Gold per prestige point" means 10 points gives +50 Gold/sec before any multipliers, which should feel significant if the first generator produces 1 Gold/sec.

Sqrt Is the Safe Default

If you are building your first idle game or designing your first prestige layer, use the Sqrt formula. It is the industry standard for a reason: the diminishing returns naturally prevent power from spiraling out of control, while still feeling rewarding enough that players want to prestige again. You can always switch to a different formula later if playtesting reveals that Sqrt is too slow or too fast, but it is the safest starting point.

Each Deeper Layer Should Take Much Longer

In a multi-layer prestige system, the timescale should expand dramatically with each layer. A good rule of thumb:

• Layer 1: 30-60 minutes to first prestige. Player does many of these per play session.
• Layer 2: Several hours to first prestige (after many Layer 1 resets). Might happen once or twice per play session.
• Layer 3: Days of accumulated play to reach. A major milestone when it happens.
• Layer 4: Weeks. An endgame aspiration that dedicated players work toward over a long period.

This expanding timescale keeps the game interesting across its entire lifespan. Layer 1 provides frequent dopamine hits. Layer 2 provides medium-term goals. Layer 3 provides long-term aspirations. Each layer operates on its own rhythm, and the player always has something to work toward at every timescale.

The "Can I Prestige?" Moment Should Be Exciting

One of the most psychologically compelling moments in idle games is the transition from "I cannot prestige yet" to "I can prestige now." Design your game to make this moment visible and exciting. Show the player how many prestige points they would earn if they reset right now, and update that number in real time as their source resource grows. The tension between "I could prestige now for 5 points" and "but if I wait 10 more minutes I could get 7 points" is one of the most engaging decision points in the entire genre.

The minimum-to-prestige threshold should be set at a point where earning even 1 prestige point feels like a meaningful achievement. And once the player crosses that threshold, showing the potential reward growing as they continue playing creates a compelling "should I hold out for more?" decision that makes the game feel active even during what would otherwise be passive number-watching.

Consider the Post-Reset Experience

The first 30 seconds after a prestige reset are critical. If the player sits there watching a blank screen with zero of everything, they might feel regret and close the game. Design your post-reset experience to immediately engage the player:

• Use non-zero reset values to give a small starting resource amount
• If the player has automation upgrades that survive prestige, those generators should start auto-buying immediately
• Show the permanent bonus prominently — "Your Prestige Bonus: +47% all production" — so the player feels the power they earned
• Make early-game progression visibly faster than it was on the first run

The goal is for the player to think "wow, look how fast I am progressing this time" within seconds of resetting. That feeling validates the prestige decision and primes them for the next cycle.

Test Your Economy at Scale

The most common prestige design mistake is not testing what happens after many prestiges. Your prestige system might feel perfect at 10 points, but at 500 points the permanent bonus might be so large that the game breaks. Use the bonus preview slider in the wizard to check high point counts. If 500 prestige points gives +500% global production (6x everything), is your late-game economy designed for that? If 2000 points gives +2000% (21x everything), do your generator costs still scale fast enough to provide meaningful resistance?

The interplay between permanent bonuses and cost scaling is the fundamental tension of idle game design. Bonuses make production grow. Cost scaling makes generators more expensive. If bonuses grow faster than costs, the game breaks. If costs grow faster than bonuses, the player hits a wall. Finding the balance is what separates good idle games from great ones — and the preview tools in the wizard are designed to help you find that balance before you write a single line of code.

What Are Achievements?

Achievements are the global milestones that guide your players through your idle game and reward them for hitting goals. They are the targets that sit in the corner of the screen, quietly whispering "you're almost there" — and when they pop, they deliver a satisfying burst of progress that makes the player want to keep going.

"Earn 1,000,000 Gold." "Buy 100 Miners." "Prestige 5 Times." "Reach a production rate of 10M per second." Every successful idle game is packed with these. They serve three critical purposes in your game's design:

• They guide players toward goals. A new player who opens your game and sees "Earn 1,000 Gold" immediately knows what to do next. A mid-game player who sees "Buy 25 of every generator" has a clear target to work toward. Achievements are implicit tutorials — they teach players how to engage with your systems without a single line of tutorial text.
• They reward exploration. Players who stumble into a hidden achievement get a dopamine hit that makes them wonder what else is hiding in your game. "Wait, there's a secret for reaching level 100 on my first generator without buying upgrades? What other secrets are there?" That curiosity drives engagement deeper than any explicit reward system.
• They provide long-term structure. When the immediate loop of "buy generator, earn resources, buy more generators" starts to feel routine, achievements provide a meta-layer of goals that keep the player invested. Tier progressions like "Earn 1K → 100K → 10M → 1B Gold" give players a sense of how far they have come and how far they can still go.

In Simple Idle Forge, achievements come in three flavors:

• Visible achievements — the player can see the target and track their progress toward it. These are your standard milestones. "Earn 1M Gold" shows up in the achievement list, and the player can watch their gold count climb toward the goal.
• Hidden achievements — secret milestones that are not revealed until the player earns them. The achievement list might show "???" or nothing at all, and when the player accidentally meets the condition, the achievement pops with a surprise. These are your easter eggs, your skill challenges, your discovery moments.
• Repeatable achievements — milestones that reset after completion and can be earned again. These are perfect for daily challenges, weekly goals, or prestige-based milestones that count up every time the player restarts. "Prestige 1 time" can be earned again and again, with the reward stacking each time.

The Achievement Forge gives you a complete wizard for defining all three types. You set the condition (what triggers the achievement), the rewards (what the player gets), and the flags (hidden, repeatable, or both). The toolkit handles the rest — checking conditions, granting rewards, tracking completion state, and providing events for your UI to react to.

Opening the Achievement Forge

In the Unity Editor, go to Window → Living Failure → Simple Idle Forge → Achievement Forge. The wizard window opens with Step 1 (Setup) displayed, ready for you to name your achievement database and pick a genre template.

The Achievement Forge is the fifth and final forge in the chain. It sits at the top of the dependency hierarchy — achievements can check conditions against resources, generators, upgrades, and prestige layers, which means it links to all four other database types. This makes it the most connected forge in the toolkit, and the one you typically build last after your game's economy, progression, and prestige systems are already in place.

Linking Databases

The Achievement Forge links to all four other database types in your project:

• Resource Databases — so achievement conditions can check resource amounts ("Reach 1M Gold") and rewards can grant resources ("Give 10,000 Gems")
• Generator Databases — so conditions can check generator levels ("Get your Blacksmith to level 50") and total generator counts ("Own 500 generators across all types")
• Upgrade Databases — so conditions can check whether specific upgrades have been purchased ("Buy the Auto-Miner upgrade")
• Prestige Databases — so conditions can check prestige counts ("Prestige 3 times") and rewards can reference prestige currencies

You link databases in Step 1 (Setup) of the wizard. Each database type has its own section with a list where you drag-and-drop or add your generated databases. The forge validates each one to make sure it implements the correct interface, detects duplicates, and shows you a count of how many codes it found in each database.

Once your databases are linked, every dropdown in the Builder step that asks for a resource code, generator code, upgrade code, or prestige code will be populated with the actual entries from your databases. No typing codes from memory, no copy-paste errors, no typos that break at runtime.

The 5 Steps

Like every forge in Simple Idle Forge, the Achievement Forge walks you through five steps from naming your database to generating your final game data. The tab bar at the top of the wizard shows all five steps, and you can click any step to jump directly to it.

The Builder in Detail

The Builder (Step 3) is the heart of the Achievement Forge. This is where every achievement in your game takes shape. The right-side detail panel is organized into collapsible sections, each handling a different aspect of the achievement.

Identity

Every achievement starts with four identity fields:

• Code — a unique string identifier used in code and data references. This is what the runtime uses to look up the achievement. Keep it short, descriptive, and consistent. Examples: GOLD_1M, GEN_MINER_50, PRESTIGE_FIRST, SECRET_NO_UPGRADES.
• Name — the display name shown to the player. "Gold Rush", "Mining Mogul", "Born Again", "The Purist".
• Description — a longer text explaining what the player needs to do. "Accumulate 1,000,000 Gold", "Reach level 50 on your Gold Mine", "Complete your first Prestige", "Reach level 100 on any generator without purchasing any upgrades".
• Icon — an optional sprite reference for the achievement's visual representation in your UI.

Condition

The condition defines what triggers this achievement. It is the rule the game checks to decide whether the player has earned it. Every condition has four fields that work together:

Condition Type

This determines what kind of thing the game checks. There are seven condition types, each designed for a different pillar of your idle game:

Condition Code

This specifies which resource, generator, upgrade, prestige layer, or achievement the condition checks. The dropdown is context-dependent — it only shows codes that make sense for the selected condition type:

• If the condition type is ResourceAmount, the dropdown lists all resource codes from your linked resource databases (GOLD, GEMS, WOOD, etc.)
• If the condition type is GeneratorLevel, the dropdown lists all generator codes from your linked generator databases (PEASANT_HUT, LUMBER_MILL, etc.)
• If the condition type is UpgradePurchased, the dropdown lists all upgrade codes from your linked upgrade databases (DOUBLE_GOLD, AUTO_MINERS, etc.)
• If the condition type is PrestigeCount, the dropdown lists all prestige layer codes from your linked prestige databases (REBIRTH, ASCENSION, etc.)
• If the condition type is TotalGenerators, no code is needed — the condition checks the combined total across all generators
• If the condition type is TotalProduction, the dropdown lists resource codes so you can specify which resource's production rate to check
• If the condition type is MilestoneCompleted, the dropdown lists other achievement codes from the current wizard (so you can chain achievements)

If you have companion forge packages installed (Simple Quest Forge, Simple Enemy Forge, etc.), their codes also appear in the appropriate dropdowns, prefixed with their source forge ([SQF], [SEF], [SSF], [SIF]) so you can tell at a glance where each code comes from.

Comparison

This determines how the player's current value is compared to the threshold. Six comparison operators are available:

Most achievements use "Greater or Equal" — the player needs to reach or exceed a target. But the other operators let you design creative challenges. "Beat the game with 0 upgrades purchased" is an Equals check. "Never let your Gold exceed 1,000" is a Less or Equal check that rewards constraint-based play.

Condition Value

The numeric threshold that the comparison checks against. This is a double value, so it supports the massive numbers that idle games produce. Set it to 1000000 for "reach 1M", 50 for "reach level 50", 5 for "prestige 5 times", or 1 for "purchase this upgrade at least once".

Because Simple Idle Forge uses double-precision numbers throughout, your condition values can go as high as your game's economy demands. "Reach 1.5 Quadrillion Gold" is just as valid as "Reach 100 Gold" — the comparison works identically at any scale.

Achievement Flags

Two toggles control the achievement's visibility and repeatability:

Is Hidden

When this flag is enabled, the achievement is a secret. It does not appear in the player's achievement list until they earn it. Your UI can show a placeholder ("???") or hide the entry entirely — that is your design choice. The point is that the player does not know the condition until they stumble into it.

Hidden achievements are perfect for:

• Easter eggs — "Click the logo 50 times"
• Skill-based challenges — "Reach level 100 on your first generator without buying any upgrades"
• Discovery moments — "Find the secret resource hidden behind the prestige menu"
• Narrative surprises — "Witness the Dragon Lair's special event"

The Builder's list view on the left panel shows a [Hidden] prefix on any achievement with this flag enabled, so you can always tell which ones are secrets while you are building your database.

Is Repeatable

When this flag is enabled, the achievement resets after completion and can be earned again. The runtime tracks how many times it has been completed, and the reward is granted each time. This is fundamentally different from a one-time achievement — it creates an ongoing goal that the player can pursue repeatedly.

Repeatable achievements are perfect for:

• Daily login rewards — "Play for 10 minutes today"
• Weekly challenges — "Earn 100M Gold this week"
• Prestige milestones — "Prestige 1 time" (earnable every time the player prestiges)
• Recurring skill checks — "Reach 1B production rate" (earnable after each prestige reset)

An achievement can be both hidden and repeatable. A hidden repeatable is a secret recurring challenge — the first time the player earns it, the secret is revealed, and from then on they know the condition and can pursue it again.

Rewards

Every achievement can grant multiple rewards when completed. This is not a single prize — it is a list of rewards, and you can add as many as you want. An achievement for reaching 1M Gold might grant 10,000 Gems, a permanent +5% production bonus, and unlock a new generator all at once.

Each reward in the list has five fields:

The Builder provides quick preset buttons that add common reward configurations in one click:

• Grant 1K Gold — adds a ResourceGrant reward with a value of 1000
• +10% Production — adds an AddPercent reward targeting Global with a value of 0.1
• x2 Multiplier — adds a Multiply reward targeting Global with a value of 2.0

These presets give you a starting point that you can customize. Change the target code, adjust the value, modify the description — the preset just saves you from building the reward from scratch every time.

Dynamic Properties

Below the rewards section, the Builder shows foldable sections for each of the custom property types you defined in Step 2 (Definitions). If you created a "Tier" category with Bronze/Silver/Gold/Platinum entries, each achievement will have a Tier dropdown. If you created a "Point Value" numeric, each achievement will have a number field for it. These properties are fully queryable at runtime — you can filter achievements by tier, sort by point value, or display flavor text in your UI.

Hidden and Repeatable Achievements

These two flags deserve special attention because they fundamentally change how an achievement behaves in your game. Understanding when and how to use them is key to designing an achievement system that feels rewarding and keeps players engaged over the long term.

Hidden Achievements — The Art of Surprise

A hidden achievement is invisible to the player until they earn it. Your achievement UI might show a locked icon with "???" text, or it might hide the entry entirely so the player does not even know it exists. Either approach works — the important thing is that the player cannot see the condition in advance.

This creates a fundamentally different engagement pattern. Standard achievements are goals — the player sees the target and works toward it. Hidden achievements are discoveries — the player does something unusual or impressive and is surprised by a reward they did not expect. That surprise creates a powerful emotional moment that standard achievements cannot match.

Great uses for hidden achievements:

• Easter eggs: "Click the title screen logo 50 times." Players who find these feel like they discovered a secret, and they tell other players about it.
• Skill challenges: "Reach level 100 on your first generator without buying any upgrades." This rewards players who experiment with unusual strategies.
• Speed runs: "Reach 1M Gold within 5 minutes of starting." A time-based challenge that rewards efficient play.
• Negative conditions: "Go bankrupt — reach exactly 0 of every resource." Sometimes the most interesting achievements reward failure.
• Cross-system mastery: "Own at least 1 of every generator type." This encourages players to explore your entire production chain instead of stacking one generator.

A good rule of thumb: make 10–20% of your achievements hidden. Enough to create a sense of mystery, but not so many that the visible achievement list feels empty.

Repeatable Achievements — Ongoing Engagement

A repeatable achievement resets after completion. The player earns it, gets the reward, and the achievement becomes available to earn again. The runtime tracks the completion count, so you know how many times the player has earned it.

This is a powerful tool for ongoing engagement, but it requires careful reward design. If a repeatable achievement grants a permanent x2 multiplier every time, the game breaks after the third completion. Repeatable rewards should be either small and incremental ("+1% production per completion") or resource grants that get absorbed into the economy ("Grant 10K Gold each time").

Great uses for repeatable achievements:

• Daily login targets: "Play for 10 minutes today." Resets every day, grants a small resource bonus each time. Encourages daily return habits.
• Weekly challenges: "Earn 100M Gold this week." Larger goals with larger rewards on a weekly cycle. Creates a reason to come back even after the player has "beaten" the main progression.
• Prestige milestones: "Complete a prestige." Earnable every time the player prestiges. The reward can be a small prestige currency bonus on top of the standard prestige reward, making each prestige feel slightly more valuable.
• Cumulative challenges: "Earn 1B Gold total (lifetime)." The condition checks a lifetime statistic that keeps growing across prestiges. Each time the player crosses a new billion, the achievement triggers again.

In the Builder's list view, repeatable achievements do not get a visual prefix (unlike hidden achievements, which show [Hidden]). You can identify them by selecting the entry and checking the flags section. If you want to sort or filter by repeatability, add a custom flag property in the Definitions step.

Tips for Achievement Design

A well-designed achievement system is one of the most effective retention tools in an idle game. Here are practical guidelines for making yours great.

Create Achievement Tiers

The most effective achievement structure is a tiered progression where each milestone is a stepping stone to the next. Instead of one achievement for "Earn Gold", create a chain:

Each tier gives the player a visible next goal. When they earn "Gold Collector", they immediately see "Gold Hoarder" as the next target. This creates a natural progression that guides players through your game's economy scaling. The reward percentages should increase with each tier — later tiers are exponentially harder to reach, so they deserve proportionally larger bonuses.

Mix Your Condition Types

Do not make every achievement about resource amounts. A balanced achievement system uses all seven condition types to touch every part of your game:

• Resource milestones — "Reach 1M Gold", "Accumulate 100K Gems"
• Generator milestones — "Get any generator to level 50", "Own 25 Iron Mines"
• Upgrade milestones — "Purchase your first upgrade", "Buy all automation upgrades"
• Prestige milestones — "Complete your first prestige", "Prestige 10 times"
• Production milestones — "Reach 1M Gold per second", "Hit 1B total production"
• Total generator milestones — "Own 100 generators total", "Own 1,000 generators total"
• Chain milestones — "Complete all beginner achievements", "Earn every Bronze tier reward"

This variety ensures that no matter what the player is doing in your game, there is always an achievement nearby that recognizes their progress. A player who is focused on upgrading their generators should find generator-related achievements within reach. A player who just prestiged should see a prestige achievement pop.

Give Meaningful Rewards

An achievement without a meaningful reward is just a notification. Players should want to pursue your achievements, not just passively earn them. Every achievement should grant something that makes the player tangibly more powerful or gives them something they can use.

• Early game: Resource grants are most impactful. "Grant 5,000 Gold" when the player is earning 10 Gold per second is a massive windfall that accelerates them into the next phase of your game.
• Mid game: Percentage bonuses start to shine. "+10% production" on top of an established economy gives a noticeable boost without being game-breaking.
• Late game: Multipliers become the prize. "x1.5 all production" is the kind of reward that makes a late-game player's eyes light up, because it multiplies everything they have built.
• Endgame: Unlocks and prestige currency grants keep things interesting when raw numbers have lost their impact. "Unlock the secret generator" or "Grant 100 Prestige Points" gives the player something new to interact with.

Hide a Few Secrets

Every achievement system benefits from a handful of hidden achievements that reward unexpected behavior. These create watercooler moments — players discover them, feel special, and share the discovery with others. You do not need many. Three to five hidden achievements in a set of thirty is enough to create a sense that there is always more to discover.

The best hidden achievements reward behavior that the player might try on their own: "What happens if I buy 100 of the cheapest generator?", "What if I never buy any upgrades?", "What if I prestige with exactly 0 Gold?" Reward the experimenters and the curious.

Use Repeatables for Daily and Weekly Hooks

Repeatable achievements are your engagement hooks. They give players a reason to open the game today, not just "eventually." Frame them as daily or weekly challenges with modest but consistent rewards. A player who knows they get 5,000 Gems every day for playing 10 minutes will build a habit of opening the game daily. That daily habit is worth more to retention than any one-time reward, no matter how large.

Aim for 20–50 Achievements Per Game

Too few achievements and the system feels like an afterthought. Too many and the list overwhelms the player. The sweet spot for most idle games is between 20 and 50 achievements in total.

• 20 achievements — enough for a focused, tight game. Covers the major milestones for each resource, a handful of generator targets, a few prestige goals, and 2–3 hidden secrets.
• 30–40 achievements — the ideal range for most projects. Gives you room for tiered progressions, condition variety, some repeatables, and a good set of secrets. All four included demo games fall in this range.
• 50 achievements — the upper end for a single achievement database. Beyond this, consider splitting into multiple databases (e.g., one for resource achievements, one for combat achievements, one for prestige achievements) to keep each list manageable.

The JSON Content Pipeline

Every forge in Simple Idle Forge can export its structure as JSON and import entries from JSON. This means you can create game content outside the Unity Editor — using spreadsheets, text editors, scripting tools, or any workflow that outputs JSON — and import it directly into your game databases. No manual data entry, no clicking through dozens of fields one at a time, no copy-paste errors.

This is not a minor convenience feature. It is the fastest way to build an idle game. Think about what goes into a typical incremental game: 10–20 resources, 15–30 generators each with multi-resource costs and production rates, 30–50 upgrades with prerequisites and effect configurations, multiple prestige layers with reset rules and permanent bonuses, and 30–50 achievements with conditions and rewards. That is hundreds of individual entries, each with multiple fields that need to be filled out correctly and consistently.

The JSON pipeline turns that from hours of manual work into a structured, repeatable process. You export your schema once to understand the format. You generate your entries in whatever environment you are most productive in — a spreadsheet, a text editor, a scripting language, or any external tool that can produce JSON. Then you import the result, validate it, and generate your database. Done.

All four demo games included with Simple Idle Forge were built this way. Simple Kingdom (45+ entries), Factory Tycoon (70+ entries), Survival Idle (80+ entries), and RPG Idle (95+ entries) — every resource, generator, upgrade, prestige layer, and achievement was created through the JSON pipeline and imported into the forge wizards. The JSON source files are included in the package so you can study the exact format that produced complete, playable idle games.

Three Export Formats

Each forge's Definitions step (Step 2) has export buttons for three formats. Each format serves a different purpose, and you will likely use all three at different points in your workflow.

The Database Export Window

In addition to the per-forge export buttons in Step 2, Simple Idle Forge includes a standalone utility window for exporting generated databases. You will find it at Window → Living Failure → Simple Idle Forge → Export Database.

The Database Export Window works differently from the wizard export buttons. While the wizard buttons export from your wizard data (the entries you are still editing), the Database Export Window exports from your generated database — the final, compiled asset that your game reads at runtime. This is useful in several situations:

• Backing up your work. After generating a database, export it as JSON so you have a portable copy of your final data that is not tied to Unity's asset format.
• Sharing between projects. Export a database from one Unity project, carry the JSON file to another project, and import it into a fresh forge wizard there. Your entire database travels as a single text file.
• Auditing your data. Sometimes you want to see exactly what the generated database contains after generation — every field, every array, every nested structure — in a format you can search through and verify.
• Version control. JSON files diff cleanly in Git, SVN, and every other version control system. Export your database as JSON and commit it alongside your project, and you get a human-readable history of every change to your game data over time.

Using the window is straightforward. Drag any generated database asset into the database field. The window auto-detects which type of database you have assigned — Resource, Generator, Upgrade, Prestige, or Achievement — and configures the export accordingly. Choose your output path, click Export, and the JSON file is written to disk.

Importing JSON

Getting content back into the forge is just as streamlined as getting it out. Each forge's Definitions step (Step 2) has an import button that opens the import dialog. From there, the process is designed to be fast and forgiving — the toolkit catches mistakes before they become problems.

JSON Structure

Understanding what the JSON looks like makes it easy to create entries in any tool. The format is straightforward — flat objects with clearly named fields. Here is what a resource entry looks like:

Resource Entry

{
  "code": "GOLD",
  "name": "Gold",
  "description": "The primary currency of the realm",
  "startingAmount": 0,
  "maxCap": 0,
  "capMode": "None",
  "displayFormat": "Short",
  "displayPrecision": 0,
  "categories": [{"name": "Resource Type", "value": "Currency"}],
  "flags": [{"name": "Persists Through Prestige", "value": false}],
  "numerics": [{"name": "Display Order", "value": 1}],
  "texts": [{"name": "Short Name", "value": "G"}]
}

Every resource entry has a code (the unique identifier used by every other forge to reference this resource), a name (the display name players see), and a description. The startingAmount is what the player begins with. The maxCap sets an upper limit (0 means unlimited). The capMode controls what happens as a resource approaches its cap — None, Hard (stops at cap), Flat (reduced rate near cap), Curve (smooth falloff), or Step (tiered efficiency thresholds). The displayFormat determines how numbers are shown — Short uses K/M/B/T suffixes, Scientific uses exponential notation, Full shows the complete number. The displayPrecision controls decimal places.

The four arrays at the bottom — categories, flags, numerics, and texts — are your custom dynamic properties. Their names and available values come from whatever you defined in Step 2 of the Resource Forge. If you defined a "Resource Type" category with options like "Currency", "Premium", and "Material", then each entry specifies which option applies. These properties let you filter, sort, and query your data at runtime in ways that are specific to your game.

Generator Entry

{
  "code": "MINE",
  "name": "Gold Mine",
  "description": "Digs for gold deep underground",
  "maxLevel": 0,
  "productionMode": "Continuous",
  "productionInterval": 1.0,
  "production": [
    {"resourceCode": "GOLD", "baseAmountPerSecond": 1.5}
  ],
  "costs": [
    {
      "resourceCode": "GOLD",
      "baseAmount": 15,
      "scalingType": "Exponential",
      "scalingFactor": 1.15
    }
  ],
  "prerequisites": [],
  "milestones": [
    {
      "levelThreshold": 25,
      "bonusType": "Multiply",
      "bonusValue": 2.0,
      "bonusDescription": "x2 Gold production"
    }
  ]
}

Generator entries are richer because they define the core economic engine of your game. The production array lists every resource this generator produces and how much per second at base level. The costs array lists every resource it costs to buy, with a base amount and a scaling formula. In this example, the Gold Mine costs 15 gold at level 1 and scales exponentially with a factor of 1.15 — the same formula Cookie Clicker uses. At level 10, that cost becomes roughly 61 gold. At level 50, it is about 16,367 gold. The interactive preview sliders in the wizard show you these exact numbers before you generate.

The productionMode field determines how the generator produces resources. Continuous means resources flow every tick (like Cookie Clicker). Timer means resources arrive in batches after a countdown (like Adventure Capitalist), and the productionInterval sets how many seconds each cycle takes.

The prerequisites array defines conditions that must be met before the generator becomes available — reach a certain resource amount, level up another generator, purchase a specific upgrade. The milestones array defines level thresholds that grant bonuses — at level 25, this mine doubles its gold production.

The same pattern applies to upgrade, prestige, and achievement entries. Each has a code, a name, its type-specific fields (effects for upgrades, formulas for prestige, conditions for achievements), and dynamic property arrays. The Light JSON export from each forge gives you the complete field reference for that forge's entry type.

The Demo Game Pipeline

All four demo games included with Simple Idle Forge were created using the exact JSON pipeline described on this page. Not some of the content — all of it. Every resource, every generator, every upgrade, every prestige layer, and every achievement in every demo was authored as JSON, imported into the forge wizards, and generated into playable databases. Here is how that pipeline works, step by step.

The JSON source files for all four demos are included in the package so you can study them. They are real production data — the same files that produced the playable games you can run in the demo scenes. Open them, read the structure, see how resources reference each other, how costs scale, how prestige layers chain together. These files are the best reference for learning the JSON format, because they are not simplified examples — they are complete, working game economies.

Batch Icon Assignment

Once your databases are generated, you will probably want to assign icons to your entries. If you have a handful of entries, dragging sprites one by one in the Inspector is fine. But if you have 30 generators, 50 upgrades, and 40 achievements, that becomes tedious fast. The Batch Icon Assignment window handles this in bulk.

Open it at Window → Living Failure → Simple Idle Forge → Batch Icon Assignment.

Tips for the JSON Pipeline

After building four complete demo games with this pipeline, here are the practices that make the workflow smooth and reliable.

Export Your Schema First

Before you create a single entry, open the forge wizard, set up your property definitions in Step 2, and export in Light mode. This gives you a clean template that shows exactly what fields are available, what types they expect, and what enum values are valid. Use this template as the reference for all your content generation. Every field name, every valid value, every nested structure is documented in the export. You never have to guess.

Use Consistent Naming

Stick to UPPER_SNAKE_CASE for codes (GOLD_MINE, FIRE_SWORD, PRESTIGE_RESET) and Title Case for display names ("Gold Mine", "Fire Sword", "Prestige Reset"). Codes are identifiers that the system uses internally — they need to be unique, predictable, and easy to reference in other entries. Display names are what players see — they should read naturally. Keeping these two conventions separate prevents confusion when cross-referencing between forges.

Group Related Entries

Organize your JSON files so that related entries sit together. Put all your currency resources in one block, all your crafting materials in another, all your prestige currencies in a third. Put early-game generators before mid-game generators before late-game generators. This makes the file easier to read, easier to review for balance, and easier to update when you need to adjust a tier of content. The import does not care about order, but your future self will appreciate the organization.

Validate Before Importing

The import tool catches errors, but it is faster to get things right before you import. Common mistakes include mistyped resource codes (the generator references GOLDD instead of GOLD), invalid enum values (writing Exponetial instead of Exponential), and missing commas in JSON arrays. A quick syntax check in your text editor or a JSON validator catches these instantly. The import tool will catch them too — it just takes an extra round trip.

Keep Your Source Files

Your JSON files are your content source of truth. Keep them alongside your Unity project, check them into version control, and treat them as first-class project assets. If you ever need to regenerate your databases (because you changed a property definition, or you are moving to a new Unity project, or you accidentally deleted a generated asset), the JSON files let you rebuild everything from scratch in minutes. The forge wizards and generated databases are outputs. The JSON files are the inputs you cannot afford to lose.

Iterate in Small Batches

You do not need to import your entire game at once. Start with resources and a few generators. Import, generate, play, and see how it feels. Then add more generators, import your upgrades, test again. Then prestige, then achievements. Small batches let you catch balance issues early and keep each import manageable. The four demo games were all built incrementally — resources first, then generators, then layer by layer until the complete economy was in place.

Getting Started with Code

This page is for developers who want to write C# code to integrate Simple Idle Forge's runtime components into their game. If you are using the no-code wizard workflow exclusively, you do not need this page — the forges handle everything. But if you want custom game controllers, UI integration, save/load systems, or advanced features, this is your complete reference.

All runtime classes are pure C# — not MonoBehaviours. You create them in your own game controller and manage their lifecycle. Every class lives in the SimpleIdleForge namespace.

The Basic Game Controller Pattern

Here is the standard pattern for wiring everything together. Your MonoBehaviour holds references to the generated ScriptableObject databases (assigned in the Inspector), creates the runtime trackers in Start(), and ticks them in Update().

using SimpleIdleForge;
using UnityEngine;
using System;
using System.Collections.Generic;

public class MyIdleGame : MonoBehaviour
{
    [Header("Databases")]
    public ScriptableObject[] resourceDatabases;
    public ScriptableObject[] generatorDatabases;
    public ScriptableObject[] upgradeDatabases;
    public ScriptableObject[] prestigeDatabases;
    public ScriptableObject[] achievementDatabases;

    IdleResourcePool resourcePool;
    IdleGeneratorManager generatorManager;
    IdleUpgradeTracker upgradeTracker;
    IdlePrestigeManager prestigeManager;
    IdleMilestoneTracker milestoneTracker;
    List<IdleBonus> bonusCache = new List<IdleBonus>();

    void Start()
    {
        // Cast databases to interfaces
        var resSources = new List<IIdleResourceDataSource>();
        foreach (var db in resourceDatabases)
            if (db is IIdleResourceDataSource src) resSources.Add(src);

        var genSources = new List<IIdleGeneratorDataSource>();
        foreach (var db in generatorDatabases)
            if (db is IIdleGeneratorDataSource src) genSources.Add(src);

        var upgSources = new List<IIdleUpgradeDataSource>();
        foreach (var db in upgradeDatabases)
            if (db is IIdleUpgradeDataSource src) upgSources.Add(src);

        var presSources = new List<IIdlePrestigeDataSource>();
        foreach (var db in prestigeDatabases)
            if (db is IIdlePrestigeDataSource src) presSources.Add(src);

        var mileSources = new List<IIdleMilestoneDataSource>();
        foreach (var db in achievementDatabases)
            if (db is IIdleMilestoneDataSource src) mileSources.Add(src);

        // Initialize trackers
        resourcePool = new IdleResourcePool();
        resourcePool.Initialize(resSources);

        generatorManager = new IdleGeneratorManager();
        generatorManager.Initialize(genSources);

        upgradeTracker = new IdleUpgradeTracker();
        upgradeTracker.Initialize(upgSources);

        prestigeManager = new IdlePrestigeManager();
        prestigeManager.Initialize(presSources);

        milestoneTracker = new IdleMilestoneTracker();
        milestoneTracker.Initialize(mileSources);

        // Apply starting amounts
        foreach (var code in resourcePool.GetAllCodes())
        {
            var def = resourcePool.GetDefinition(code);
            if (def.HasValue && def.Value.startingAmount > 0)
                resourcePool.SetAmount(code, def.Value.startingAmount);
        }
    }

    void Update()
    {
        float dt = Time.deltaTime;

        // Collect global bonuses from all sources
        bonusCache.Clear();
        upgradeTracker.CollectBonusesForTarget("", bonusCache);
        prestigeManager.CollectBonusesForTarget("", bonusCache);
        milestoneTracker.CollectBonusesForTarget("", bonusCache);

        // Tick generators (produces resources)
        generatorManager.Tick(dt, resourcePool, bonusCache);

        // Auto-collect timer generators
        foreach (var code in generatorManager.GetAllCodes())
        {
            if (generatorManager.IsTimerReady(code))
                generatorManager.CollectTimer(code, resourcePool, bonusCache);
        }

        // Periodically check conditions (every 0.5s, not every frame)
        generatorManager.CheckUnlockConditions(GetValueProvider());
        milestoneTracker.CheckAll(GetValueProvider(), resourcePool);
    }

    Func<IdleConditionType, string, double> GetValueProvider()
    {
        return (type, code) =>
        {
            switch (type)
            {
                case IdleConditionType.ResourceAmount:
                    return resourcePool.GetAmount(code);
                case IdleConditionType.GeneratorLevel:
                    return generatorManager.GetLevel(code);
                case IdleConditionType.UpgradePurchased:
                    return upgradeTracker.GetPurchaseCount(code);
                case IdleConditionType.PrestigeCount:
                    return prestigeManager.GetPrestigeCount(code);
                default: return 0;
            }
        };
    }
}

The rest of this page documents every class, method, and event in detail.

IdleResourcePool

Tracks current resource amounts at runtime. Initialize with one or more databases, then add, remove, or set amounts. Respects caps and fires events on changes. This is the foundation — every other tracker interacts with it.

Namespace: SimpleIdleForge
Type: class (pure C#, not a MonoBehaviour)

Events

Methods

Usage Example

// Check if the player can afford a custom purchase
if (resourcePool.CanAfford("GOLD", 5000) && resourcePool.CanAfford("GEMS", 10))
{
    resourcePool.Remove("GOLD", 5000);
    resourcePool.Remove("GEMS", 10);
    // Grant the item...
}

// Or use the atomic multi-resource spend
var costs = new Dictionary<string, double> { { "GOLD", 5000 }, { "GEMS", 10 } };
if (resourcePool.TrySpendAll(costs))
{
    // Both resources deducted atomically
}

// Listen for events
resourcePool.OnResourceChanged += (code, oldVal, newVal) =>
{
    Debug.Log($"{code}: {oldVal} -> {newVal}");
    UpdateResourceUI(code, newVal);
};

resourcePool.OnCapReached += (code, cap) =>
{
    ShowNotification($"{code} is full! ({cap})");
};

// Cap efficiency query for UI
float efficiency = resourcePool.GetCapEfficiency("ENERGY");
// 1.0 = full production, 0.5 = half production, 0.0 = stopped

IdleGeneratorManager

Tracks generator levels, handles purchases, evaluates prerequisites, and ticks production. Supports both Continuous (per-frame) and Timer (batch) production modes. The workhorse of any idle game.

Namespace: SimpleIdleForge
Type: class (pure C#, not a MonoBehaviour)

Events

Methods

Important: CanAfford Signature

CanAfford takes a Func<string, double> delegate, not an IdleResourcePool directly. This keeps the generator manager decoupled from any specific resource source. The standard usage pattern is:

// Standard usage with IdleResourcePool
bool canBuy = generatorManager.CanAfford("MINE", code => resourcePool.GetAmount(code));

// Or with a shorthand lambda
bool canBuy = generatorManager.CanAfford("MINE", resourcePool.GetAmount);

Timer Production Example

Timer-mode generators (Adventure Capitalist style) produce in batches instead of continuously. Automated timers collect automatically. Non-automated timers wait for manual collection.

// Update timer progress bar UI
float progress = generatorManager.GetTimerProgress("STEEL_FOUNDRY");
mySlider.value = progress; // 0.0 to 1.0

// Check if timer batch is ready
if (generatorManager.IsTimerReady("STEEL_FOUNDRY"))
    generatorManager.CollectTimer("STEEL_FOUNDRY", resourcePool, bonusCache);

// Get effective interval (accounts for Speed bonuses)
double interval = generatorManager.GetEffectiveInterval("STEEL_FOUNDRY");
// Display: "12.0s per cycle" or faster with speed upgrades

Buy Max Example

// Buy as many levels as the player can afford
int levelsBought = generatorManager.BuyMax("MINE", resourcePool);
if (levelsBought > 0)
    Debug.Log($"Bought {levelsBought} levels of MINE");

// Or buy a specific number of levels
if (generatorManager.BuyLevels("MINE", 10, resourcePool))
    Debug.Log("Bought 10 levels of MINE");

IdleUpgradeTracker

Tracks upgrade purchase counts, evaluates prerequisites, handles cost deduction, and fires special events for Automate, Unlock, and ResourceGrant effect types. Supports both one-time and repeatable upgrades.

Namespace: SimpleIdleForge
Type: class (pure C#, not a MonoBehaviour)

Events

Methods

Purchase Example

string code = "MINE_BOOST";
if (!upgradeTracker.IsMaxed(code)
    && upgradeTracker.CanAfford(code, c => resourcePool.GetAmount(c))
    && upgradeTracker.ArePrerequisitesMet(code, GetValueProvider()))
{
    upgradeTracker.Purchase(code, resourcePool);
    // Costs deducted, effect applied, events fired
}

Selective Prestige Reset

// Reset all upgrades EXCEPT those targeting "PRESTIGE_POINTS"
upgradeTracker.ResetWhere(def => def.targetCode != "PRESTIGE_POINTS");

// Reset all upgrades except those with the Automate effect type
upgradeTracker.ResetWhere(def => def.effectType != IdleBonusType.Automate);

IdlePrestigeManager

Manages prestige layers: counts, total currency earned, reward calculations, reset rule execution, and permanent bonus collection. The prestige loop — reset progress in exchange for permanent bonuses — is the core progression mechanic of most idle games.

Namespace: SimpleIdleForge
Type: class (pure C#, not a MonoBehaviour)

Events

Methods

Prestige Example

double sourceAmount = resourcePool.GetAmount("GOLD");
if (prestigeManager.CanPrestige("REBIRTH", sourceAmount))
{
    double preview = prestigeManager.GetPotentialReward("REBIRTH", sourceAmount);
    // Show confirmation dialog: "Prestige for {preview} points?"

    double earned = prestigeManager.ExecutePrestige(
        "REBIRTH", resourcePool, generatorManager, upgradeTracker);
    // Resets applied, currency granted, permanent bonuses active

    Debug.Log($"Prestiged for {earned} points!");
}

// Check permanent bonus values
double prodBonus = prestigeManager.GetPermanentBonus("MINE", IdleBonusType.AddPercent);
Debug.Log($"MINE has +{prodBonus * 100}% permanent production bonus");

IdleMilestoneTracker

Tracks achievement and milestone completion. Evaluates conditions each tick, fires completion events, auto-grants ResourceGrant rewards, and collects bonus rewards for the bonus resolution pipeline. Supports both one-time and repeatable milestones, plus hidden (secret) achievements.

Namespace: SimpleIdleForge
Type: class (pure C#, not a MonoBehaviour)

Events

Methods

Achievement UI Example

// Display achievement progress in a UI panel
foreach (var code in milestoneTracker.GetAllCodes())
{
    var def = milestoneTracker.GetDefinition(code);
    if (!def.HasValue) continue;

    bool completed = milestoneTracker.IsCompleted(code);
    bool hidden = def.Value.isHidden && !completed;

    if (hidden)
    {
        // Show as "???" in the UI
        ShowHiddenAchievement();
    }
    else
    {
        double current = milestoneTracker.GetCurrentProgress(code, GetValueProvider());
        double target = def.Value.conditionValue;
        float ratio = target > 0 ? (float)(current / target) : 0f;
        ShowAchievement(def.Value.displayName, def.Value.description, ratio, completed);
    }
}

// Display completion stats
int done = milestoneTracker.GetCompletedCount();
int total = milestoneTracker.GetTotalCount();
achievementCountLabel.text = $"{done} / {total}";

IdleBuffManager

Manages temporary boosts with durations — ad rewards, consumable potions, event bonuses, and similar timed multipliers. Call Tick() each frame to expire buffs. Use CollectBonusesForTarget() to feed active buffs into the bonus resolution pipeline.

Namespace: SimpleIdleForge
Type: class (pure C#, not a MonoBehaviour)

Events

Methods

Buff Examples

// Apply 2x global production for 120 seconds (ad reward)
buffManager.ApplyBuff("ad_reward_2x", IdleTargetType.Global, "",
    IdleBonusType.Multiply, 2.0, 120f);

// Apply permanent +10% to a specific generator
buffManager.ApplyBuff("passive_mine_boost", IdleTargetType.Generator, "MINE",
    IdleBonusType.AddPercent, 0.1, 0f); // duration 0 = permanent

// Apply a Speed buff (makes Timer generators faster)
buffManager.ApplyBuff("speed_potion", IdleTargetType.Global, "",
    IdleBonusType.Speed, 0.5, 60f); // +50% speed for 60 seconds

// In Update loop
buffManager.Tick(Time.deltaTime);

// Include buffs in bonus collection
bonusCache.Clear();
upgradeTracker.CollectBonusesForTarget("MINE", bonusCache);
prestigeManager.CollectBonusesForTarget("MINE", bonusCache);
milestoneTracker.CollectBonusesForTarget("MINE", bonusCache);
buffManager.CollectBonusesForTarget("MINE", bonusCache);

// Display active buff timers in UI
foreach (var buff in buffManager.GetAllActiveBuffs())
{
    if (!buff.IsPermanent)
        ShowBuffTimer(buff.buffId, buff.remainingDuration, buff.Progress);
}

IdleProgressCalculator

This is THE killer feature. No other Asset Store package provides reusable offline progress calculation as a static utility.

Calculates offline earnings, current production rates, and time-to-afford estimates. All methods are static — no state, no initialization needed. Call on demand when the game loads, when the player returns from the background, or when the UI needs production rate data.

Namespace: SimpleIdleForge
Type: static class

Methods

Complete Offline Progress Example

// On game load — calculate what happened while away
float offlineSeconds = 3600f; // 1 hour away

// Get current production rates with all bonuses
var snapshot = IdleProgressCalculator.GetProductionSnapshot(
    generatorDatabase, generatorManager,
    upgradeTracker.CollectBonusesForTarget,
    prestigeManager.CollectBonusesForTarget,
    milestoneTracker.CollectBonusesForTarget);

// Configure offline efficiency (step-based diminishing returns)
var offlineConfig = new IdleOfflineEfficiency
{
    mode = IdleOfflineMode.Step,
    steps = new IdleOfflineStep[]
    {
        new IdleOfflineStep { hoursThreshold = 0, efficiency = 0.8f },   // First hour: 80%
        new IdleOfflineStep { hoursThreshold = 1, efficiency = 0.5f },   // 1-4 hours: 50%
        new IdleOfflineStep { hoursThreshold = 4, efficiency = 0.25f },  // 4-12 hours: 25%
        new IdleOfflineStep { hoursThreshold = 12, efficiency = 0.1f }   // 12+ hours: 10%
    }
};

// Calculate and apply
var report = IdleProgressCalculator.CalculateOfflineProgress(
    snapshot, offlineSeconds, offlineConfig, maxOfflineSeconds: 86400f);

if (report.HasProgress)
{
    IdleProgressCalculator.ApplyOfflineProgress(report, resourcePool);
    Debug.Log(report.formattedSummary);
    // "You were away for 1h 0m:\n+5.4K Gold\n+230 Wood"
}

// Time-to-afford for UI countdowns
string timeText = IdleProgressCalculator.GetTimeToAffordFormatted(
    "GOLD", 10000, resourcePool, snapshot);
// "2m 34s" or "Now" or "Never"

IdleProductionSnapshot

The snapshot returned by GetProductionSnapshot() contains production rates you can use directly in your UI:

// Display production rates
foreach (var kvp in snapshot.productionPerSecond)
{
    string rate = IdleNumberFormatter.FormatRate(kvp.Value);
    Debug.Log($"{kvp.Key}: {rate}"); // "GOLD: 1.5M/s"
}

// Get rate for a specific resource
double goldRate = snapshot.GetTotalRate("GOLD");

IdleProgressReport

The report returned by CalculateOfflineProgress() contains everything needed for the "welcome back" screen:

IdleAutoPurchaser

Handles automatic purchasing of generators and upgrades. Tracks which generators/upgrades are automated (from Automate-type upgrades), and supports a configurable global auto-buy strategy for generators. Processes purchases on a configurable tick interval, not every frame.

Namespace: SimpleIdleForge
Type: class (pure C#, not a MonoBehaviour)

Events

Methods

Auto-Purchaser Example

// Setup
var autoPurchaser = new IdleAutoPurchaser();
autoPurchaser.SetGeneratorStrategy(IdleAutoBuyStrategy.Cheapest);
autoPurchaser.SetTickInterval(0.5f); // check every 0.5 seconds

// Wire to upgrade tracker so Automate upgrades take effect automatically
autoPurchaser.WireToUpgradeTracker(upgradeTracker);

// In Update loop
autoPurchaser.Tick(Time.deltaTime, generatorManager, upgradeTracker, resourcePool);

// Listen for auto-purchases (for UI notifications)
autoPurchaser.OnAutoPurchased += (type, code) =>
{
    Debug.Log($"Auto-purchased {type}: {code}");
};

// On prestige: reset automation but keep strategy
autoPurchaser.ResetForPrestige();

IdleStatisticsTracker

Tracks cumulative lifetime statistics: total earned, total spent, peak amounts, purchase counts, prestige count, milestones completed, play time, and more. Wire it to all other trackers for automatic recording, or call Record methods manually. Useful for achievement conditions, stats UI, and analytics.

Namespace: SimpleIdleForge
Type: class (pure C#, not a MonoBehaviour)

Events

Methods

Properties

Additional Query Methods

Statistics Tracker Example

// Setup — wire to all trackers for automatic recording
var stats = new IdleStatisticsTracker();
stats.WireToTrackers(resourcePool, generatorManager, upgradeTracker,
    prestigeManager, milestoneTracker, buffManager);

// In Update loop
stats.Tick(Time.deltaTime);

// After offline progress is applied
stats.RecordOfflineTime(offlineSeconds);

// Display in Stats UI
statsText.text = $@"Play Time: {stats.FormattedPlayTime}
Total Gold Earned: {IdleNumberFormatter.Format(stats.GetTotalEarned("GOLD"))}
Peak Gold: {IdleNumberFormatter.Format(stats.GetPeakAmount("GOLD"))}
Generators Purchased: {stats.GetTotalGeneratorsPurchased()}
Upgrades Purchased: {stats.GetTotalUpgradesPurchased()}
Prestiges: {stats.TotalPrestigeCount}
Achievements: {stats.TotalMilestonesCompleted}";

Static Utilities

These static classes provide core calculations used throughout the system. You can also call them directly in your own code for UI formatting, cost previews, bonus resolution, and condition evaluation.

IdleNumberFormatter

Formats large numbers for idle game UI. Supports suffix notation (K/M/B/T/Qa/Qi/...), scientific notation, engineering notation, and full numbers with commas. Also formats time durations and per-second rates.

// Number formatting
IdleNumberFormatter.Format(1500)                              // "1.50K"
IdleNumberFormatter.Format(1500000)                           // "1.50M"
IdleNumberFormatter.Format(1.5e12)                            // "1.50T"
IdleNumberFormatter.Format(1.5e15)                            // "1.50Qa"
IdleNumberFormatter.Format(1500, IdleNumberFormat.Scientific) // "1.50e3"
IdleNumberFormatter.Format(1500, IdleNumberFormat.Full)       // "1,500"

// Time formatting
IdleNumberFormatter.FormatTime(45)    // "45s"
IdleNumberFormatter.FormatTime(154)   // "2m 34s"
IdleNumberFormatter.FormatTime(5000)  // "1h 23m"
IdleNumberFormatter.FormatTime(90000) // "1d 1h"

// Rate formatting
IdleNumberFormatter.FormatRate(1500000) // "1.50M/s"

IdleCostCalculator

Computes purchase costs with scaling formulas. Handles single-level costs, bulk costs (geometric series for Exponential), and max-affordable calculations (O(1) for Exponential via logarithm).

// Cost at level 50 with exponential scaling (Cookie Clicker uses 1.15)
double cost = IdleCostCalculator.GetCostAtLevel(10, 50, IdleCostScaling.Exponential, 1.15);
// 10 * 1.15^50 = ~10,836

// Total cost to buy levels 0 through 49 (50 levels total)
double totalCost = IdleCostCalculator.GetTotalCost(10, 0, 50, IdleCostScaling.Exponential, 1.15);

// How many levels can I afford with 100,000 gold?
int maxLevels = IdleCostCalculator.GetMaxAffordableLevels(10, 0, 100000,
    IdleCostScaling.Exponential, 1.15);

IdleBonusResolver

Resolves stacked bonuses in a strict order. This is the single source of truth for how bonuses combine. The pipeline is:

finalValue = (base + flatSum) * (1 + percentSum) * multiply1 * multiply2 * ...

// Example: base production of 100/s with upgrades
var bonuses = new List<IdleBonus>
{
    new IdleBonus(IdleBonusType.AddFlat, 50, "upgrade:EXTRA_MINERS"),     // +50 flat
    new IdleBonus(IdleBonusType.AddPercent, 0.5, "upgrade:BETTER_PICKS"), // +50%
    new IdleBonus(IdleBonusType.Multiply, 2.0, "prestige:REBIRTH"),       // x2
};

var result = IdleBonusResolver.Resolve(100, bonuses);
// (100 + 50) * (1 + 0.5) * 2.0 = 450
Debug.Log($"Base: {result.baseValue}, Final: {result.finalValue}"); // "Base: 100, Final: 450"

IdleConditionEvaluator

Shared utility for evaluating comparison conditions. Used internally by IdleMilestoneTracker, IdleUpgradeTracker, and IdleGeneratorManager, but you can call it directly too.

IdlePrestigeCalculator

Computes prestige rewards and inverse lookups. Supports four formula types: Linear, Sqrt (most common), Log, and Polynomial.

Snapshot Serialization

Every runtime tracker has CreateSnapshot() and RestoreFromSnapshot() methods. The IdleGameSnapshot class bundles all tracker snapshots into a single serializable object. All snapshot classes are [Serializable] and compatible with JsonUtility.ToJson().

Complete Save/Load Pattern

// ── SAVE ──
var gameSnapshot = new IdleGameSnapshot
{
    timestampTicks = DateTime.UtcNow.Ticks,
    resources = resourcePool.CreateSnapshot(),
    generators = generatorManager.CreateSnapshot(),
    upgrades = upgradeTracker.CreateSnapshot(),
    prestige = prestigeManager.CreateSnapshot(),
    milestones = milestoneTracker.CreateSnapshot(),
    buffs = buffManager.CreateSnapshot()
};
string json = JsonUtility.ToJson(gameSnapshot);
PlayerPrefs.SetString("idle_save", json);

// ── LOAD ──
string savedJson = PlayerPrefs.GetString("idle_save", "");
if (!string.IsNullOrEmpty(savedJson))
{
    var snapshot = JsonUtility.FromJson<IdleGameSnapshot>(savedJson);
    resourcePool.RestoreFromSnapshot(snapshot.resources);
    generatorManager.RestoreFromSnapshot(snapshot.generators);
    upgradeTracker.RestoreFromSnapshot(snapshot.upgrades);
    prestigeManager.RestoreFromSnapshot(snapshot.prestige);
    milestoneTracker.RestoreFromSnapshot(snapshot.milestones);
    buffManager.RestoreFromSnapshot(snapshot.buffs);

    // Calculate offline progress
    long savedTicks = snapshot.timestampTicks;
    float offlineSeconds = (float)(DateTime.UtcNow - new DateTime(savedTicks)).TotalSeconds;
    // ... use IdleProgressCalculator to calculate and apply offline earnings ...
}

Snapshot Types

API Hook Interfaces

Simple Idle Forge provides three interfaces that you implement in your own code. We never touch ads, IAP, analytics, or platform-specific systems. Your implementation decides where rewards come from, how data is stored, and how notifications are displayed.

IIdleSaveHandler

Implement this to handle persistence. Your implementation decides the storage backend (PlayerPrefs, JSON file, cloud save, etc.).

public class MyPlayerPrefsSaveHandler : IIdleSaveHandler
{
    private const string SaveKey = "idle_game_save";
    private const string TimestampKey = "idle_game_timestamp";

    public void SaveState(IdleGameSnapshot snapshot)
    {
        string json = JsonUtility.ToJson(snapshot);
        PlayerPrefs.SetString(SaveKey, json);
        PlayerPrefs.SetString(TimestampKey, DateTime.UtcNow.Ticks.ToString());
        PlayerPrefs.Save();
    }

    public IdleGameSnapshot LoadState()
    {
        string json = PlayerPrefs.GetString(SaveKey, "");
        if (string.IsNullOrEmpty(json)) return null;
        return JsonUtility.FromJson<IdleGameSnapshot>(json);
    }

    public float GetOfflineSeconds()
    {
        string ticksStr = PlayerPrefs.GetString(TimestampKey, "");
        if (string.IsNullOrEmpty(ticksStr)) return 0;
        long ticks = long.Parse(ticksStr);
        return (float)(DateTime.UtcNow - new DateTime(ticks)).TotalSeconds;
    }

    public bool HasSave() => PlayerPrefs.HasKey(SaveKey);
    public void DeleteSave() { PlayerPrefs.DeleteKey(SaveKey); PlayerPrefs.DeleteKey(TimestampKey); }
}

IIdleRewardHandler

Implement this to handle ad rewards, IAP boosts, daily logins, or any external reward source. The idle system calls your implementation when rewards are processed.

IIdleNotificationHandler

Implement this to handle game notifications and UI updates. Your implementation decides how notifications are displayed (toast, popup, log, HUD, etc.).

Events Reference

Complete table of every event across all runtime trackers. Subscribe to these in your game controller for UI updates, sound effects, analytics, and state synchronization.

Enums Reference

All enums in the SimpleIdleForge namespace with every value and its meaning.

IdleCostScaling

Cost scaling formula type for generators and repeatable upgrades.

IdleBonusType

Bonus and effect type for upgrades, milestones, prestige bonuses, and buffs.

IdleProductionMode

Production mode for generators.

IdleTargetType

Target type for upgrades, bonuses, and buffs.

IdleResetTarget

Target type for prestige reset rules.

IdleConditionType

Condition type for prerequisites and milestone conditions.

IdleComparison

Comparison operator for prerequisites and milestone conditions.

IdlePrestigeFormula

Prestige reward formula type. Controls how prestige points scale with source amount.

IdleNumberFormat

Number display format for idle game UI.

IdleAutoBuyStrategy

Strategy for the IdleAutoPurchaser's global generator auto-buy behavior.

IdleOfflineMode

How offline efficiency scales with time away. Used by IdleOfflineEfficiency.

Four Complete Games

Simple Idle Forge ships with four fully playable idle games. These are not tech demos. They are not minimal examples with a single button and a counter. They are complete, polished idle games with multiple progression systems, dozens of upgrades, layered prestige mechanics, achievement milestones, and hours of content — the kind of games that players actually sit down and play.

Every single one of these games was built entirely with Simple Idle Forge. The same five forge wizards you get access to. The same JSON workflow you can use to design your content externally and import it in bulk. The same runtime components that handle offline progress, bonus stacking, cost scaling, and prestige resets. Nothing was hand-coded outside the toolkit. Nothing was faked for the sake of a demo. What you see running in the Unity Editor is exactly what the toolkit produces.

Each demo targets a different genre of idle game, uses a different visual theme and layout paradigm, and showcases different features of the toolkit. Together, they cover the entire spectrum of idle game design — from the classic Cookie Clicker loop to industrial supply chains, survival decay mechanics, and dark RPG combat systems with four-layer prestige hierarchies.

Most importantly: every demo includes its complete JSON source data. You can open these JSON files, study exactly how the resources, generators, upgrades, prestige layers, and achievements were structured, and use them as templates for your own game. The JSON pipeline is the fastest way to build content for Simple Idle Forge, and the demo source files are the best reference for learning exactly how it works.

Playing the Demos

Getting into the demos takes about ten seconds. Every demo is accessible from a central hub scene that acts as a launcher — click a button, and you are playing that game. Click "Back to Hub" inside any demo, and you are back at the launcher ready to try another one.

Simple Kingdom — The Classic Idle Clicker

Simple Kingdom is the "hello world" of idle games, and it is one of the most satisfying hello worlds you will ever play. This is the genre that started it all — the Cookie Clicker formula that launched a thousand incremental games. Tap to earn gold. Buy generators that produce gold automatically. Purchase upgrades that multiply your output. Prestige to restart with permanent bonuses and watch the numbers climb even faster the second time around.

The genius of this formula is its simplicity. There is always something to buy, always a milestone just out of reach, always a reason to check back in five minutes to see how much gold has piled up. Simple Kingdom captures that loop perfectly, wrapped in a dark fantasy medieval theme with a polished centered column layout.

At a Glance

7 Resources

The kingdom's economy runs on seven distinct resources, each serving a different role in the progression system:

• Gold — The primary currency. Everything starts and ends with gold. Your generators produce it, your upgrades cost it, and your prestige formula reads from your total gold earned. This is the heartbeat of the kingdom.
• Gems — A premium secondary currency used for high-tier upgrades and special purchases. Harder to earn than gold, which makes spending them feel meaningful.
• Prestige Points — Earned through the Rebirth prestige layer. These are the permanent currency that survives resets and funds your permanent bonuses.
• Wood — A basic material produced by the Lumber Mill. Used in the cost formulas of mid-tier generators and upgrades, adding depth to the economy beyond "everything costs gold."
• Iron — A refined material produced by the Iron Mine. Gates access to the higher-tier generators like the Blacksmith and Crystal Cavern.
• Crystals — A rare resource produced by the Crystal Cavern. Used for the most powerful upgrades and as a component in the Dragon Lair's cost formula.
• Energy — A regenerating resource that gates certain special actions and speed-based upgrades. Adds a timing element to an otherwise passive game.

8 Generators

The kingdom's generators follow a classic medieval progression, each one unlocking via prerequisites that guide the player through a natural order of advancement:

• Peasant Hut — Your first generator. Cheap, cheerful, produces a trickle of Gold. Every kingdom starts with peasants.
• Lumber Mill — Produces Wood. Unlocks once you have a few Peasant Huts, introducing the player to the concept of prerequisite chains.
• Gold Mine — A dedicated Gold producer that outpaces the Peasant Hut by a wide margin. This is where the numbers start climbing.
• Farm — Produces Gold and provides food-related bonuses. Mid-tier pricing that requires both Gold and Wood.
• Iron Mine — Produces Iron, opening the door to the second tier of the economy. Costs Gold and Wood to purchase.
• Blacksmith — Converts Iron into Gold at a high rate. One of the first generators that requires a refined material (Iron) in its cost formula.
• Crystal Cavern — Produces Crystals, the rarest basic material. Expensive to buy, but its output feeds into the most powerful upgrades in the game.
• Dragon Lair — The crown jewel. Massive Gold production, costs Gold, Iron, and Crystals. The ultimate generator that players spend hours working toward.

All eight generators use Continuous production — resources flow every tick with no waiting, no progress bars, no timers. This is the purest expression of the idle clicker formula: buy the generator, watch the number go up, buy another one.

20 Upgrades

The upgrade system in Simple Kingdom covers three categories that work together to accelerate the player's progression:

• 8 Production Boosts (Peasant Boost, Lumber Boost, Gold Mine Boost, Farm Boost, Iron Mine Boost, Blacksmith Boost, Crystal Boost, Dragon Boost) — One per generator, each multiplying that generator's output. These are the bread and butter of the upgrade system.
• 8 Automation Triggers (Peasant Auto, Lumber Auto, Gold Mine Auto, Farm Auto, Iron Mine Auto, Blacksmith Auto, Crystal Auto, Dragon Auto) — Each one enables automatic purchasing for its corresponding generator. Once bought, the auto-purchase system takes over and buys that generator whenever you can afford it.
• 4 Speed Bonuses (Iron Speed, Blacksmith Speed, Crystal Speed, Dragon Speed) — Accelerate the production rate of the higher-tier generators, providing a meaningful boost in the late game when raw multipliers start to plateau.

1 Prestige Layer: Rebirth

When the player feels ready — or when progress slows to a crawl — they can trigger a Rebirth. This resets their generators, upgrades, and non-prestige resources, but awards Prestige Points based on their total Gold earned. Those Prestige Points buy permanent bonuses that make the next run faster, letting the player reach the point where they last prestiged in a fraction of the time. The cycle repeats, each Rebirth pushing further than the last.

One prestige layer is all this game needs. The simplicity is the point. Simple Kingdom teaches the fundamental prestige loop before the player moves on to more complex demos.

20 Achievements

The achievement system provides long-term goals across every aspect of the game: earning gold milestones (1K, 100K, 10M, 1B), stockpiling materials, leveling specific generators to high thresholds, purchasing your first upgrade, triggering your first Rebirth, and reaching the ultimate "Eternal Kingdom" milestone that represents true mastery.

What Simple Kingdom Teaches You

Factory Tycoon — The Supply Chain

Factory Tycoon takes the idle formula and adds a layer of strategic depth that changes everything: supply chains. Resources do not just accumulate — they flow. Raw materials come out of extractors, get refined into intermediate goods, get assembled into finished products, and get sold for profit. Each step in the chain depends on the step before it. You cannot build Electronics without Copper Wire and Plastic. You cannot build Copper Wire without Copper Ore. You cannot extract Copper Ore without a Copper Mine.

This creates a fundamentally different kind of idle game. Instead of the linear "buy more of everything" progression of a Cookie Clicker, Factory Tycoon demands that you think about bottlenecks. Your Steel Foundry can only refine Steel as fast as your Iron Mine can supply Iron Ore. Your Electronics Fab needs both Copper Wire and Plastic, so you need to balance the output of your Wire Mill and Plastic Plant. Every investment is a decision about which part of the chain needs more capacity.

The visual theme is industrial opulence — royal maroon backgrounds with gold accents and clean black text. It feels like the office of a titan of industry who has profits to count and factories to build.

At a Glance

12 Resources

The factory's economy is organized into three tiers that mirror a real supply chain:

Raw Materials (Tier 1):

• Iron Ore — Extracted by the Iron Mine. Feeds into the Steel Foundry.
• Copper Ore — Extracted by the Copper Mine. Feeds into the Wire Mill.
• Oil — Extracted by the Oil Pump. Feeds into the Plastic Plant.

Processed Goods (Tier 2):

• Steel — Refined from Iron Ore at the Steel Foundry. Used by the Machine Shop.
• Copper Wire — Drawn from Copper Ore at the Wire Mill. Used by the Electronics Fab.
• Plastic — Molded from Oil at the Plastic Plant. Used by the Electronics Fab.

Finished Products and Currencies (Tier 3):

• Electronics — Assembled from Copper Wire and Plastic. High-value product.
• Machinery — Assembled from Steel. Powers industrial upgrades.
• Power — Generated by the Power Plant. Consumed by high-tier operations.
• Cash — The primary currency. Earned from the Trade Depot and used for all purchases.
• Research Points — Earned alongside Cash. Spent on technology upgrades.
• Blueprint Tokens — Prestige currency earned through the Retool and Conglomerate layers.

10 Generators — Continuous Extractors + Timer Processors

This is where Factory Tycoon showcases one of Simple Idle Forge's most powerful features: mixing Continuous and Timer production modes in the same game. The three extractors run continuously, producing a steady flow of raw materials. The seven processors use Timer production — each crafting cycle takes real seconds, displays a visible progress bar that fills up, and delivers a batch of output when the timer completes.

Continuous Extractors (always running):

• Iron Mine — Continuously extracts Iron Ore.
• Copper Mine — Continuously extracts Copper Ore.
• Oil Pump — Continuously extracts Oil.

Timer Processors (batch production with visible progress bars):

• Steel Foundry — 8-second cycle. Consumes Iron Ore, produces Steel.
• Wire Mill — 10-second cycle. Consumes Copper Ore, produces Copper Wire.
• Plastic Plant — 8-second cycle. Consumes Oil, produces Plastic.
• Electronics Fab — 15-second cycle. Consumes Copper Wire + Plastic, produces Electronics.
• Machine Shop — 20-second cycle. Consumes Steel, produces Machinery.
• Trade Depot — 12-second cycle. Converts finished goods into Cash.
• Power Plant — 5-second cycle. Produces Power for high-tier operations.

The timer bars are the star of the show. Watching seven different progress bars fill at different rates, knowing that each one depends on having enough raw materials, creates a deeply satisfying management experience. When you buy a Speed upgrade and watch a timer that used to take 15 seconds drop to 10, the improvement is visceral and immediate.

24 Upgrades with Speed Bonuses

The upgrade system in Factory Tycoon is designed around the supply chain:

• 10 Production Boosts — One per generator, increasing output per cycle.
• 7 Speed Upgrades (Steel Speed, Wire Speed, Plastic Speed, Electronics Speed, Machine Speed, Trade Speed, Power Speed) — These directly reduce the timer duration on processors. A Steel Foundry with a Speed upgrade refines Steel faster, which means your downstream Machine Shop gets fed sooner. Speed bonuses are the most impactful upgrades in a timer-based game.
• 5 Automation Triggers (Auto Iron, Auto Copper, Auto Refinery, Auto Assembler, Auto Trade) — Enable automatic purchasing for groups of generators.
• 2 Global Bonuses (Factory Efficiency, Industrial Revolution) — Late-game upgrades that boost the entire factory at once.

2 Prestige Layers: Retool → Conglomerate

Factory Tycoon demonstrates stacked prestige layers — a more advanced system where the second prestige layer resets the first.

• Retool — The first prestige layer. Resets your factory and awards Blueprint Tokens based on your total Cash earned. Blueprint Tokens buy permanent efficiency bonuses that make your next factory run significantly faster.
• Conglomerate — The second prestige layer. Resets everything including your Retool progress and awards a more powerful prestige currency. This is the deep meta-game that gives Factory Tycoon its long-term legs. Players who have Retooled a dozen times eventually graduate to the Conglomerate layer for even greater permanent power.

25 Achievements

Achievements track progress across the entire supply chain: first profits, production milestones for each resource tier, speed optimization targets, generator level thresholds, prestige completions for both layers, and the ultimate "Singularity" achievement for players who master every aspect of their industrial empire.

What Factory Tycoon Teaches You

Survival Idle — The Decay Challenge

Survival Idle turns the idle formula on its head. In every other idle game, resources only go up. You accumulate, you grow, you buy more, and the numbers climb forever. In Survival Idle, three critical resources — Food, Water, and Warmth — are constantly draining. Every second that passes, your settlers get hungrier, thirstier, and colder. If any of these vital resources hits zero, you are in trouble.

This creates a fundamentally different emotional experience. Instead of the zen-like satisfaction of watching numbers grow, Survival Idle gives you urgency. You need to gather wood before the campfire goes out. You need to hunt before your food stores run empty. You need to balance production across multiple resource types simultaneously, because letting any one of them drop to zero means your settlement is in danger.

The visual theme reinforces this tension perfectly. A neumorphic black-and-white palette with no color except in the vital resource bars: green when you are safe (above 50%), amber when supplies are getting low (25–50%), and red when you are in danger (below 25%). The entire UI is built around the Melvor Idle sidebar pattern — a permanent 250-pixel sidebar on the left showing your vital resources at all times, with the main content area on the right.

At a Glance

16 Resources

The survival economy is divided into vital resources that drain, basic materials, crafted goods, and prestige currencies across three layers:

Vital Resources (drain every second):

• Food — Drains constantly. Produced by the Forager and Hunter Lodge. When Food hits zero, your settlers start to starve. The resource bar turns red well before this happens, giving you time to react.
• Water — Drains constantly. Produced by the Well. Dehydration is faster than starvation in this game, making the Well one of your first priorities.
• Warmth — Drains constantly. Produced by the Campfire. Without warmth, your settlers freeze. The Campfire needs Wood as fuel, creating a chain dependency: Woodcutter → Wood → Campfire → Warmth.

Basic Materials:

• Wood — Gathered by the Woodcutter. Used for Campfire fuel, building materials, and crafting recipes.
• Stone — Quarried by the Quarry. Used for construction and tool crafting.
• Hide — Gathered by the Hunter Lodge. Used for clothing and leather goods.
• Herbs — Cultivated by the Herb Garden. Used for Medicine crafting.
• Iron Scrap — Scavenged from the environment. Used for advanced tools and trade goods.

Crafted Goods:

• Medicine — Crafted by the Apothecary from Herbs. Essential for survival.
• Tools — Crafted by the Workshop from Wood, Stone, and Iron Scrap. Boost gathering efficiency.
• Clothing — Crafted by the Tannery from Hide. Provides warmth bonuses.
• Stamina — A regenerating pool that gates special actions.

Prestige Currencies (3 tiers):

• Survival Points — Earned from Season Reset (Layer 1).
• Season Tokens — Earned from Season Reset. Secondary layer 1 currency.
• Legacy Points — Earned from Migration (Layer 2).
• Evolution Shards — Earned from Evolution (Layer 3). The ultimate currency.

12 Generators — 5 Continuous Gatherers + 7 Timer Crafters

Like Factory Tycoon, Survival Idle mixes both production modes — but with survival-specific logic:

Continuous Gatherers (always running):

• Forager — Continuously gathers Food.
• Well — Continuously produces Water.
• Woodcutter — Continuously gathers Wood.
• Quarry — Continuously extracts Stone.
• Campfire — Continuously produces Warmth (consumes Wood).

Timer Crafters (batch production with progress bars):

• Hunter Lodge — 12-second cycle. Produces Food and Hide.
• Herb Garden — 10-second cycle. Cultivates Herbs.
• Apothecary — 15-second cycle. Crafts Medicine from Herbs.
• Workshop — 20-second cycle. Crafts Tools from Wood, Stone, Iron Scrap.
• Tannery — 15-second cycle. Crafts Clothing from Hide.
• Shelter — 8-second cycle. Provides Warmth and protection.
• Trading Post — 25-second cycle. Converts surplus goods into valuable resources.

The continuous gatherers keep your vital resources from hitting zero while the timer crafters produce the goods you need for long-term progression. The tension between "keep my settlers alive right now" and "invest in better crafting for later" is what makes Survival Idle compelling.

24 Upgrades Including Decay Reduction

The upgrade system includes the standard production boosts, speed bonuses, and automation triggers — but Survival Idle adds a category that no other demo has:

• 5 Continuous Boosts — Increase gathering rates for the five continuous generators.
• 7 Speed Upgrades — Reduce timer durations on all seven crafting buildings.
• 6 Automation Triggers — Enable auto-buying for gatherers, crafters, and trade.
• 3 Decay Reduction Upgrades (Food Preservation, Water Purification, Insulation) — These directly reduce the drain rate on vital resources. Food Preservation slows how fast Food depletes. Water Purification slows Water drain. Insulation slows Warmth loss. These are game-changing upgrades that fundamentally shift the pressure from "constantly gathering to survive" to "comfortably stockpiling for the future."
• 3 Specialty Upgrades (Medicine Stockpile, Survival Instinct, Apex Survivor) — Late-game upgrades that provide powerful global bonuses.

3 Prestige Layers: Season Reset → Migration → Evolution

Survival Idle demonstrates three stacked prestige layers, each one resetting more aggressively and rewarding more generously:

• Season Reset — The first prestige layer. Represents surviving through a harsh season and starting a new one with the knowledge you gained. Resets generators and basic resources, awards Survival Points and Season Tokens for permanent survival bonuses.
• Migration — The second prestige layer. Your settlement moves to a new location. Resets everything including Season Reset progress, awards Legacy Points that fund powerful permanent upgrades unavailable at the first layer.
• Evolution — The third prestige layer. A fundamental transformation of your settlement. Resets everything including Migration progress, awards Evolution Shards — the most powerful permanent currency in the game. Reaching the third prestige layer requires significant investment in the first two, creating a deep progression chain.

30 Achievements

The achievement system tracks survival milestones, trading volumes, crafting totals, generator levels, speed optimization targets, and prestige completions across all three layers. Thirty achievements provide a comprehensive roadmap through early gathering, mid-game crafting, late-game optimization, and the deep prestige meta-game.

What Survival Idle Teaches You

RPG Idle — The Cross-Forge Showcase

RPG Idle is the most ambitious of the four demos, and it exists to prove a point: Simple Idle Forge can handle anything. This is a dark, soulslike RPG where warriors venture into combat zones that drain their health and endurance while producing souls, crafting materials, and prestige currencies. Every expedition costs something. Every reward is earned through sacrifice. The numbers go up, but they also go down — and managing both sides of that equation is what makes RPG Idle feel like an actual RPG rather than just another clicker with a fantasy skin.

The visual theme matches the tone: dark neumorphic panels with a deep crimson accent color (#A4133C) that evokes blood, fire, and ancient power. The layout follows the Melvor Idle sidebar pattern, with a permanent navigation panel on the left and tabbed content pages on the right — four pages that players switch between without losing state (no destroying and recreating UI elements on tab switches, which is a pattern worth studying).

But the real reason RPG Idle exists is to showcase the cross-forge ecosystem. If you own other Simple Forge packages — Simple Quest Forge, Simple Enemy Forge, Simple Item Forge, Simple Skill Forge, or Simple Attribute Forge — the RPG demo detects them at runtime and enriches its interface with their data. Quests from Quest Forge appear as completable objectives. Enemies from Enemy Forge populate the combat zone descriptions. Items from Item Forge show up as lootable rewards. Skills from Skill Forge enhance your combat capabilities. And if you do not own any of these companion packages, RPG Idle works perfectly on its own — it just displays a friendly checklist showing which packages are available and what they would add.

At a Glance

19 Resources

The RPG's economy is organized around combat, crafting, and soul currencies:

Combat Stats:

• Health — Drained by combat zone generators based on their Stamina Drain numeric value. When Health drops too low, combat becomes dangerous.
• Focus — Mental resource consumed by runic and ritual activities.
• Endurance — Physical resource drained by combat and crafting. Limits how many zones you can run simultaneously.

Soul Currencies:

• Souls — The primary currency, earned from combat zones. The beating heart of the RPG economy.
• Humanity — A rare currency tied to the game's lore. Difficult to earn, powerful when spent.
• Insight — Prestige currency from Awakening (Layer 1).
• Echoes — Prestige currency from Reincarnation (Layer 2).
• Void Essence — Prestige currency from Hollowing (Layer 3).
• Divine Spark — Prestige currency from Apotheosis (Layer 4). The ultimate currency in the game.

Crafting Materials:

• Bone Shards — Harvested from defeated enemies at the Graveyard Patrol.
• Dark Essence — Collected from corrupted zones.
• Runic Fragments — Forged at the Runic Forge.
• Primordial Ash — Gathered from the deepest combat zones.
• Forgeite — A rare crafting material from the Ember Sanctum.
• Ember Resin — Processed material from bonfire rituals.

Progression Resources:

• Experience — Earned from combat and used for level-gated upgrades.
• Healing Draughts — Consumable resource for health recovery.
• Bonfire Kindling — Fuel for the Bonfire generator.
• Covenant Tokens — Earned from the Covenant Altar. Special faction currency.

14 Generators — Combat Zones + Crafting Stations + Passive Sources

The generator system in RPG Idle models the full RPG experience: venturing into dangerous zones, crafting powerful equipment, and maintaining passive resource flows.

Combat Zones (Timer production — each expedition takes time):

• Graveyard Patrol — The introductory combat zone. Produces Souls and Bone Shards. Low Stamina Drain, suitable for new characters.
• Cathedral Expedition — Mid-tier zone. Produces Souls, Dark Essence, and Experience. Moderate Stamina Drain.
• Ironhold Raid — Advanced zone. Higher Souls output, produces Forgeite. Significant Stamina Drain.
• Crimson Hunt — Elite zone. Produces Humanity and rare materials. Heavy Stamina Drain — only viable with upgrades that mitigate combat costs.
• Abyssal Descent — The ultimate combat zone. Massive rewards, brutal Stamina Drain. The endgame challenge that players build toward across multiple prestige cycles.

Crafting Stations (Timer production):

• Bone Workshop — Processes Bone Shards into usable materials.
• Runic Forge — Crafts Runic Fragments from raw materials.
• Ember Sanctum — Processes rare materials into Forgeite and Ember Resin.
• Training Grounds — Produces Experience through combat practice.
• Covenant Altar — Produces Covenant Tokens through ritual devotion.

Passive Generators (Continuous production):

• Hollow Farm — Continuously generates a trickle of Souls.
• Dark Ritual Site — Continuously generates Dark Essence.
• Abyss Well — Continuously generates Void Essence (very slowly).
• Bonfire — Continuously restores Health and provides Ember Resin. The central safe haven of the RPG, consuming Bonfire Kindling as fuel.

Combat Drain — The Stamina Drain System

What sets RPG Idle apart from every other demo is its combat drain mechanic. Every combat zone generator has a "Stamina Drain" numeric value defined in its database entry. When you level up combat zones, the total drain across all your active zones increases. This drain is applied against your Health and Endurance resources, meaning that expanding your combat operations has a real cost — you need to balance offense (more zones, higher levels) against defense (healing upgrades, bonfire maintenance, drain reduction).

This mechanic was built entirely with the toolkit's existing features — generator-level custom numerics, the runtime tick system, and the resource pool. No special code was written to support it. The demo's runtime controller reads the Stamina Drain numeric from each generator's database entry and applies it during the tick cycle. This is a powerful example of how custom numerics on generators can model game mechanics that go far beyond simple production.

28 Upgrades

The upgrade system covers every aspect of the RPG:

• 4 Passive Boosts — Increase output from continuous generators.
• 10 Speed Upgrades — Reduce expedition and crafting timer durations for all ten timer-based generators.
• 7 Automation Triggers — Enable auto-expedition and auto-crafting across combat zones, crafting stations, and passive sources.
• 7 Specialty Upgrades (Warrior Training, Sorcery Attunement, Covenant Blessing, Dragonslayer Pact, Kindled Strength, Lord's Resolve, First Flame Remnant) — Powerful themed upgrades that provide unique bonuses like drain reduction, global multipliers, and cross-system synergies.

4 Prestige Layers: Awakening → Reincarnation → Hollowing → Apotheosis

RPG Idle has the deepest prestige system of any demo, with four stacked layers that provide months of progression depth:

• Awakening — Your first death and rebirth. Resets generators and basic resources, awards Insight. Insight buys permanent combat bonuses. Most players will Awaken dozens of times before moving deeper.
• Reincarnation — A deeper reset that clears Awakening progress. Awards Echoes — a more powerful currency that buys bonuses unavailable through Insight. Requires significant Awakening investment to be worthwhile.
• Hollowing — A dangerous transformation that strips away almost everything. Awards Void Essence, which provides multiplicative bonuses that stack on top of all previous prestige bonuses. This is where the exponential power growth begins.
• Apotheosis — The final prestige layer. Complete transcendence. Resets everything, awards Divine Spark — the rarest and most powerful currency in the game. A single Divine Spark can provide bonuses that take hundreds of Awakenings to match. Reaching Apotheosis is a genuine accomplishment that represents mastery of every system in the game.

35 Achievements

The most extensive achievement set of any demo. Thirty-five milestones cover soul earning tiers (five levels from first souls to soul god), material collection, combat zone mastery, production rate targets, speed optimization, generator level milestones, prestige completions for all four layers, covenant devotion, and hidden achievements for players who discover secret interactions between systems.

Cross-Forge Integration

RPG Idle is the showcase for the Simple Forge ecosystem. The demo's runtime uses reflection-based bridge detection to check which companion packages are installed in your project, and it adapts its interface accordingly:

If you do not own any companion packages, RPG Idle works perfectly on its own. On startup, the demo displays a friendly upsell panel that shows a checklist of detected packages with green checkmarks for installed packages and clear labels for packages that are not yet installed. This panel uses a carousel-style forge picker that lets you browse what each companion package would add — without being pushy or disruptive.

What RPG Idle Teaches You

Demo Comparison

The following table provides a side-by-side comparison of all four demo games, making it easy to see the scale and scope of each one at a glance. Use this to pick which demo to study first based on what your own game needs.

Notice how the complexity scales deliberately across the four demos. Kingdom is the simplest — 7 resources, 1 prestige layer, all continuous production. RPG is the most complex — 19 resources, 4 prestige layers, combat drain, cross-forge integration. Each demo builds on the patterns established by the ones before it, creating a natural learning progression from simple to advanced.

What You Can Learn

The four demos are not just games to play — they are complete reference implementations that teach you everything you need to know to build your own idle game with Simple Idle Forge. Here is what you get access to when you study them:

Complete Generated Databases

Every demo's generated databases are included in the package under Assets/Simple IDLE Forge/Generated/. You can open any database in the Unity Inspector and see exactly how every resource, generator, upgrade, prestige layer, and achievement is configured. The custom editors provide search, filtering, and pagination for easy browsing — even with databases containing dozens of entries.

JSON Source Data

Every demo's original JSON source data is included. These are the exact JSON files that were fed into the forge wizards' import system to create the databases. You can study the JSON structure, modify it, and re-import it to see how changes affect the generated output. This is the fastest way to understand the JSON workflow — start with a working example and experiment from there.

Two UI Paradigms

The demos demonstrate the two most popular UI layouts in idle game design:

• Centered Column (Kingdom, Factory) — A single scrollable column, typically 900px wide, centered on screen. Clean, focused, mobile-friendly. This is the layout that Cookie Clicker, Clicker Heroes, and most casual incrementals use.
• Sidebar + Main Content (Survival, RPG) — A permanent sidebar on the left showing critical information (vital resources, navigation tabs) with a scrollable main content area on the right. This is the layout that Melvor Idle, Idle Slayer, and more complex incrementals use. It works best when your game has multiple simultaneous systems that players need to monitor.

Timer Production Examples

Three of the four demos use timer-based generators alongside continuous ones. Factory Tycoon, Survival Idle, and RPG Idle all demonstrate how to configure timer durations, how speed upgrades interact with timers, and how visible progress bars create a more engaging experience than pure continuous production. If your game uses the Adventure Capitalist timer model, these demos show you exactly how to set it up.

Prestige Layer Scaling

The demos provide examples of every prestige depth you might need:

• 1 layer (Kingdom) — The minimum viable prestige system. Simple, effective, sufficient for casual games.
• 2 layers (Factory) — The standard for mid-complexity idle games. The second layer resets the first, creating a meta-progression.
• 3 layers (Survival) — Deep enough for games with weeks of content. Each layer introduces new currencies and bonuses.
• 4 layers (RPG) — The maximum complexity demonstrated. Four stacked layers provide months of progression for dedicated players.

Same Runtime Components Everywhere

Despite looking completely different, all four demos use the exact same runtime components: IdleResourcePool for resource tracking, IdleGeneratorManager for production and purchasing, IdleUpgradeTracker for upgrade effects and prerequisites, IdlePrestigeManager for prestige resets and permanent bonuses, IdleMilestoneTracker for achievement checking, IdleBuffManager for temporary boosts, IdleProgressCalculator for offline progress, IdleStatisticsTracker for lifetime totals, and IdleAutoPurchaser for automatic buying. The only difference between demos is the data they load and the UI that displays it. This is the power of a data-driven architecture — your game logic is completely separate from your game content.

Using a Demo as a Starting Point

The fastest way to build your own idle game with Simple Idle Forge is to start from the demo that most closely matches your vision, study how it works, and then modify it to fit your design. Here is the recommended workflow:

Common Issues

These are the problems that come up most often, along with their solutions. If you are stuck on something, start here — there is a good chance your issue is one of these.

My database did not generate

After clicking Generate, the toolkit writes new script files to your project. Unity must recompile these scripts before the database asset can be created. This happens automatically through a process called domain reload — you will see a small spinner in the bottom-right corner of the Unity Editor while it is working.

If the spinner seems stuck or the database asset never appears, try forcing a refresh: go to Assets → Refresh (or press Ctrl+R). This tells Unity to re-scan for new files and trigger compilation. In most cases, this resolves the issue immediately.

If the database still does not appear after a refresh, check the Console window (Window → General → Console) for red error messages. A compilation error in any script — even one unrelated to Simple Idle Forge — will block the domain reload and prevent the database from being created. Fix the compilation error first, then try generating again.

The Generate button is greyed out

The Generate button stays disabled until your wizard data passes all validation checks. Look at the validation panel above the Generate button — it lists every issue that needs to be resolved. The most common causes are:

• Empty database name. Go back to Step 1 and give your database a name. The name is used to generate file names and class names, so it cannot be blank.
• No entries. You need at least one entry to generate a database. Go to Step 3 and create at least one entry, or import entries from JSON in Step 2.
• Duplicate codes. Every entry must have a unique code. If two entries share the same code, the validation will flag both of them. Go to Step 3, find the duplicates (the validation message tells you which codes are duplicated), and rename one of them.
• Invalid characters in codes. Codes must use UPPER_SNAKE_CASE — uppercase letters, digits, and underscores only. No spaces, no hyphens, no special characters. A code like Gold Mine or gold-mine will fail validation. Use GOLD_MINE instead.

My resource codes do not appear in the Generator Forge

The Generator Forge does not scan your entire project for resource databases. It only knows about databases that you have explicitly linked in Step 1 of the Generator Forge wizard. Open the Generator Forge, go to Step 1, and scroll down to the Linked Resource Databases section. Drag your generated resource database asset into the list. Once linked, every resource code from that database will appear in the resource code dropdowns throughout the Generator Forge's builder.

The same applies to the Upgrade Forge (which needs both resource and generator databases linked), the Prestige Forge (resource, generator, and upgrade databases), and the Achievement Forge (all four). Each forge only sees the databases you have explicitly connected.

Timer production does not show progress bars

Timer production requires two things to work correctly. First, the generator's Production Mode must be set to Timer (not Continuous) in the Generator Forge builder. Second, the Production Interval must be greater than zero — this is the number of seconds each production cycle takes. If the interval is zero, there is no timer to display.

If you have set both correctly and still do not see progress bars, check your runtime UI code. The demo games read each generator's production mode from the database and only render a progress bar for Timer generators. Your UI needs to check the production mode and render accordingly. Look at any demo's runtime manager for an example of how this is handled.

The prestige button is always disabled

The prestige system requires two conditions to be met before a prestige can be executed. First, the source resource amount (the resource the prestige formula reads from) must exceed the Minimum to Prestige value defined in the Prestige Forge. If your minimum is set to 1,000,000 and the player only has 500,000, the prestige is unavailable.

Second, the calculated reward from the prestige formula must be greater than zero. Even if the player has enough of the source resource to exceed the minimum, a formula with a very high base divisor might produce a reward of zero at that level. Open the Prestige Forge builder, look at the formula preview slider, and check what reward the formula produces at the source amounts your players are reaching. If the reward is 0 at realistic source amounts, your formula needs tuning — try lowering the divisor or switching to a more generous formula type.

Achievements are not completing

Achievement conditions are evaluated periodically, not continuously. In the demo games, the milestone tracker checks conditions every 0.5 seconds. If your own implementation uses a different interval, or if conditions are only checked on specific events, make sure the checking is actually happening.

Beyond timing, the most common issue is a mismatch between the condition's comparison operator and the intended threshold. If your achievement says "Reach 1,000,000 Gold" and uses Greater Than (>) as the operator, the player needs more than 1,000,000 — exactly 1,000,000 will not trigger it. Use Greater or Equal (>=) if you want exact thresholds to count. Also verify that the condition type and target code are correct — a condition checking GeneratorLevel against a resource code, for example, will never evaluate to true.

Cross-forge codes do not appear

Cross-forge integration requires two things. First, the companion package must be installed in your project. Simple Idle Forge detects companion packages automatically through both UPM version defines and reflection-based type probing — you do not need to enable anything manually. If the companion package is installed and Unity has recompiled, the bridge is active.

Second, you must link the companion's databases in the Cross-Forge Databases section of Step 1 in the forge wizard you are working in. Bridges are detected automatically, but databases must be linked manually. Drag the companion database into the appropriate slot, and its codes will appear in the relevant dropdowns throughout the builder.

My JSON import has errors

The import validation checks every cross-reference in your JSON against the databases you have linked in the forge wizard. The most common cause of import errors is resource codes in your JSON that do not match any code in your linked resource databases. For example, if your generator JSON references a resource code GEMS, but your linked resource database does not contain an entry with the code GEMS, the import will flag it.

Check the error messages — they tell you exactly which entry, which field, and which code failed validation. Common fixes include:

• Correcting typos in resource codes (the JSON says GOLDD, the database has GOLD)
• Linking missing databases in Step 1 before importing
• Fixing invalid enum values (the JSON says Exponetial, the valid value is Exponential)
• Adding missing required fields (every entry needs at least a code and a name)

Numbers display as scientific notation

If your resource amounts are showing up as values like 1.5E+06 instead of 1.5M, the resource's display format is set to Scientific. Open the Resource Forge wizard, go to Step 3 (Builder), find the resource, and change its Display Format from Scientific to Short. The Short format uses the K/M/B/T/Qa/Qi suffix system that players expect in idle games. Regenerate the database after making the change.

The domain reload takes too long

The first time you generate from any forge, Unity needs to compile entirely new script files (the enum, the database class, and the custom editor class). This triggers a full domain reload, which can take several seconds depending on the size of your project. This is normal.

Subsequent generations are faster because the script files already exist — Unity only needs to recompile the changed files and update the database asset. If domain reloads are consistently slow, it is usually because your overall project has many scripts that Unity recompiles on every change. This is a Unity-wide issue, not specific to Simple Idle Forge. Reducing your project's total script count or using assembly definitions to isolate frequently-changing code can help.

Frequently Asked Questions

Can I modify generated databases after generation?

Yes. Your generated database is a standard Unity asset that you can select in the Project window and edit directly in the Inspector. The custom editor provides search, filtering, and pagination to make this comfortable even for large databases. Any changes you make in the Inspector are saved to the asset immediately.

However, if you regenerate from the forge wizard, your Inspector changes will be overwritten with whatever is currently in the wizard. The wizard is the source of truth during generation. If you want a change to persist through regeneration, make it in the wizard data (Step 3) and regenerate. For quick one-off tweaks that you do not plan to regenerate over, editing in the Inspector is perfectly fine.

Can I use multiple resource databases in one game?

Yes. All runtime components — the resource pool, generator manager, upgrade tracker, prestige manager, and milestone tracker — support initialization from multiple databases. When you initialize a component with multiple databases, their entries are merged into a single working set. Resources are deduplicated by code, so if two databases both define a GOLD resource, only one will be used (the first one encountered).

This is useful when you want to split your game data into logical modules — one database for base game resources, another for expansion resources, another for seasonal event resources. Each can be authored and managed independently in its own forge wizard, then merged at runtime.

Do I need all five forges?

No. Use only the forges your game needs. The forges are designed to work independently, with optional connections between them.

A simple clicker game might only need the Resource Forge (to define currencies) and the Generator Forge (to define producers). An idle game with upgrades adds the Upgrade Forge. A game with reset mechanics adds the Prestige Forge. And achievements are always optional — add the Achievement Forge when you want milestone goals and challenges.

You can also add forges later. Start with Resources and Generators, build your core loop, play-test it, and then add Upgrades and Prestige when you are ready to deepen the progression. Each new forge links to your existing databases and builds on what you have already created.

Does Simple Idle Forge handle save and load?

It handles the data side — every runtime component (resource pool, generator manager, upgrade tracker, prestige manager, milestone tracker, buff manager, auto-purchaser, and statistics tracker) can export its complete state as a snapshot object and restore from one. Snapshots are plain data structures that are easy to serialize.

The actual persistence — where the save data goes and how it gets there — is up to you. The toolkit defines the IIdleSaveHandler interface with Save, Load, Delete, and HasSave methods that you implement with whatever storage backend your game uses: PlayerPrefs for simple games, a JSON file for portability, cloud saves for cross-device sync, or any other approach. The toolkit never makes assumptions about your save infrastructure.

Can I use this for a non-idle game?

The toolkit is designed and optimized for idle and incremental games, but many of its components are generic enough to work in other genres. The resource tracking system works in any game with currencies or inventories. The upgrade system works in any game with purchasable boosts. The achievement system works anywhere you want milestone-based goals. The number formatting and cost scaling utilities are useful whenever you have large numbers or escalating costs.

What makes it specifically "idle" is the combination of offline progress calculation, prestige reset cycles, auto-purchase automation, continuous and timer production modes, and the bonus stacking pipeline. If your game uses some of these mechanics (RPGs with idle farming, tycoon games, strategy games with production chains), Simple Idle Forge will feel right at home. If your game has none of these mechanics, you might be better served by a more general-purpose data toolkit.

What Unity versions are supported?

Simple Idle Forge supports Unity 2021.3 (the Long-Term Support release) and every version after it, including Unity 2022, Unity 2023, and Unity 6. The toolkit uses stable, well-tested Unity features and avoids experimental or version-specific functionality. If your project compiles on Unity 2021.3 or later, Simple Idle Forge will work.

Both the Mono and IL2CPP scripting backends are fully supported, on every platform Unity targets — Windows, macOS, Linux, Android, iOS, WebGL, and consoles.

Are there any dependencies?

None. Simple Idle Forge is completely standalone. It does not depend on any third-party plugins, any Unity packages beyond the core engine, or any paid add-ons. Import it and it works.

The five companion forge packages (Simple Attribute Forge, Simple Item Forge, Simple Enemy Forge, Simple Quest Forge, and Simple Skill Forge) are entirely optional. They enrich the wizard dropdowns with cross-forge codes when present, but Simple Idle Forge has full functionality without any of them installed. The bridges detect companion packages at compile time and gracefully do nothing when they are absent.

Getting Help

If you have run through the troubleshooting list and the FAQ and your issue is not covered, here is how to get support.

Email Support

Reach out directly at livingfailuregames@gmail.com. Include the following information to help resolve your issue quickly:

• Your Unity version (e.g., 2022.3.18f1)
• Your Simple Idle Forge version (check package.json in the package folder)
• Which forge you are working with (Resource, Generator, Upgrade, Prestige, or Achievement)
• What step you are on (Setup, Definitions, Builder, Settings, or Generate)
• What you expected to happen and what happened instead
• Any error messages from the Unity Console (copy the full text, not just the first line)

Asset Store Reviews

If Simple Idle Forge helped you build something, consider leaving a review on the Unity Asset Store page. Reviews help other developers find the toolkit and let us know what is working well. If something is not working, a review is also a valid way to flag it — but emailing directly will get you a faster response.

Documentation

You are already here, but just in case: the full documentation is included offline in the package and is always available without an internet connection. Start at the Home page for an overview, follow the Quick Start for a hands-on tutorial, read the individual forge pages (Resources, Generators, Upgrades, Prestige, Achievements) for detailed feature guides, and check the API Reference for runtime component documentation.

About Simple Idle Forge

Simple Idle Forge is a no-code idle game toolkit for Unity, created by Living Failure. It gives you five interconnected wizard tools that handle every aspect of an idle or incremental game — resources, generators, upgrades, prestige systems, and achievements — without writing a single line of code.

You design your game through guided, step-by-step wizards inside the Unity Editor. Pick a genre template, customize your entries, generate your databases, and wire them into your UI. The toolkit handles cost scaling formulas, offline progress calculations, number formatting with K/M/B/T suffixes, bonus stacking, prestige resets, achievement tracking, temporary buffs, auto-purchasing, and every other system that makes idle games work. Four complete, playable demo games are included so you can see exactly what the toolkit produces.

What's Included

Simple Idle Forge is a comprehensive toolkit. Here is everything inside the package.

The Forge Ecosystem

Simple Idle Forge is part of a family of no-code database generators for Unity. Each package handles a different game system domain, and they all work together through optional bridges that detect each other automatically. No configuration, no setup, no dependencies between packages. Install any combination and they enrich each other's wizard dropdowns with cross-referenced data.

Every package in the ecosystem is fully standalone. You can use Simple Idle Forge without any companions, or with all five, or with any combination in between. The bridges add convenience — dropdown selections instead of typing codes manually — but they are never required. Your game data works identically whether companion packages are installed or not.

Credits

Simple Idle Forge was created by Living Failure.

For questions, support, bug reports, or feature requests, reach out at livingfailuregames@gmail.com.

If Simple Idle Forge helped you build something, consider leaving a review on the Unity Asset Store. Reviews help other developers discover the toolkit and make it possible to keep building and improving it.

License

Simple Idle Forge is distributed under the standard Unity Asset Store End User License Agreement (EULA). The full text of the EULA is available on the Unity Asset Store Terms of Service page.

In summary: you may use Simple Idle Forge in any number of your own projects (commercial or non-commercial), but you may not redistribute the toolkit's source code or assets as part of a competing product, template, or toolkit. One license covers one seat — each developer on your team who uses the Unity Editor with Simple Idle Forge installed needs their own license.