JSON Workflow

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.