Installation

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.

Companion Package	Package Name	What It Adds to Idle Forge Wizards
Simple Attribute Forge	com.livingfailure.simple-attribute-forge	Attribute names appear in wizard dropdowns for stat-based references and scaling targets
Simple Item Forge	com.livingfailure.simple-item-forge	Item codes and loot table codes appear for crafting and reward references
Simple Enemy Forge	com.livingfailure.simple-enemy-forge	Enemy codes and faction codes appear for combat zone and encounter references
Simple Quest Forge	com.livingfailure.simple-quest-forge	Quest codes appear for milestone conditions and unlock triggers
Simple Skill Forge	com.livingfailure.simple-skill-forge	Skill codes appear for ability-based generator and upgrade references

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.

Assembly	Namespace	What It Contains
SimpleIdleForge.Runtime	SimpleIdleForge	All runtime types: struct definitions, interfaces, calculators, formatters, managers, trackers, snapshot types, buff system, offline progress, API hook interfaces, enums
SimpleIdleForge.Editor	SimpleIdleForge.Editor	All editor types: forge wizard windows, wizard steps, wizard data, code generators, genre templates, JSON schema export/import, cross-forge bridges, shared helpers

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.