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:

Demo	Generators	Notes
Simple Kingdom	PEASANT_HUT, WHEAT_FARM, QUARRY, IRON_MINE, GEM_CAVE, CHAPEL, MONASTERY, SOUL_WELL	Classic cookie clicker layout. All continuous production. Each generator produces one primary resource.
Factory Tycoon	ORE_EXTRACTOR, LUMBER_MILL, STEEL_FOUNDRY, CIRCUIT_FAB, LUXURY_WORKSHOP, PATENT_OFFICE, RESEARCH_LAB, STOCK_EXCHANGE, BLUEPRINT_PRINTER, SHARE_BROKER	Supply chain game. Extractors use continuous production. Foundries, fabricators, and workshops use timer production with visible progress bars.
Survival Idle	FORAGER, WELL_DIGGER, FIRE_KEEPER, WOODCUTTER, STONE_MASON, TANNER, WEAVER, TOOL_SMITH, HERBALIST, SHELTER_BUILDER, MORALE_BOOSTER, MILITIA_TRAINER	Survival game. Five basic gatherers run continuously. Seven crafting buildings use timer production.
RPG Idle	GRAVEYARD_PATROL, UNDEAD_CRYPT, DEMON_ARENA, DRAGON_NEST, COSMIC_VOID, EMBER_FORGE, TITANITE_MINE, BLOOD_DISTILLERY, INSIGHT_MEDITATION, BONFIRE_REST, EQUIPMENT_REPAIR, HOLLOW_SHRINE, APOTHEOSIS_ALTAR, PASSIVE_REGEN	Dark RPG. Combat zones drain health/endurance while producing souls and materials. Uses timer mode for combat rounds (10s, 15s, 30s intervals) and continuous for passive regeneration.

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

Field	Description	Example
Database Name	Name prefix for all generated files.	KingdomGenerators
Namespace	Optional C# namespace.	MyIdleGame
Class Prefix	Optional prefix for generated class names.	Kingdom

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:

Category	Preset	Scaling Type	Factor
Exponential	Gentle	Exponential	1.07
	Standard	Exponential	1.15
	Steep	Exponential	1.30
	Aggressive	Exponential	1.50
Linear	+10	Linear	10
	+Base	Linear	(base cost)
Polynomial	Quadratic	Polynomial	2.0
	Sub-Quadratic	Polynomial	1.5
	Cubic	Polynomial	3.0
Logarithmic	Gentle	Logarithmic	0.5
	Standard	Logarithmic	1.0
	Steep	Logarithmic	2.0

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:

Preset	Interval	Good For
Fast	5 seconds	Quick crafting, cooking, basic processing
Medium	15 seconds	Standard manufacturing, combat encounters
Slow	30 seconds	Heavy industry, boss fights, expedition runs
Very Slow	60 seconds	Research projects, mega-crafting, raid completions

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:

Level	Cost at Level	Total Cost to Level
1	10	10
10	40	203
25	329	2,190
50	10,837	72,248
100	11,741,394	78,275,960
200	13,781,066,058,946	91,873,773,726,305

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:

Level	Milestone	Feel
10	+25% Production	Early boost to reward initial investment
25	x2 Production	First big doubling, feels great
50	+50% Global Output	Affects everything, major power spike
75	x2 Production	Another doubling to push toward 100
100	x3 Production	Major milestone, triple production, celebration moment
150	x2 Production + Unlock	Deep investment reward, unlocks something new
200	x5 Production	Aspirational endgame goal

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.