Log inGet started
World

Idle Ascent: Upgrades, Prestige and Idle Earnings Kit

Branchmain
Branchesmain
Commit72425fd83f

README.md

incrementalKit

Everything an idle, incremental, clicker or upgrade-shop game needs between "earn" and "spend": data-driven upgrades with nine price curves and exact bulk buying, stats that add up from upgrades, milestones and prestige, currencies with earning multipliers, prestige / rebirth with its own shop, generators that earn per second while playing and while away (with a welcome-back screen), milestones and records, per-player saves that are safe in multiplayer, events, and styled screens (shop, prestige, welcome back, milestones, toasts, hints, a currency HUD that rolls up and pops) in nine looks switched with one call.

local Inc = require("incrementalKit.inc")

Version 1.3.0. Uses three single modules from other kits, each installed as one record: saveKit's store (per-player storage), menusKit's icons and productionKit's numbers (the five base number styles; incrementalKit.numbers adds si, myriad, kanji and grouped on top). Installing incrementalKit brings those three modules along and nothing else of those kits (no package-wide dependencies), so the games that install it stay small and their own kits update freely.

1.3.0: upgrade tree, exclusive choices, numbers you can see.

  • Tree layout for a shop. Inc.setup{ shops = { main = { layout = "tree" } } } (or per open: Inc.ui.open("shop", { layout = "tree" })) draws every upgrade as a node: icon, name, level / max, price and what the next level changes, with an edge from each requires = { upgrade = ... } prerequisite (solid when met, dashed when not). Each category is a column band; treeStyle = "radial" lays the branches out as sectors of rings instead. Locked nodes are greyed with their requirement sentence, affordable ones glow, the selected one is outlined, and a detail panel beside the tree (below it on a phone) shows the description, every requirement with a tick or a lock, what changes and the Buy button (x1 / x10 / x25 / MAX still apply). Drag to pan, wheel / +/- / FIT to zoom; the arrow keys and the d-pad walk from node to node (along edges first, then to the nearest node that way), LB / RB jump between branches, LT / RT zoom, A / Enter buys the selected node, B / Esc closes; tap or click a node to select it, double-click to buy. Nodes outside the view are not drawn, so big trees stay cheap. The list stays the default. The prestige shop takes shops = { prestige = { layout = "tree" } } too.
  • Exclusive choices. exclusive = "group" on upgrades makes them a choice: once one has a level the others lock ('You chose "Tougher Parts" instead (respec to switch)'). setup{ exclusives = { group = { name, respecCost, respecCurrency, refund = 0..1, respec = false } } } names the choice and prices the respec: Inc.respec(group) takes the chosen upgrade and every owned upgrade built on it back to level 0, charges the price and refunds refund (default all) of what those levels cost; the tree's detail panel has the two-step Respec button. Inc.exclusiveGroup(s), Inc.respecQuote, Inc.excludedBy, Inc.lockInfo and the "respec" event go with it.
  • The difference in numbers. Inc.effectChange(id, levels) works out every stat and production rate an upgrade touches now and after levels more levels, with every multiplier: "Shove 3 -> 4 (+33%)", "Coins 10.5/s -> 11/s (+4.76%)", or with an effect label as the bracket ("Shove 4 -> 4.48 (+12% push)"). An upgrade's own preview = function(level, Inc) return "..." end adds a line of its own ("5 miners digging -> 6 miners digging"). Tree nodes, the tree's detail panel and the list cards all show it; Inc.effectChangeText gives it as one line.
  • Inc.ui.shopData rows carry change (the effectChange rows) and progress is now Inc.lockInfo (same share / text, plus locked / excludedBy). New incrementalKit.tree module (the pure layout builder) and treeTests suite (9 tests).

1.2.1:

  • economyKit bridge fixed: bridged purchases are paid for. economyKit's Economy.spend and Economy.grant are requests its bank answers later, and 1.2.0 treated a queued spend as paid: an upgrade priced in a bridged currency was granted at once (even when the bank then refused), two quick clicks bought twice on the same money, and the shown balance stayed stale because a wallet change never redrew the kit. Now Inc.buy on a bridged currency returns nil, "pending" and grants the level only when the bank took the money ("bought"); a refusal grants nothing and fires "buyRefused" with the bank's reason, shown as a "Purchase refused" toast. While a spend waits its amount is held (Inc.held, Inc.available; the shops, canAfford and "max" leave it out) and that upgrade takes no second purchase (Inc.isPending). The balance shown is always the wallet's own: the bridge follows economyKit's balanceChanged and ready events (and the wallet record arriving through the shared store) and fires "walletChanged". Inc.spend on a bridged currency returns nil, "pending" with an optional cb(ok, info), then "spent" or "spendRefused"; never treat pending as paid.
  • Prestige gains through the wallet are never lost. A gain the wallet refuses or never answers (a rate limit, a cap, a bank that is not up yet) is kept in the profile (Inc.walletOwed()), fires "walletRefused", and is given again every few seconds while playing. A bonusFrom = "held" prestige bonus reads the wallet's balance.
  • Inc.useWallet providers may be async (spend and give answer through done(ok, info)) and may offer ready, subscribe and rev. Covered by the economyBridgeTests suite in the Idle Ascent world (outside the package, so installing the kit still brings no economyKit), run against the real economyKit bank.

1.2.0:

  • Requirements read as sentences. A locked card says what to do, not raw data: "Reach 250 m deep (best: 76 m)", "Upgrade Miner to level 3 (now 0)", "Buy Coin Drone first", "Earn 1M Coins in total (so far 2.4K)", "Ascend once to unlock this", 'Earn the milestone "Millionaire"'. Records, counters and stats take a display name, a unit and an optional goal sentence from setup: records = { bestDepth = { name = "Deepest dive", unit = "m", goal = "Reach {want} deep" } } (counters and stats work the same way; a plain string is just the name). An id with no entry reads as words (bestFall becomes "Best fall"). Any single requirement can carry its own text (or label): a string with {want}, {have} and {name} filled in, or function(have, want, name) return "..." end. Units sit right after the number for %, x and /..., with a space otherwise.
  • economyKit wallets, where they fit. Inc.useEconomyKit({ gems = "gems" }, require("economyKit.economy")) keeps the named kit currencies in the player's economyKit wallet (per player, saved and authoritative in economyKit's bank), and every kit call (balance, earn, give, spend, canAfford, the shops and requirements) goes through it unchanged. Inc.useWallet(currency, { balance, spend, give, whole }) does the same for any other wallet, and Inc.walletOf(currency) says which one a currency uses. Gains go through Economy.grant with reason "incrementalKit" (allow it in Economy.setup{ clientGrants = ... }), spends through Economy.spend; fractions wait until they add up to a whole unit, and prestige never resets a bridged currency. It is opt-in and the game passes economyKit's module in, so incrementalKit takes no dependency on economyKit and its install stays the three modules above. Why the idle currencies stay in the kit: economyKit's bank takes whole numbers only (at most 1e9 per request, capped by each currency's max), answers asynchronously, and accepts client grants only for reasons the game allows at a rate limit; an idle game's soft and prestige currencies earn fractions many times a second, grow to 1e300, are predicted locally for the roll-up and reset on prestige. Routing those through the bank would round away the early game, cap the late game and flood the bank, so economyKit fits a game's premium, whole-number currency (gems sold in an economyKit shop), not the core idle loop.
  • Gamepad focus navigation. The shop, prestige, milestones and welcome-back screens focus their first buy / ascend / claim button when they open or change tab; the d-pad (and the arrow keys) walk every enabled button and wrap round, A / Enter / Space presses it, LB / RB switch tabs, B closes. UI.nav(step), UI.focusList() and UI.focusFirst() are there for a game's own screens.

1.1.0: the kit restarts itself every play session from the last Inc.setup (a game may call setup once per module lifetime: leaving play and pressing Play again reloads the save, closes any screen left open and respawns the host); the HUD's "+N" pop labels no longer carry a pointerEvents style (a UI validation warning); the install closure is down to the three modules above; the four extra number styles live in incrementalKit.numbers instead of a patched productionKit copy.

Guides

  • How to make an idle game with upgrades and prestige (how-to-make-an-idle-game-with-upgrades-and-prestige): every part of the kit, how it fits together, and the choices (curves, formulas, offline rules, looks).
  • Example: make a cookie-clicker style idle game with rebirth (example-make-a-cookie-clicker-style-idle-game-with-rebirth): an empty world to a small playable clicker, step by step.

Open them in the editor's Docs panel, with zero guides read <name> in the shell, or an agent's guides tool.

First example

-- a component on any entity in your scene
local Inc = require("incrementalKit.inc")

function awake()
    Inc.setup({
        currencies = { coins = { name = "Coins" }, stars = { name = "Stars", kind = "prestige" } },
        upgrades = {
            { id = "click", name = "Better Clicks", baseCost = 10, effect = { stat = "clickPower", op = "add", perLevel = 1 } },
            { id = "robot", name = "Robot", baseCost = 25, produces = { currency = "coins", perSecond = 1 } },
        },
        stats = { clickPower = 1 },
        prestige = { currency = "stars", from = "coins", formula = "sqrt", divisor = 10000 },
    })
    Inc.ui.setLook("cartoon")
end

-- call from your own click / gameplay code
local function onTap()
    Inc.earn("coins", Inc.stat("clickPower"), "click")
end

Press Play: a currency HUD appears top-left with Upgrades / Prestige / Milestones buttons top-right. The kit starts its own host the first time it is used in play (it ticks generators, autosaves, draws the screens and routes their clicks), so nothing else needs placing.

The API

Setup and data

CallWhat
Inc.setup(opts)currencies, upgrades, milestones, stats, prestige, offline, start (starting balances), numbers (style), namespace (save slot name), version + migrations, records / counters / stats (display names, units and goal sentences for requirement text), shops = { [shop] = { layout = "list" | "tree", treeStyle = "columns" | "radial", categories = { order } } }, exclusives = { [group] = { name, respecCost, respecCurrency, refund, respec } }, autosave (seconds). Re-callable.
Inc.defineUpgrade(u) / Inc.defineMilestone(m)Add one after setup.
Inc.on(event, fn) / Inc.off(handle)Events: bought, earned, spent, prestige, milestone, unlock, offline, claimed, record, loaded, changed, hint, respec.
Inc.rev()Changes whenever anything visible changes (redraw your own UI on it).

An upgrade: { id, name, description, icon, currency, baseCost, curve, curveParams, maxLevel, effect, produces, requires, category, shop = "main" | "prestige", exclusive = "group", preview = function(level, Inc) -> string, hidden, secret, resetsOnPrestige }.

  • effect = { stat, op = "add" | "mul" | "pct" | "pow", perLevel, label }, or a list of them, or function(level, Inc) return { stat = amount } end.
    • add: +perLevel per level. mul: x perLevel per level (compounding). pct: +perLevel % per level (additive). pow: raises the stat's exponent by perLevel per level.
  • produces = { currency, perSecond } (or a list): a generator, earning perSecond per level.
  • requires: { upgrade = "id", level = n }, { upgrades = { a = 3, b = 1 } }, { milestone = "id" }, { prestiges = n }, { record = "bestDistance", atLeast = 1000 }, { records = { name = v } }, { stat = "x", atLeast = v }, { currency = "coins", total = v } (lifetime earned), { counter = "runs", atLeast = n }, a function, or a list of any of these (all must hold). Any of them may carry text = "Dive below {want} (best: {have})" (or a function) to word it itself; otherwise the shop builds a sentence from the names and units given to setup.

A milestone: { id, name, description, icon, when = <same as requires>, reward = { currency, amount } | { upgrade, levels }, effect = <same as an upgrade's, applied once>, resetsOnPrestige }. Shorthand: put the condition keys on the milestone itself ({ id = "far", record = "bestDistance", atLeast = 1000 }).

A currency: { name, kind = "soft" | "premium" | "prestige", icon, color, hidden }.

Stats

Inc.stat(name) = (base + all adds) * all muls / pcts, then ^ (1 + all pows), from upgrades and reached milestones; Inc.stats() lists them. Base values come from stats = { name = base | { base, name, min, max } }. Names the kit itself reads:

StatDefaultUsed for
earn1 x prestige multiplierevery Inc.earn
earn.<currency>1earnings of one currency
source.<source>1earnings from one source ("tap", "distance", "idle" for generators ...)
gen.<upgradeId>1one generator's output
offline1offline efficiency multiplier
offlineHours.mul1offline time-limit multiplier
prestigeGain.mul1prestige gain multiplier

Any other name ending in .mul also starts at 1; everything else starts at 0.

Currencies and earning

CallWhat
Inc.earn(currency, amount, source?)Applies earn x earn.<currency> x source.<source> and returns the amount credited.
Inc.give(currency, amount, source?)Adds with no multipliers (rewards, refunds).
Inc.spend(currency, amount, reason?, cb?) / Inc.canAfford / Inc.availableSpend if possible. A currency in an economyKit wallet answers nil, "pending" and cb(ok, info) later ("spent" or "spendRefused").
Inc.balance(c), Inc.earned(c)Held; lifetime and this-run totals.
Inc.multiplier(c, source?)The multiplier earn would apply.
Inc.currencies(), Inc.currency(id)Definitions.

Upgrades and bulk buying

CallWhat
Inc.quote(id, amount)amount = 1, 10, 25, any number, or "max": { count, cost, affordable, maxed, locked, level, nextLevel, currency }. The cost is the exact sum of the per-level prices, capped at maxLevel.
Inc.buy(id, amount)Returns ok and the quote, or false and "locked" / "maxed" / "poor" / "pending". Priced in an economyKit wallet it returns nil, "pending" and grants the levels ("bought") only once the bank took the money, else fires "buyRefused" { text }.
Inc.cost(id), Inc.level(id), Inc.setLevel(id, n)Price of the next level; level; set it.
Inc.isUnlocked(id), Inc.progressOf(conds)Requirements met; progress { done, share, text }.
Inc.upgrades({ shop, category }), Inc.categories(shop)Lists.
Inc.effectText(id, levels)"+1 Push Power", "x2 Coins", "+3/s Coins".
Inc.effectChange(id, levels) / Inc.effectChangeText(id, levels, sep)What levels more levels change, in real numbers: rows { kind = "stat" | "rate" | "label" | "preview", name, now, next, nowText, nextText, delta, text, maxed }, text "Shove 3 -> 4 (+33%)" (an effect label is the bracket; the upgrade's preview(level) adds a row).
Inc.lockInfo(id)Why it is locked: { locked, share, text, excludedBy }.

Exclusive choices and respec

Upgrades with the same exclusive = "group" are a choice ("tougher parts" or "weaker parts"): once one has a level, the others are locked (Inc.isUnlocked false, Inc.buy answers "locked", Inc.excludedBy(id) names the one chosen). Name and price the choice in setup: exclusives = { parts = { name = "Part strength", respecCost = 500, respecCurrency = "coins", refund = 0.5 } } (respec = false makes the choice final; the respec is free when no cost is given, and refunds everything when no refund is given).

CallWhat
Inc.exclusiveGroup(group) / Inc.exclusiveGroups(){ id, name, options, chosen, respec = { enabled, cost, currency, refund } }.
Inc.respecQuote(group){ can, reason ("none chosen" | "disabled" | "poor" | "pending"), chosen, cost, currency, resets = { ids }, refunds = { [currency] = amount } }. resets is the chosen upgrade plus every owned upgrade that needs it (directly or further down).
Inc.respec(group)Pays, resets those upgrades to 0, refunds, fires "respec", saves. Returns ok, the quote (or false and the reason; nil, "pending" with the price in an economyKit wallet).

Price curves

Pick one per upgrade with curve = "<name>" and curveParams; baseCost is the first level's price. require("incrementalKit.curves") gives cost, total, maxAffordable, list, and define(name, fn) for your own named curve.

CurvePrice of level n → n+1Params (default)Feels like
linearbase + step·nstep (= base)calm, predictable
exponentialbase · rate^nrate (1.15)classic idle: 1.07 gentle, 1.15 Cookie Clicker
polynomialbase · (n+1)^powerpower (2)prestige shops
fibonaccibase · F(n+2): 1, 2, 3, 5, 8 …~x1.618 a level
steppedbase · rate^n · jump^⌊n/every⌋rate (1), jump (10), every (10)clear tiers
softcaplogistic S-curve from base to maxmax (base·1000), mid (25), steep (0.2)buy forever
superexpbase · rate^n · accel^(n(n−1)/2)rate (1.15), accel (1.01)a wall that forces prestige
constantbaseconsumables
customyour function(n, params) or curveParams.table = { prices }anything

Aliases work: classic, geometric, tiered, logistic, soft-capped, super-exponential, quadratic, fib …

Prestige

prestige = { currency, from, formula, divisor, scale, threshold, basis, bonusPer, bonusFrom, multiplier, resets, resetRecords, minGain, name, verb }.

  • formula: "sqrt" (scale·√(earned/divisor)), "cbrt", "log" (scale·(log10(earned/divisor)+1) once earned ≥ divisor), "linear" (scale·(earned − threshold)/divisor over the threshold), or function(earned, Inc).
  • basis: "run" (default: what from earned since the last prestige) or "lifetime".
  • Permanent multiplier: every point gives bonusPer (0.1 = +10%) on all earnings, counted from points earned (bonusFrom = "earned", spending them in the prestige shop does not hurt) or held; or your own multiplier = function(Inc).
  • Resets: the currencies in resets (default { from }), every upgrade with resetsOnPrestige (default: main-shop ones), milestones marked resetsOnPrestige, this run's totals, and resetRecords.
  • The prestige shop: upgrades with shop = "prestige" (priced in the prestige currency, never reset).

Inc.prestigePreview() → { can, gain, basis, next (earnings for one more point), multiplier, newMultiplier, resets = { currencies, upgrades }, prestiges }. Inc.prestige() does it. Inc.prestiges() counts them.

Idle and offline earnings

Inc.idleRate(currency) / Inc.idleRates() is per-second production (all multipliers, through source.idle). Generators pay out every frame while playing. When a player returns, time away (wall clock, from their saved lastSeen) pays rate x min(away, maxHours x offlineHours.mul) x efficiency x offline; offline = { enabled, maxHours = 8, efficiency = 0.5, minSeconds = 60 }. Inc.offlinePending() shows it, Inc.claimOffline(mult?) collects (mult 2 for a "double it" button), Inc.simulateAway(seconds) tests it. The welcome-back screen opens by itself.

Milestones, records, counters

Inc.record(name, value) keeps the best (true when it is a new best), Inc.best(name); Inc.count(name, delta) / Inc.counter(name) for lifetime counters; Inc.milestones() lists { def, done, at, progress }; Inc.hasMilestone(id). Milestones are checked after every change and fire a toast.

Big numbers

Inc.format(n, style?), Inc.setNumberStyle(style) (saved per player), Inc.numberStyles(); the formatter itself is Inc.numbers (require("incrementalKit.numbers"): format, rate, delta, duration, percent, grouped, setStyle, STYLES, INFO). Setting a base style also sets productionKit's, so a game using both kits writes numbers one way.

Style12,340,000,000,000 reads
short12.3T (K M B T Qa Qi Sx … up to 1e303)
letters12.3T, then aa, ab … zz
scientific1.23e13
engineering12.3e12
words12.3 trillion
si12.3T (k M G T P E Z Y R Q)
myriad12.3chō (Japanese 10^4 groups in romaji: man, oku, chō, kei …)
kanji12.3兆 (needs a CJK font)
grouped12,340,000,000,000

Saving and multiplayer

Each player's progress is saved in their own data store (runtime_data.player(id) through saveKit's store) under incrementalKit/<namespace>, a few seconds after any change, on prestige, on claiming offline earnings, and when play stops; it is back when they return. Each machine runs the kit for its own player only and the engine refuses writes to anyone else's store, so several players in one world each keep their own game and nobody's actions can change another's progress. Call Inc.earn / Inc.buy on the machine of the player who earned or bought (in a component, only for the local player: if Inc.isMine(player) then ... end).

  • Inc.card() / Inc.cardOf(userId): a public card (name, prestiges, records, lifetime totals) for leaderboards.
  • Inc.save(), Inc.status() ("memory" until the player's identity arrives, then "ready"; progress made before carries over), Inc.reset().
  • Inc.useStore(store) / Inc.memoryStore(): save somewhere else (tests, a simulated second player).
  • version and migrations = { [1] = function(save) ... end } upgrade old saves.

Screens and looks

Inc.ui:

CallWhat
setLook(name, overrides?)One of the nine looks; `overrides = { colors = { accent, buy, panel, ink, ... }, font = "anton"
`open("shop""prestige"
hint(text, { once, duration, icon })A teaching bubble at the bottom (once per player with once).
toast(text, { sub, icon, color, duration })A message card at the top.
showHud(bool), setBulk(n)
configure({ hud, hudButtons, toasts, autoWelcome, autoHints, shopTitle, prestigeTitle, milestonesTitle, welcomeTitle, bulk, hudCorner, doubleOffline = { currency, cost }, keys })
look()Current look id and its palette, fonts and builders, to style your own UI to match.
shopData(shop, bulk), build(name, w, h)Everything a screen shows, or its widget tree, for a game that draws its own.
layoutOf(shop), treeData(shop, bulk, style)The layout a shop draws now ("list" / "tree", and the tree style), and the tree as data (incrementalKit.tree's layout with each node's shopData row and each edge's met).
select(id), selected(shop), pan(dx, dy), zoom(factor | "fit")Drive the tree shop the way a tap, a drag and the zoom buttons do.

The upgrade tree

Inc.setup({
    -- ...
    shops = { main = { layout = "tree" } },             -- or treeStyle = "radial"
    exclusives = { parts = { name = "Part strength", respecCost = 500 } },
    upgrades = {
        { id = "shove", name = "Shove", category = "Push", baseCost = 10, effect = { stat = "shove", op = "add", perLevel = 1 } },
        { id = "tough", name = "Tougher Parts", category = "Push", exclusive = "parts", baseCost = 200,
          requires = { upgrade = "shove", level = 3 }, effect = { stat = "shove", op = "pct", perLevel = 12, label = "+12% push" } },
        { id = "weak", name = "Weaker Parts", category = "Push", exclusive = "parts", baseCost = 200,
          requires = { upgrade = "shove", level = 3 }, effect = { stat = "wobble", op = "add", perLevel = 1 },
          preview = function(level) return "Parts break at " .. (100 - level * 10) .. "% force" end },
    },
})

Each category is a branch (a column band, or a ring sector with treeStyle = "radial"), and a node's row is how deep its chain of upgrade prerequisites goes, so edges always run downward (outward). Options of one exclusive group sit side by side with a gold OR between them and a PICK 1 badge. On a screen under 640 points wide the detail panel sits under the tree.

LookCharacter
cleanbright modern cards, soft shadows, rounded
cartoonthick ink outlines, chunky offset shadows, springy bounce
pixelhard 8-bit frames, square buttons, stepped motion, monospace
neon (sci-fi)chamfered glass over deep space, cyan glow, scanlines
parchment (fantasy)aged scroll, inked borders, serif italics, wax-seal buttons
papercraftpaper layers, washi tape, dashed stitching, a hand-made tilt
minimalblack on white, hairlines, spaced capitals, one red accent
candy (arcade)bubblegum gradients, candy stripes, glossy jelly buttons
luxeblack lacquer and gold leaf, serif capitals

require("incrementalKit.looks").define(name, base, spec) adds your own.

Input. Mouse and touch press any button; the d-pad and the arrow keys move focus through the open screen's buttons (the first buy button is focused when a screen opens) and Enter / Space / A press. In a tree shop the arrows and d-pad move the selected node instead (Buy stays focused, so A / Enter buys it), drag pans, the wheel, +/- and LT / RT zoom. The host adds Esc / Backspace / pad B to close, Q / E and LB / RB to switch tabs, 1-4 and pad Y for the bulk amount, B and P to open the shop and prestige screens (configure({ keys = false }) turns these off, setup({ hotkeys = false }) only the B / P toggles). Screens under 640 points wide stack cards with full-width buy buttons and stack the HUD.

First minute. Hints point a new player at the shop the first time something is affordable, and at prestige the first time it pays; affordable buy buttons glow and pulse, and the shop button and tabs carry a green dot.

What it ships

PartWhat
inc.moduleThe API above.
curves.moduleThe price curves and bulk maths.
numbers.moduleThe nine big-number styles (productionKit.numbers plus si, myriad, kanji, grouped).
ui.moduleThe screens.
tree.moduleThe upgrade tree's layout builder (bands, depths, edges, radial rings, d-pad neighbours), pure data.
looks.moduleThe nine looks.
icons.moduleSVG icons (coin, gem, star, shard, bolt, gear, pickaxe, clock, crown, rocket, flame, shield, heart, trophy, lock, sparkle, chart, magnet, boot, dice, stairs, ragdoll, hand, factory, tree, moon …) plus menusKit's.
IncHost.componentThe host the kit spawns in play (again every play session).
two guidesSee Guides.

Performance

Measured in the demo (13 upgrades, 6 milestones, 3 currencies): the per-frame tick costs about 9 µs, the screens' per-frame upkeep about 16 µs, a HUD rebuild about 90 µs and a full shop rebuild about 0.3 ms. Screens are rebuilt only when something they show changes, and idle income redraws at most 4 times a second.

Known limits

  • Numbers are doubles: exact to 2^53, readable to about 1.8e308 (shown as ∞ beyond). No arbitrary-precision mode.
  • Offline time is the wall clock between saves; a player who changes their device clock can move it.
  • Bulk "max" and totals sum level by level (up to 100,000 levels per call), which keeps them exact for every curve.
  • Editing inc.module while playing reloads it with no setup; leave and re-enter play after changing kit code.
  • The kanji number style needs a font with CJK glyphs; the engine's bundled fonts have none.