Skip to content

Kiln 0.2.0-dev.29

Pre-release
Pre-release

Choose a tag to compare

@frostdev-ops frostdev-ops released this 16 Nov 00:04

Kiln 0.2.0-dev.29

OnBoot now runs in a player's game, not only on a dedicated server. In 0.2.0-dev.28 a mod with "boot" (for example More Flame Altars) loaded on a dedicated server but not in a game that hosts a world or joins a server, unless "preview" was set in kiln.json. That was a mistake in the release: the capability had been tested in a real game and should have shipped on.

Also in this release: building-material pools, same-step impact natives and EffectBlock.Run, client-world programs and program wraps, typed hooks, cancelable death, pickup and equip events, component watches, equipment sets, an NPC roster of up to 93 mod NPCs, room for 4,096 mod buffs, and a VFX budget mods can read. The launcher keeps the version you had when a mod updates and can roll it back, replaces a mod's DLL without rebuilding its zip, and says why when Kiln stops a start. Fixes from player reports: autosave hitches on hard drives, the pause menu running off the screen, /noclip and rules.json (thanks to bisdat), ShroudForge's EML copies and spawning beside Kiln, and more. Nothing ships held: every capability is on, and the section "On, not yet confirmed in a real game" lists what only a game can confirm.

Players

  • Boot mods load in your game. A mod that changes the game's data before the game reads it (More Flame Altars and others built on OnBoot) now works in a world you host and when you join a server, with no setting. If you added "preview": ["mods.boot.client", "mods.boot.resource_patches"] to kiln/kiln.json for dev.28, it is no longer needed; leaving it does no harm.
  • Server owners: when Kiln stops a server's start (exit status 1, 2 or 3 under Wine, 19201, 19202 or 19203 on Windows: a boot mod that is required failed, the mods' NPC roster does not fit, or the mods' NPCs and quests could not be built at all), do not restart it; fix the mod list. kiln.log and kiln/state/ say which mods. The release's kiln@.service no longer restarts on these three statuses (RestartPreventExitStatus=1 2 3); tell a hosting panel the same. Under Wine statuses 1, 2 and 3 also come from ordinary failures, so a server kept down this way may have failed for another reason: read kiln.log before starting it again.
  • A dedicated server that runs a boot mod its players need no longer turns away players who have Kiln and the mod: their game now loads it.
  • When ShroudForge's own loader is in the game folder, Kiln says so. The Engines view's ShroudForge row names the loader file, and the mod list shows one notice when your profile has ShroudForge mods. If that loader runs, Kiln's ShroudForge steps aside and ShroudForge reads its own mods folder: your profile's switches still update the ShroudForge mods Kiln placed there, while folders you put there yourself keep their own switches. The way out is in the notice (remove that file, or let Kiln manage ShroudForge). kiln.log says at each start whether that loader actually ran. Nothing about what loads has changed.
  • When Kiln stops the game's start, the launcher says why. Kiln ends a start before any world loads when going on would cost a world its mods' progress (the mods' NPCs do not fit the Survivors roster, the mods' NPCs and quests could not be built at all, or a boot mod the profile requires failed). Where the launcher used to go back to Play as if you had quit, it now shows "Kiln stopped the start" with the reason, the mods by name and a button to the mod list filtered to them; kilnctl run, start and status print the same reason.
  • Updating a mod keeps the version you had. After an update, the mod's menu in the launcher offers "Roll back to " when Kiln could keep the earlier version (not with 0 versions to keep, or when the disk check refuses). For a mod Kiln placed in the game folder, its earlier version comes back with the settings files Kiln could keep at the update. A Kiln mod's profile settings stay as they are, and the update says when a settings file could not be kept. Kiln keeps one earlier version per mod and profile by default (Settings, "Earlier versions to keep", 0 to 5; kilnctl library rollback does the same from a terminal). A setting you change after a roll back stays yours: Kiln only puts back a settings file that is still as it was before the roll back. If the launcher or the PC stops in the middle of an update or a roll back, the next start recovers interrupted rollback records, owned-copy replacements and settings restores when it can still verify them. If it cannot, it keeps the recovery files and says what needs attention; a partial first placement or a damaged copy can need manual repair. Not covered: a real power cut has not been tested (only the order in which things are written), and a mod whose folder you placed by hand is never taken over.
  • Replace a mod's DLL without rebuilding its zip. A native DLL mod from the Library that is in your profile has Replace DLL… in its menu: choose the patched DLL you got from the mod's author or its forum, and Kiln makes a new build of the same mod with that file swapped. The mod keeps its place in your list, its switch and its settings. By default the build you had is kept for Roll back to … (earlier build), with the same Earlier versions to keep setting as an update. If keeping it is switched off or the disk check refuses, the result says so and the old build remains an ordinary Library version. Adding a bare DLL as before still makes a new mod. Not run on Windows yet.
  • A way out when another mod loader left its files in the game folder. If Kiln's EML mods all fail because the game folder holds game data and backups another loader made, the launcher's Engines view (Logs, Engines) now offers Restore the game's data: verify the game files in Steam, then Kiln lists the leftover files and moves them into a folder under kiln/eml/displaced. Nothing is deleted, and Undo move puts them back. If Steam repaired files, start the game once more before the move: Kiln reads the list of leftover files at a start. It is not offered while ShroudForge prepares the game's data for your profile, and it has not run on Windows or on a real game folder yet: if it does not appear or refuses, the manual way still works (move the extra enshrouded_NNN.dat files and the two .bak files out of the game folder).
  • Filter boxes can be cleared. The launcher's filter and search boxes (the mod list, Logs, a server's Mods, its console and Kiln commands, the Catalog and the item search) have a clear (X) button while they hold text, and Esc empties them. Esc in an empty box still closes the dialog it is in.
  • Linux, without Kiln's launcher: starting the game from Bottles, Lutris or plain Wine needs dinput8 set to native, builtin. With Ultimate ASI Loader next to Kiln, set xinput9_1_0 as well (WINEDLLOVERRIDES="dinput8,xinput9_1_0=n,b"). engines.md says what was tested.
  • Linux (Wine, Proton): when Wine loads its own copy of a DLL in place of one Kiln chains (Ultimate ASI Loader as xinput9_1_0.dll is the known case), kiln/logs/proxy.log (or kiln.log for a [late] DLL) now says so and names the override to set, for example WINEDLLOVERRIDES="xinput9_1_0=n,b". Before, the log said "loaded" while the mod never ran.
  • Mods can swap a whole set of gear at once: they apply supported sets of equipment in one transaction (on this game build some sets that swap several filled slots must be split into two). If a transaction leaves the inventory in an unknown state, Kiln warns and switches equips off until the server or the hosting game restarts.
  • Mods can add up to 93 recruitable NPCs (29 before). A world whose mods add more than 29 needs Kiln 0.2.0-dev.29 or later on the server and in every player's game: an older Kiln refuses those mods' NPCs and quests, and that world loses their progress once it is saved. If your mods add more NPCs to the Survivors roster than Kiln can hold on your game, the game now closes at its start and names the mods, before any world loads, so your save keeps its progress.
  • Boot mods are compared when you join a server. When both sides send their fingerprints, Kiln checks that each boot mod both sides run in the same version made the same game data in your game as on the server, for example the Flame Altar limit More Flame Altars takes from its settings. Optional mods and fingerprints that do not fit the join message are left out, and older Kiln builds do not compare them. If your settings differ, a server with the normal setting lets you join with a warning that names the mod (a server set to refuse turns you away with the same message, and a server can switch this check off): use the server's settings of that mod and restart the game. Not yet seen between a real server and a real game: if you get this warning with the same settings as the server, tell us.
  • Mods can give their own wall and roof shapes their own list of materials to pick from in the build menu, while the game's own build menus stay as they are. If you have no such mod, nothing changes for you.
  • Servers can carry many more mod buffs (room for 4,096 added buffs, 1,024 before). Joining such a server needs Kiln. Whether you also need its mods installed depends on what those mods require. If your game cannot hold as many added buffs as the server uses, the server now turns you away at the join and says how many it uses and how much room your game has, where before you could get in and see wrong or missing buffs.
  • Shroudlink mods without the client addon. When a profile switches Shroudlink mods on in a game client but does not load Shroudlink's client addon, the mods list says that the mods still run and that the in-game MODS tab needs the addon, and offers to switch the addon on when it is in the Library. A support report names it too.
  • On a fresh game start, a single-player or hosted world without item mods no longer needs Kiln's item lookup hook. Kiln hooks it only when you join a server, where items from mods you don't have show as [Unknown item], or when your mods add items. Once a joined world or an item mod needs it, the hook stays until you close the game. On a hosted world it uses the installer that first checks every game thread is clear, and skips the hook for that world if it can't.
  • Support reports include kiln/logs/tick-stats.jsonl (Kiln's step times per minute and world), so a slow session can be told apart from a stall at save time.
  • The pause menu scrolls when its entries are taller than the screen, so Quit to Desktop stays reachable at every resolution with Kiln's and other mods' entries (SET's tools and Creative pushed it off a 1280x720 or 1080p screen); a menu that fits is drawn as the game draws it.

Mod authors

  • The mod API is 0.2.4. Everything new is additive: no public member of 0.2.0-dev.28 was removed or changed.
  • New: events a mod can refuse (kiln.decisions). EntityDyingEvent (a death from health), ItemPickingUpEvent (a walk-over pickup) and PlayerEquippingEvent (an equipment input) can be canceled by a listener; the game's own handling runs when nobody cancels or a listener does not answer in time. The hooks go in at your first Events.On (the capability reads pending, then available; if they cannot be placed safely the row lowers and CapabilityChangedEvent tells you). Only the server world's deaths and pickups are held. A refused death keeps the entity alive after one or two steps at 0 health; a walk-over allow is one attempt, and a failed one (no room) asks again. A fault shuts the service down for the process. Open decisions end CapabilityReleased if the broker remains usable; otherwise managed decisions already dispatched end locally and native sinks are not told. A rollback of entity ids ends them StaleEntity. Guide: docs/kiln/services/decisions.md; sample mods/samples/Decisions.
  • New Kiln.Systems: wrap the game's own ECS programs. Systems.Wrap("fuel_setup") runs your code before, after or instead of one of the game's programs, by name, per slice (Before, After, Replace) or per entity (BeforeEach, AfterEach with an EntityView: Has, Read, Write, Attribute), in the program's own place and on its own thread. Writes through a view reach the save and other players and raise ComponentWrittenEvent with Writer = "<modid>/wrap:<program>"; Attribute32.Changed runs the game's attribute formulas. Handlers can run on the game's worker threads as soon as a player is in the server world, and client-world programs use workers too: tick-thread APIs throw inside them, use slice.Post. One Replace per program (a second is refused and names the holder); wraps are refused while native SET is loaded. A throw turns off that stage only (both halves of an AroundEach). Guide: docs/kiln/modding/ecs-programs.md, "Wrapping the game's programs".
  • Typed program wraps. Systems.Wrap<Ecs.Programs.FuelSetup>() gives a per-entity stage a typed view of one of the game's programs and its components (802 views on this game build, in Kiln.Game, under Ecs.Programs), checked against the running game: a program a game update changed is refused, and the reason names the lists that changed; a component whose layout changed is refused before it is read or written. AroundEach(capture, apply) runs your code on each entity just before and just after the game's own update. Sample: mods/samples/WaterWorks (wells refill faster); template: kiln new system-wrap.
  • WhenArchetype now matches on a real server (in the first build of Kiln.Systems it matched nothing there), and a filter that cannot decide turns its stage off with a reason instead of skipping every slice. The filter reads each slice's archetype from the game's own record of that slice (a link around the game's program runner, put in a step after the first stage asks; the record is taken for one call and restored on every way out). On a server, until that link is in or where it cannot be resolved, it falls back to the entity map, checking it again after the read: when three reads in a row saw the map change under them, that one slice is left to the game (counted in WrapStats.ArchetypeSkips, said once per stage in kiln.log) and the stage stays on; the fallback narrows the window, it does not close it, and relies on the game applying entity creation and removal at the end of its step. In a game client the filter never reads the entity map: it leaves a slice to the game until that slice's own record can be read, and turns itself off with a reason where it cannot.
  • A world's stop waits for the world's jobs on a game client too. When you leave a world, Kiln now calls the game's own wait for that world's jobs before mods hear the world stop, as it already did on a server, and the game never lets a program's slice run past the step that started it; so a wrap stage or a client-world program is not still running when its world is freed. The rows world.stop_drain.server, .client and .prediction say whether this build has that wait; where it is missing, wraps have a 2-second safety wait only, which does not keep the world alive. The wait itself has no time limit: if it ever stalls, kiln.log says "still waiting for world jobs" after 5 seconds and then more rarely. If Kiln's tick hook faults, program wraps close admission at their next slice and the game's own updates run as without Kiln; a stage already running finishes.
  • Spawn and Destroy called inside a program wrap's stage or a Kiln ECS program are refused, on the world's own thread too, with a message that names slice.Post (or Scheduler.Post): creating an entity in the middle of the world's step changes the entity map under the game's workers. Inside a GameSystems.Hook callback such calls still go through as in 0.2.0-dev.28, with a warning in kiln.log once per mod and call kind (once per call kind for a native caller); EMF's own hook_program refuses them as upstream EMF does.
  • Program wraps run under dotnet test. KilnHarness.Programs declares the game programs your mod wraps, or a Kiln.Game view with its contract, and each harness step runs your stages over the fake world's entities (Before, Replace or the update, After, per-entity views, marks, WhenArchetype, ComponentWrittenEvent). The kit times each stage against the 1 ms budget and turns a stage off after ten overruns in a row, as the game side does; it does not model Systems.Define, client-world wraps, the worker threads or a native fault.
  • Systems.Define: a program of your own. Write a [Query] struct; the build writes it into kiln.programs.json (a wrong entry stops the build with KILN036), kiln.world reserves it when the server starts, and Systems.Define<T>(key, options, each) binds your handler, which then runs once per matching entity on the game's workers. A key that was not reserved at boot answers Ok = false ("rebuild the mod and restart the server"), and so does a [Query] that differs from what was reserved at boot (another filter, another required or optional component, other flags): the answer names the first difference, because a rebuilt declaration is in the game only after a server restart. Your handler cannot call tick-only APIs while it runs, as in a wrap. systems.define says whether it is available.
  • A per-entity stage whose program lists could not be read in time is suspended with the reason and tried again at the next steps (eight times) before it is turned off; it used to be off for good after one miss.
  • The SDK's programs step: removing the last [Query] removes the generated kiln.programs.json from the output, an unchanged file is not rewritten, and two [Query] structs with one key stop the build (KILN036).
  • WhenArchetype checks that the entity's record still names the entity it looked up before it trusts the record: the game frees a removed entity's record at once and may hand it to a new entity. A record that now names another entity is read again, three times in all, and then that one slice is left to the game; the stage goes off with a reason only when the filter cannot decide at all on this build (no archetype to read, or an unknown component name).
  • In a game client, new WrapOptions { World = WorldKind.Client } wraps the client world's programs.
  • kiln.mod.json takes "systems": { "replaces": [...] } (a declaration for tools; nothing reads it yet).
  • Native mods: kiln.world gains register_program_world, program_world_state, bind_program_world and unbind_program_world at offsets 496 to 520, after the foreign views (the table is 528 bytes, version 4 stays).
  • Native mods: kiln.world v4 gains per-entity members for a wrap stage (game_program_list, game_slice_iterate, _slot, _mark, _archetype, game_archetype_has, game_slice_attr_changed, game_slice_attr_validate, game_world_session, game_program_contract), appended after in_program. Before you free anything a stage uses, call game_wraps_release and poll it until nothing is pending.
  • Typed hooks and typed calls (Kiln.Sigs, Hooks.Detour, Invoke). A typed hook is written into the game only after Kiln has checked every game thread: one asked for during a step is pending until the next safe tick (HookResult.Pending, HookHandle.State, HookHandle.Reason), and if the threads cannot be checked Kiln tries at three safe ticks, then the handle says Refused with the reason and HookRefusedEvent is posted. Invoke checks the descriptor it was compiled with against the game it runs in before it calls. An exception in a handler is caught and the game gets the original's result, also a result returned in a buffer. A null reference in a handler's own C# code is caught like any exception; any other access violation (in native code the handler calls, or at another address) still ends the game, as anywhere in managed code. While a world is running, typed hooks go in at safe ticks, with at most four installation attempts admitted in each 5 ms window (each first hook on a game function briefly stops the game's other threads for the check); a long Pre can admit more than four. With no world running there is no limit. On a lab server, GetItemVolume through Invoke took about 0.6 µs a call, with a pass-through hook adding about 10 ns in that run.
  • Impact natives that answer in the same step. Abilities.Natives.RegisterSync registers a native that answers inside the program's call (server only, abilities.natives.sync); the older natives still suspend the program for one step. Abilities.Natives.Attach hooks a vanilla native's calls in one program at one call site, Before, Instead or After, without cloning the program (abilities.natives.attach); Natives.Wrap and OnDamage now run through it, unchanged. A natives.json entry with "sync": true binds its argument types: Kiln and the cook refuse mismatched programs (E_ARGTYPE) and every call is checked; Natives.DeclareTyped does the same from C#. Kiln's two built-in natives and all mods' natives share 21 entries of the game's native registry (it takes 128, 107 of them the game's own), so 19 are left for mods: a registration past that is refused with the reason, where before it was silently left out.
  • Watch components for changes (ComponentChanges.Watch, Kiln.World). A watch covers Health, Stamina, Mana, Fuel, Inventory and SlotSelection of up to 128 entities, or of every player, optionally with their linked inventories and items. Each step it posts one ComponentValueChangedEvent per changed component with the bytes before and after and an origin: Kiln with the writer's id (your mod, kiln.combat, kiln.items), Mixed, or Unknown; a change is never called the game's. AttributeValueChangedEvent carries typed values, ComponentWatchStateChangedEvent says when a watch is suspended and why. It is a net-change observer of the server world: a component larger than 256 bytes reads as absent, a watch that joins a pair another watch already covers splits that step into two records, and an item that left and came back unseen with the same id cannot be told from the one before. Budgets are shared by all mods, first come first served: 32 watches, 4,096 present pairs, 128 roots a pair; a watch that does not fit is refused with the reason and one that grows past them is suspended whole. Nothing runs for it unless a mod watches; writers pay only for watched entities (events.component_net; the test kit fakes it with KilnHarness.ComponentChanges).
  • Your own ECS program in the player's client world. A client or both mod can run a program in the client world or in the prediction storage: declare it in kiln.programs.json with "world": "client", "both" or "prediction" (a file without the field means the server world, as before) and bind it with EcsPrograms.TryBind(key, callback, WorldKind.Client) in OnLoad. It runs in that player's game only; other players and vanilla clients see nothing of it. In a client world or the prediction storage TryWrite does not mark the write for the save or for replication, and TryWriteOther answers false. The native side follows: in a client program mark_written does nothing, and foreign_write and foreign_attr_changed refuse. A bind in a process whose client programs were switched off throws KilnUnavailableException with the reason, and a client callback that threw is reported again in every later client world. EcsProgramRefusedEvent and ClientComponentWrittenEvent are raised on the game's main thread in the client world's next Pre; events of a client world that has ended are dropped. A declaration rebuilt for another world needs a game restart. New template kiln-client-program, analyzer rule KILN109, lint and SDK checks for "world" (world.programs.client).
  • EMF mods: register_program, register_program_def and on_event with EMF_WORLD_CLIENT now run in the client world, hosted or joined; a dedicated server refuses them as before.
  • Building-material pools (BuildingMaterialPoolBlock). A pool, in blocks/*.json or in code, lists 1 to 64 building materials (yours, or the game's by GameMaterials name) in menu order, and BlueprintBlock.MaterialPool gives your own shape that list; the game's shapes keep their lists, and a pool's own (or a dependency's) materials leave the game's selectors only while the pool is accepted. A pool that names the same block twice or mixes roof and wall materials is refused with the entries named. Pools are read at game or server start only (a pool defined later is stored for the next start, with a receipt like buffs and VFX) and need clients: mod; a player whose pools or bindings differ from the server's is refused at the join before any block data is sent, with differing or missing pools named (older peers keep the generic text). Stored pools are pruned when their loaded mod no longer defines them; WorldTables.RemoveStoredMaterialPool removes one by name. kiln lint checks pools (KL334). C# world-table blocks keep their runtime next-start behavior by default; KilnBakeWorldTables=true explicitly bakes an offline snapshot into the mod for its first start. WorldTables budgets say how many material ids and pool entries are left (worldtables.material_pools, worldtables.budgets; the test kit fakes both).
  • A native can read and write other entities. Inside a same-step native, NativeContext.TryRead<T> and TryWrite<T> reach the components that the game's Impact program itself declares, on any entity (the caster's target, for example), in the same step; a type the program does not declare answers false and touches nothing. A write raises ComponentWrittenEvent with Writer = "<modid>/native:<name>", and writing an attribute type runs the game's attribute formulas. NativeContext.Post defers work to the tick thread. Kiln checks its view of the program against the running game at the first native call of each world and keeps the feature off when it does not match, and it is on only while the game runs that program serially on the world's thread, as the shipped game does (abilities.natives.ecs, server only). A write that faults is not rolled back, and the write-event queue is bounded.
  • A block effect can run your native first. EffectBlock.Run (JSON "run") names an [ImpactNative] method (Natives.<Name>, or a native from a mod's impact/natives.json); the effect's program calls it first, in the same step, with its parameters bound by name (self, target, attacker, caster, position, attackMod, damage), so a weapon's or a perk's additional hit can change its own attackMod before that effect's damage is dealt. kiln-manage lint reports a parameter that binds to nothing as KL340. Server only; damage needs damage in the effect, and attackMod needs damage or knockback, unless the parameter is Optional.
  • Sample and unit tests for natives. mods/samples/FrostMark is a sword whose added Ice hit runs an [ImpactNative] and deals 1.5 times its damage when the target is below a quarter of its health (the sword's ordinary strike stays unchanged), with an attachment that counts the Fireball explosion's applyDamage calls (/frostmark). Kiln.TestKit's kiln.ImpactNatives runs your [ImpactNative] methods, RegisterSync natives and attachments offline: the test declares the game programs it attaches to (AddProgram) and makes each call itself (Call); programs, attributes and their formulas stay offline.
  • abilities.natives.sync and abilities.natives.attach are decided before your mod's OnLoad, so if (Capabilities.Is("abilities.natives.attach")) Abilities.Natives.Attach(...) works there; an attachment made then is Pending until the world's programs are in.
  • Native mods: kiln_world.h and kiln_abilities.h no longer both define KilnProgramInfo: the structs are KilnWorldProgramInfo and KilnImpactProgramInfo, and the old name stays as an alias in whichever header you include first, so a plugin can include both.
  • [ImpactNative]: a C# method becomes an Impact native. Put [ImpactNative] on a static method with typed parameters and the build generates its registration as a same-step native, its typed impact/natives.json entry and a Natives.<Name> reference for your programs; a shape it cannot make is a build error (KILN170 to KILN174). See impact.md.
  • Same-step natives and attachments while a mod unloads. A mod's natives and attachments take no new call once the mod unloads or reloads or the world stops, and its OnUnload waits for a call that is still inside: the host keeps the mod, says in kiln.log what it waits for, and unloads it in the first step after the call has left (a reload's new load waits with it; at shutdown the host waits 5 s and then skips that mod's OnUnload rather than run it under the call). Mods without same-step natives or attachments unload as before. (Kiln's own services close their admission in a new internal step before OnUnload; it is not mod API.) A handler still inside after a second is named in kiln.log with its native and its mod: a handler must not block. Abilities.Natives.StateOf (Waiting, Live, Refused, Dead) and NativeAttachment.State (Pending, Active, Off, Gone) say where a native or an attachment stands, and Abilities.Status counts attachments by state. An attachment to a program that is registered later turns on when that program goes in. A native accepted before a world exists that the world then has no room for posts NativeRegistrationRefusedEvent.
  • Equipment sets. Items.CaptureSet reads a player's 20 equipment slots, Items.PlanSet says what applying a set would do without doing it, and Items.EquipSet applies it in one transaction: every slot changes or none does (the one exception is InvariantFailure: the game left the inventory neither as asked nor as before, or faulted inside the transaction; the reason then says the inventory may be in an unknown state, and sets and single equips switch off until the server, or the hosting player's game, restarts), with one PlayerEquippingEvent (a SetEquipmentChange) deciding the whole set, EquipmentSetChangedEvent / EquipmentSetFaultedEvent, and a result that says exactly what changed (items.equip_sets, server side). Sets live for the current world session only; the hotbar and the main hand are not touched. On this game build a set with several direct swaps can be refused before anything changes (UnsupportedSwaps): split it into two sets. Two worn items can exchange slots through a free backpack slot. Backpack changes in a set are refused for now.
  • Buff clones: room for 4,096 per process, all mods together (1,024 before). Content.Buffs.GetBudget() says how much is left. Content.Buffs.Define(clone, new DefinitionRegistrationOptions(...)) answers Registered, AcceptedNextStart or Refused with a code and a reason instead of throwing, and GetRegistration(id) reads the answer later; a definition accepted for the next start is stored under kiln/data/gamedata/pending/<mod>/ and replayed at the next start, once that mod is loaded again: while the mod is switched off or removed its stored definition stays where it is and nothing registers (kiln.log names it once). The store holds at most 4,096 definitions of at most 64 KiB each; Kiln writes it with a flush before the rename, and refuses a link placed at the store's folders or files (the path above kiln/data is yours and may contain links). Define many buffs in a data pack or before the world loads, so they are published together (one table for the batch; a buff defined from code while a world runs still gets a table of its own). New refusals with a reason: buff id 0, a game buff's id, another clone's id, room full. If the larger room cannot be reserved next to the game's data, it stays 1,024 and kiln.log says so (gamedata.expanded_buff_room).
  • VFX resources: a budget you can read, and a definition with an answer (game clients). Vfx.ResourceBudget says how many VFX resources the game holds, how many the game and Kiln's mods use and how many are left (473 for all mods together on this game build), read from the game's own table once a client world runs. Blocks.Define(name, VfxBlock, options) answers registered, accepted for the next start, or refused with a code and a reason, and Blocks.GetVfxRegistration(id) reads the answer later (vfx.budget, blocks.vfx_registration). The game's limit itself is unchanged in this release.
  • The NPC roster holds 128 (the game's 35 included, so 93 for all mods together; 64 before). The game keeps unlock states in one 64-bit value; past 64 entries Kiln keeps a second unlock page beside each world's NPC registry (npcs.expanded_roster), installed only when a mod's roster needs it. A roster this game cannot hold (129 or more, or 65 or more where the page cannot be installed) stops the start before any world loads, the same way with or without boot mods: kiln/state/roster-refused.json, an error line naming the mods, kiln.boot's stop (boot.json boot.stop, progress.json failed), on a game client a message box that closes after 60 seconds, then exit code 0x4B02 (status 2 under Wine). It is a start-time act: once a world has run in the process nothing is stopped. Run Kiln as one matched bundle: an older kiln.knowledge cannot be made to stop. No save is opened without the mods' NPCs and knowledge. kiln.knowledge.npc answers no unlock state (0xff) for any entry of a roster longer than this side's maximum and names it in status.reason; a damaged collection (more than 4,096 entries) is named too, and a roster snapshot after a step whose registry could not be read answers NotReady. A mod's NPCs are ordered by key name, not by file order. New on NativeQuests: GetServerRosterWorld, GetClientRosterWorld, GetUnlock, GetClientUnlock, GetRosterBudget and RosterUnlockChangedEvent read unlock states from per-world snapshots on any thread, with a token that ends with its world (npcs.client_roster_read).
  • World programs: Kiln and all mods together may register 64 (32 before), and one kiln.programs.json may declare 32 (8 before). The last 8 of the 64 are kept for Kiln's own services and loaders. World.GetProgramBudget() reads what is left of Kiln's slots and of the world's own table of 896; kiln.log names who holds each slot.
  • The capacity types of 0.2.0-dev.28 are no longer experimental: NoWarn KILNX028 is not needed any more.
  • Native mods: kiln.hooks gains mid2_checked, validate_typed, sig_status, typed_install_ready and detour_typed_checked (the table is 296 bytes; KILN_HOOKS_ERR_UNCHECKED when a thread could not be checked and nothing was written). kiln.abilities gains native_register_sync, native_counters, native_attach, native_detach, native_declare_typed, native_state, native_attach_state, native_ecs_read and native_ecs_write (312 bytes). kiln.world gains six foreign-view members for services that read other entities from inside a program (foreign_layout, foreign_slot, foreign_check, foreign_read, foreign_write, foreign_attr_changed); the table is 528 bytes after the client-world members. kiln-set accepts any kiln.hooks table that has the members it calls.
  • Native mods: kiln.vfx gains resource_budget, define_vfx_result and vfx_registration (the table is 136 bytes; version 1 stays).
  • Native mods: kiln.items is version 6: set_capture, set_release_snapshot, set_status, set_plan, equip_set, set_cancel appended (288 bytes); version 5 readers are unaffected.
  • Native mods: new services kiln.decisions v1 (the native side of the refusable events) and kiln.window_clock v1 (the core's step-phase clock that decisions and watches share); kiln.build gains terrain_budget_reserve and terrain_budget_charge for the shared terrain budget.
  • Native mods: new service kiln.component_changes v1 (144 bytes): watch, resume, status, remove, watched(entity) and record_write, the one call a native writer adds after a write so that watches can name it. A native reader uses the count read_events returns: a batch it has begun can shrink when a watch ends.
  • Native mods: kiln.boot gains stop_start (appended to its v1 table): a service ends the start with its own exit code, with or without a boot generation; boot.json boot gains stop, issue code StartStopped.
  • When the whole build of the mods' native quests and NPCs fails, the start stops and kiln.log names the mods and what failed (KILN_KNOW_CONTENT_EXIT_CODE, 0x4B03, in kiln_knowledge.h; kiln/state/content-refused.json, schema state-content-refused.schema.json). A kiln.mod.json field of the wrong type in a mod with quests, NPCs or knowledge (for example "side": 5), which before threw away every mod's native quests without a word, now leaves out only that mod and names it in kiln.log (a required boot mod is refused through kiln.boot by name), as an error in your own quests always did. The lab switch kiln/control/knowledge.fail-build forces each kind of whole failure (npcs.md).
  • Native mods: kiln.knowledge gains roster_world, roster_budget and npc_unlock_at (264 bytes), KilnNpcUnlockReply, and the event kind KILN_KNOW_EVENT_ROSTER.
  • Native mods: kiln.worldtables gains material_budget, pool_budget, define_pool_result and pool_registration (the table is 176 bytes; version 1 stays). prune_pending also accepts {"removePools": ["key", ...]}.
  • Native mods: kiln.gamedata gains buff_budget, define_buff_result and buff_registration (the table is 160 bytes; version 1 stays). New service kiln.world.budget v1 (program_budget). kiln.world.budget gains program_reservation (24 bytes).
  • Kept transform scales are set again only where Kiln can tell the entity. After a restart a scale you set with World.SetTransformScale comes back when exactly one entity of that template is at the saved place (0.5 m for placed things, 16 m for creatures and NPCs). With two or more candidates nothing is scaled: the record waits, kiln.log says so once, and World.GetWaitingTransformScales() (new) gives you each waiting record's template, position, scale and reason, so you can call SetTransformScale on the entity you mean. A waiting record is dropped after three sessions. An entity that was destroyed and made again under the same id no longer inherits a scale. In 0.2.0-dev.28 the first entity of the template near the place got the scale, so two identical neighbours could swap.
  • Weapon follow-ups (blocks.move_followups) are published only when they can be played. In a world you host, a weapon's routed moves are applied once the hosted client's sequence registry has them too (up to about eight seconds; then the weapon is refused with the world and the reason, and keeps its unrouted moves). A raw GUID or 0x animation state is now looked up in the animation graph like a named one and refused when it is missing or of the wrong kind. A Kiln player without your mod who receives the weapon through content sync and cannot play its moves keeps the base weapon's moves on their side (one line in their kiln.log); the server still simulates the routed timing.
  • Terrain overlays (terrain.overlays) decide by evidence before they write into a world Kiln has no record of. A world with Kiln's history installs a new plan as before. With no history (Kiln and your mod added to an old world, or a save moved without kiln/data), Terrain.Apply first reads the plan's cells: all already equal, the plan is recorded as Adopted without a write; a quarter or more equal, the result is NeedsAdoption and nothing is written until you choose with TerrainApplyOptions.InstallChoice (Adopt or InstallAnyway); fewer, it installs, and the result says InstalledWithoutProof with the measured PresenceShare. Limit: an overlay of which a player removed more than three quarters is taken as absent and written again. New: TerrainState.NeedsAdoption and Adopted, TerrainInstallChoice, PresenceShare, InstalledWithoutProof, Terrain.Forget(id, restoreTerrain) (restoring is refused: the original cells were never stored).
  • Terrain work shares one budget on the host: 4,096 written and 32,768 read cells per server step and 2 ms of admitted work, in units of at most 512 cells, for every mod's Apply, Inspect and the transient journal's put-back together. CellsPerTick can only lower your share. TerrainChangedEvent now comes per unit. On a lab server a 32,768-cell patch took about 3 s on an idle server (64 steps; about 1 s at 60 steps a second), where 0.2.0-dev.28 wrote it in one 38 ms call: slower, without the hitch.
  • Persistent terrain writes are refused, and terrain.overlays reads unavailable, in a process where Kiln cannot see the world stop; a world counts as running only when it does (not by steps the process has made).
  • At the join, Kiln compares what OnBoot committed for each side: both boot mod (staged definitions and resource patches, also those in blocks/*.json). In OnBoot, read only settings a server and its players share, and stage the same content for every role (boot.Roles). network.md has the rule and what modSync does with a difference.
  • mods.boot.client and mods.boot.resource_patches are open on a game client: Mod.OnBoot, boot definitions and resource patches run there as on a dedicated server. Confirmed in a real game on 0.2.0-dev.28 with More Flame Altars (a hosted world: OnBoot ran, the boot generation was published, and 42 values of altarsPerFlameLevel were patched before the game read them).
  • Compat rules have a new action before: the subject loads before the target (Kiln loads the target late and keeps the subject early). Kiln now ships kiln/compat-rules.json with every update; your own rules go in your config folder, and one with the same id replaces Kiln's. engines/README.md
  • kiln/state/progress.json has a new optional field worldMs (when the game's first world began). On a client, state ready now also comes at the first world once step game has begun.
  • A boot mod's VFX and material files are built at start in a player's game, as every mod's are. Staging VFX or materials into a boot generation is not in this build, and mods.boot.vfx says so on a client ("not in this build").
  • In OnBoot, a PNG icon on a staged item (Visual.Icon) or a game-tree talent (Icon) is read from your mod's folder, as in OnLoad. In 0.2.0-dev.28 it was looked up under the game's kiln folder and the starter's icon stayed (kiln.log: cannot open ...\kiln\icons/...). A missing icon, or one outside the mod's folder, costs only the icon: state/boot.json keeps the refusal (IconRefused), kiln.log says it once when the mod loads, and the SDK's bake warns with it (KILN030). At the join such an icon counts by its place in the mod folder, so players whose game is in another folder still match the server.
  • A game-tree talent's Icon must now be a file inside the mod's folder, in OnLoad too: a path that leaves the folder, a link out of it or a missing file is refused with the line an item's icon gets, and the node keeps the icon of the node it was made like. Before, such a path went to kiln.skills unchecked.
  • kiln lint no longer calls "writes" in kiln.mod.json an unknown key.
  • Build events and build protection: when the hooks go in. kiln.gameplay no longer hooks PlaceBlueprint, PlaceProp, the two dismantles and PickUpProp at start. They go in when a mod needs them: Kiln asks for them before the first world for every mod whose assembly (or a helper DLL it ships) references Kiln.Gameplay, so a C# mod notices nothing. The row gameplay.build_hooks says idle, installed, waiting or refused. A mod loaded for the first time into a running world, or a native plugin that did not ask at start, gets them while that world runs, at its next safe ticks (two functions a tick, so the five take three): its build-event subscription is accepted and delivers once gameplay.build_hooks says installed (nothing earlier is replayed), and until then a zone with build or break denies is refused (KilnUnavailableException naming gameplay.build_hooks) instead of being stored unenforced. Each function written while a world runs stops the game's other threads for a few milliseconds (2 to 9 ms per function on a lab server); kiln.log has one line per function. Where Kiln cannot check all of the game's threads before writing a hook (some Windows PCs), a hook asked for while no world runs goes in as on dev.28, and one asked for during play waits until no world runs (your next menu, or the server's next start) instead of going in unchecked mid-game; kiln.log says which. Native plugins that will add such zones later call the new request_build (KilnGameplayApi, offset 128) or subscribe to build events from kiln_plugin_main.
  • The rest of kiln.gameplay's hooks follow: nothing is hooked at start. CraftRecipe (ItemCraftedEvent), TerraformImpact (terraforming BuildEvents, zones that deny terraforming), QueueSpawn (NaturalSpawnEvent, natural-spawn replacements, zones that deny spawns) and the entity pair CreateEntity/DestroyEntity (EntityJoinLevelEvent, EntityLeaveLevelEvent, WatchEntities) also go in only when a mod needs them, four groups with one row each (gameplay.craft_hooks, gameplay.terraform_hooks, gameplay.spawn_hooks, gameplay.entities_hooks). Kiln asks before the first world for every mod that references Kiln.Gameplay, or Kiln.Creatures, Kiln.Quests or Kiln.Blocks for the groups those use (a Kiln.Rules mod asks only when one of its rule sets keeps builds outside bases), and for data packs with a blocks/ folder, so a mod that worked on dev.28 notices nothing. Like the build group, these four also go in while a world runs, at the next safe tick, and follow the same rule where not every thread can be checked: a subscription made then is accepted and starts delivering once the row says installed (nothing earlier is replayed), a zone with a terraform or spawn deny is refused until then, and a spawn replacement stays registered and takes effect when the hooks are in. Native plugins use the new request_hooks(owner, mask) (appended after request_build; the table is 144 bytes). A player whose mods use none of this now runs with no kiln.gameplay hook in the game at all, which leaves those game functions untouched for other loaders. With a Kiln.Host older than this service, every group goes in at the first world as on dev.28 (kiln.log: no demand-aware host: all gameplay hooks installed as before).
  • Native mods: kiln.ui gains set_next_window_size_constraints(min_w, min_h, max_w, max_h) at the end of its table (896 bytes; version 7 stays): with KILN_UI_WINDOW_ALWAYS_AUTO_RESIZE, an equal minimum and maximum width fixes the width while the height follows the content up to the maximum. Check header.size and the pointer before calling.
  • Guided checks ([ClientCheck]): a failed Expect now decides. A check whose assertion failed can no longer be recorded as passed: answering Pass records Fail, the check says "this check cannot pass: N assertion(s) failed: …", and the ledger entry keeps your answer (playerAnswer), the count (assertionFailureCount) and the reason. A failure in the body or a clean-up after the answer counts too. To show a value without requiring it, pass true as the condition. An older entry that says pass next to a failed assertion is counted as failed in the game's list, in tools/client-checks/report.py and in the status table.
  • The other gate rows are open: assets.blob_catalog, blocks.move_followups, items.tool_wear_debit, queries.ground, queries.line_of_sight, queries.overlap_origins, queries.path, queries.reachability, queries.voxel_ray, systems.wraps.client, terrain.overlays, ui.slots.inspect, ui.values.detail, ui.values.held, ui.values.hud, ui.values.slot, ui.values.tooltip_lines, world.transform_scale. Capabilities.Is / KilnUnavailableException no longer report "game test pending" for them; normal dependencies, side restrictions and faults still apply. Two of the rows 0.2.0-dev.28 held are not features of this build: mods.boot.vfx (above) and repl.client (receiving replication has no implementation yet; its service reports it unavailable).
  • In the pause menu, Auto (the default for mods' entries) now shows every mod's entry whenever the menu can scroll; whether it scrolls depends on the entries' height, not on how many mods add one.
  • kiln/logs/tick-stats.jsonl now says how long the game's own wait for its world jobs, the window services and each Kiln service or plugin took after each step, the slowest Pre subscribers and a breakdown of each minute's worst step, so a slow-motion report names the part that stalls. Kiln.Saves logs at Info when saving or confirming mod data takes over 250 ms, with the time spent forcing files to disk shown apart. Kiln.Host's per-mod stats line shows the longest Pre and Post apart: max Z ms (pre A / post B).

Fixed

  • A start no longer goes on without every mod's NPCs and quests. When Kiln could not build the mods' NPCs, quests and their progress at all (the shared part of the build failing, a game update that moved what Kiln hooks for it, a part of Kiln missing), the game started without any of them, and a world saved then lost every one of those mods' progress. Now Kiln stops the start before any world loads, names the mods and says what failed (exit code 0x4B03, status 3 under Wine, kiln/state/content-refused.json), and the launcher shows it: remove or update those mods, and if it still stops, send kiln/logs/kiln.log. A mod whose own quests have an error still loads without them, and the others are served, unless its boot content is required. A required boot mod still stops the start when its own content fails.
  • One mod with a broken kiln.mod.json no longer takes every mod's NPCs and quests with it. A field of the wrong type in one mod (for example "side": 5) used to throw away the NPCs, quests and knowledge of every mod without a word. Now only that mod is left out, kiln.log names it, and the others are built and served. A required boot mod still stops the start when its own files cannot be read.
  • Launcher: a selection made right after switching profiles was lost. The launcher shows the new profile at once and finishes the switch a moment later; that later step cleared whatever you had selected in the new profile in between, and the "Selected mods" bar vanished under your click. The selection now clears once, when the profile changes.
  • EML mods that bring their own DLL and need ShroudForge to load it (Quiver & Spellbook) now run whole when your profile has no ShroudForge mod: Kiln starts ShroudForge for them by itself. Before, only the mod's data was applied, its extra slots never appeared, and the mod's own page warns that the game drops what is in those slots at the next save in that state. Where ShroudForge cannot run (its part of Kiln is not installed, or you switched it off), the mod is skipped entirely with the reason, never half. After updating, start once and check that the mod's slots are there before you save.
  • ShroudForge mods that spawn things into the world (SpiderHook's grapple, for one) did nothing under Kiln: Kiln changed the start of five of the game's building functions for every player, and ShroudForge reads one of them to find the game's spawn code. Kiln now leaves those functions alone unless one of your Kiln mods uses the gameplay service (build events, protection zones). With such a mod in your profile, the ShroudForge that Kiln ships should find that code anyway: its search reads through a function another module has detoured, and only through one that still belongs to the game's own image (frostdev-ops/shroudforge#1 by AlexK-Notable, with a follow-up of ours). ShroudForge no longer gives up on the game's file because of Kiln's own hooks inside a few functions, its own main-menu button or the game's randomised load address, and it checks a detour's target the way real hooks are written (frostdev-ops/shroudforge#2; Kiln's ShroudForge is now built from that merge). Seen in ShroudForge's own tests and under Wine only, not seen in a game yet: SpiderHook itself has not been run beside a Kiln mod that uses building. kiln.log says which way ShroudForge's check went ([sf] ... executable file accepted ... or refused: <reason>).
  • A visual effect or material a mod defines for the next start is saved whole or not at all: a crash during the save no longer leaves a broken file behind.
  • EMF mod windows grow with what is in them. A window of an EMF mod (the Beastmaster stable, for one) kept the height it had when it opened, so a list that filled in afterwards needed a manual resize or scrolling. It now follows its content, up to 85 % of the screen height, and scrolls past that, as under EMF's own loader. Not looked at in a game yet.
  • Frame generation mods (NVIDIA Streamline) no longer crash the game at start. Kiln's overlay and Streamline wrap the same graphics calls. When Streamline is installed, Kiln now leaves only the overlay's drawing off: your mods' key bindings, the entries mods add to the game's menus and mod loading at the menu keep working; mod windows, on-screen drawing and screen effects are off, and the Mods entry says why. KILN_UI_OVERLAY=1 tries the drawing anyway, KILN_UI_OVERLAY=0 switches it off yourself. Not yet tried on a PC with such a mod.
  • If the game closes while Kiln's overlay is starting, the next start leaves the overlay's drawing off and says why in kiln.log, instead of crashing the same way again. A start counts as fine once the game has shown its screen for half a minute through Kiln's overlay, or when you quit normally, also when you never opened Kiln's menu or a mod's window; the overlay's first drawing in that game is watched the same way. After a start that ran a minute with drawing off, the next start tries it once more. If that attempt closes at the same stage again, drawing stays off until you remove kiln/state/overlay-start.guard or explicitly try it with KILN_UI_OVERLAY=1.
  • Linux (Proton), with Ultimate ASI Loader chained: the launcher's Steam launch option now names xinput9_1_0 as well (WINEDLLOVERRIDES="dinput8,xinput9_1_0=n,b" %command%), and it tells you when only that part is missing. Before, it showed "Already set" while Valve's Proton loaded its own xinput9_1_0 and the loader's .asi plugins never started.
  • EML mods: a failed start says why. When Kiln's EML loader could not prepare the game's data, every EML mod showed only "the EML run failed (Failed to create AppState)". The log and each mod's status now name the step and the cause (for example a backup of the game's data that no longer matches what Kiln recorded, with what to do: verify the game files in Steam, then start through Kiln again).
  • A boot mod's own icons show from the first start. An item or a skill-tree talent that a boot mod makes with an icon of its own showed the icon of the game item or skill node it was made from.
  • Shroudtopia mods that are only a DLL are now switched on. Such a mod stayed off for good although your profile had it on, because nothing ever wrote its entry in Shroudtopia's settings; Kiln now writes it at the mod's first start. A mod you switched off there yourself stays off, and Kiln's in-game list says where an off Shroudtopia mod is switched off.
  • A Shroudtopia mod that is switched on but never reports itself active showed as "inactive", and kiln.log got an Activating: line twice a second. Kiln calls such a mod's Activate on every update, as Shroudtopia's own loader does; it now says so once, and the in-game list shows the mod as "activating" with the reason (the mod may not support this game version) instead of sending you to a setting that is already on.
  • Auto Loot Plus next to Ultimate ASI Loader: Kiln now loads Ultimate ASI Loader after Kiln and keeps Auto Loot Plus first, whatever their "Load after Kiln and ShroudForge" switches say, so Auto Loot Plus can hook the game first and its F8 menu comes up. The profile page shows both switches held by Kiln's rule and says why. Kiln recognises Auto Loot Plus by the folder its package brings (mods/auto-loot-plus): if you imported only its DLL, or renamed it, set Ultimate ASI Loader to load late yourself. (Its looting needs an Auto Loot Plus build made for the current game version; that part is the mod's.)
  • Windows, with ShroudForge mods in the profile: EML mods that come with their own DLL (Auto Loot Plus, Endless Chests) now switch on. Kiln placed them in the game's mods folder but never turned on ShroudForge's switch for them, because ShroudForge writes that folder as \\?\C:\... and Kiln compared the two spellings letter by letter. If you made an extended.mod.json by hand as a workaround, leave it: Kiln takes it as its own switch.
  • The launcher no longer says "Kiln has said nothing for ... s" for a whole session while you play. A start whose main menu Kiln did not see now ends at your first world, and kiln.log names what did not come.
  • With more than one chained dinput8.dll mod (Spawn the World and Auto Loot Plus, for example), Kiln's in-game mod list no longer shows a "Message From Dear ImGui" popup under them, and each one can be picked on its own. Kiln also turns that developer popup off for every window it draws, mod windows included.
  • On Windows, Kiln's in-game Mods page treats ShroudForge's mods folder as the same folder however ShroudForge spells it (\\?\C:\...): an EML mod Kiln placed there shows ShroudForge's switch correctly and is no longer called a mod you put there yourself.
  • A mod's settings page in Kiln's menu says when its settings file could not be saved (a read-only folder, a full disk), also when the mod saved it itself, until a later save works.
  • The proxy's log (kiln\logs\proxy.log) now names a line of dinput8-chain.ini that was skipped because it does not name a .dll (a mistyped file name, an .asi). Before, such a line was skipped without a word.
  • A boot mod's resource patches can no longer be lost without notice: if the game's resource service was already up before the boot generation was ready, the mod is refused (left out, or the start stops for a "required" mod) and kiln.log says why, instead of the mod loading while the game keeps its own values.
  • A "boot": "required" mod with a broken VFX or material file now stops the start in a player's game, as it promises, instead of loading without that file. (Its valid files work as before.)
  • Hosting one world after another: a brand-new world's kept terrain chunks (written before its first save) no longer land in the record of the world you had open before.
  • A mod that needs ShroudForge's runtime did nothing beside EML's own loader. With EML's loader (its dbghelp.dll, or in a DLL chain) in the game folder, an EML mod that declares runtime or runtime-register-dll was handed to the ShroudForge Kiln hosts, which that loader keeps from starting, so the mod's DLL never ran. Activating the profile and Play now stop and name the mods and the loader: switch those mods off, or remove that loader. Mods that only patch game data are unchanged.
  • /noclip said "rules.json does not allow it" although rules.json had "allowNoClip": true, in a world where no mod had applied rules yet (a Friends Only or Offline world with only a NoClip key mod, for one); /noclip status said the same, and editing the file changed nothing. NoClip now reads the server's rules.json itself and follows it when you edit it, without starting the rest of the rules (no gameplay hooks for a status check). On a joined game, /noclip status typed in your own console now says to ask the server in chat instead of reading your own file. Reported and fixed by bisdat (GitHub issue #37, pull request 38), with a follow-up of ours.
  • A rules mod no longer switches on the game's building hooks unless one of its rule sets keeps builds outside bases; where those hooks cannot install (after a game update, for one), that one rule is not kept and every other rule still applies, where before every rule set failed to apply.
  • Native plugins: an ability event queued in a server world's last step is no longer delivered into the next world you host, where a held start's cancellation could remove an unrelated entity that reused the id.
  • A set of mods whose VFX together went past the game's table could crash the game at start. Kiln counted its cooked VFX against the game's 2,048 resources but let VFX that come through asset files or native plugins in on their own, so 473 cooked VFX and one more from an asset file reached the game's fatal limit. Kiln now counts both against one budget, refuses what does not fit and names the mod in kiln.log, or the native owner's number when the caller has no mod name; a required boot mod whose VFX is refused stops the start as before. (Also in 0.2.0-dev.28.)
  • kiln.log's "chained over" lines and the compat overlap warnings now name Kiln's hook and its owner, for example "content/ItemRegistryFind (kiln-content)", instead of another service's name for the same function ("build/ItemFind").
  • Autosave hitches on hard drives. The game slowed or froze for seconds at each autosave while Kiln.Saves rewrote its unchanged mod data file twice and forced it to disk on the drive the game was saving to (GitHub issue #39, HadToRegister). When no mod data changed, Kiln.Saves now writes nothing during the save and does not force its small files to disk; a power loss can then at worst bring back the previous save's identical mod data. Saves where mod data changed, and the first save of a session, are written and forced as before. (Also in 0.2.0-dev.28.)

On, not yet confirmed in a real game

  • events.component_net: ran on a dedicated lab server without players, on stand-in entities (46 rows; a stop and a reload with live watches; the budget, queue, overlap and rollback cases). At the full budget of 32 watches and 4,096 pairs it cost 0.3 to 0.4 ms at the start of a step and 0.7 to 1.2 ms at its end (median over four runs on a heavily loaded machine; worst single window seen 12.6 ms); every player on that server shares that cost, and it is a measurement, not a bound. Not seen: a watch following a real player, a hosted world, writers on the game's own worker threads. Confirm hosted that a Players watch follows you, that sprinting changes Stamina with origin Unknown, that a health change by Kiln names kiln.combat and a given item names kiln.items, and that dragging an item is not called Kiln's (07-watch.hosted); on a joined client Watch must answer no (07-watch.joined).

  • events.death, events.pickup, events.equip: ran on dedicated lab servers with a stand-in player (07-events.decision-rollback). A real game must show: your own screen during the one or two steps a refused death spends at 0 health (no death screen, no respawn button), what a second player without Kiln sees, a save taken in that step, a drop picked up by walking, and gear after a refused equip.
    These shipped switched off in 0.2.0-dev.28 and their gates are open now; the implemented features below are on but unconfirmed in a real game, so report a problem with what you saw, kiln.log and, if you ran a guided check, its ledger (client pass).

  • assets.blob_catalog: mods can list the game's served files on servers and in every game; confirm with Client asset catalog acceptance (13-assets.catalog-client).

  • blocks.move_followups: a weapon's block can hand over to its parry or light attack on servers and in every game; confirm the handoffs, held block and shield recovery (16c-b, 16c-d) Also not run in a real game: a second player joining in the middle of a swing, hosting, leaving, joining and hosting again with a routed weapon, and a player without the mod receiving it.

  • gamedata.expanded_buff_room, gamedata.buff_budget, gamedata.buff_registration: the room for 4,096 buff clones ran on a dedicated lab server (2,000 and 4,096 clones, a restart, a reload); a stored definition was also followed over three starts (stored, kept while its mod was off, registered when it came back, then a reload), and the store's Windows file handling ran under Wine. A game client has not run it, and neither has the refusal of a joining player whose game has too little room (the server holds the player for at most 25 s while it checks). Confirm the first and the last clone on the buff bar and that the game's own lookup finds both, after a rejoin and in a second world (17-buffs-client).

  • 64 world programs: ran on a dedicated lab server; what a second player without Kiln sees of a server with that many programs has not been run (17-programs-vanilla). World.GetProgramBudget for the client world has no check yet.

  • hooks.typed (typed hooks and Invoke): typed hooks ran on dedicated lab servers and under Wine (handlers on worker threads, 20 reloads, the checked installation with a thread parked inside the bytes). No managed typed hook has run in a game client: confirm the sample's hook installed, the same can and well giving unchanged water with the sample off and about twice with it on, and two minutes without a stutter (06b-typed-hooks.client).

  • abilities.natives.ecs: ran on a dedicated lab server without a player (the self-check, a Health write seen by World.TryRead, an undeclared type refused, one event with the native's writer, the write still in the save after a restart; with the program taken off its thread by a lab switch the bridge switched itself off, as it must).

  • EffectBlock.Run and the FrostMark sample: ran on a dedicated lab server without a player (the native ran once per hit in the hit's step and its attackMod change was in the damage event). Confirm with a real hit: the sample's sword on two enemies, one at 20 % health (06c-impact-damage).

  • abilities.natives.sync, abilities.natives.attach: ran on a dedicated lab server without a player. Confirm with a player in the world that the fixture's same-step native answers in each program's start step and that a Before on the Fireball explosion gets one call per explosion, the explosions looking and sounding as the game's own (06c-natives.joined; needs the fixture mod natives-fixture).

  • worldtables.material_pools: ran on two dedicated lab servers, 18 cases (served pools and bindings read back from the game's own tables, a restart, the mod absent and back, a pool stored for the next start and replayed, a torn file refused, a stored pool its loaded mod dropped, an explicit removal, the observer’s cost per tick, a mismatching client refused before any block data, the id and terrain boundaries). No game client has run it: confirm in the build menu that a shape shows its own materials in order (four, a shared one, 64, a roof), the previews, that each placement costs three blocks and mining gives one back, that the game's own lists are unchanged, and the same after a reload, a rejoin and in a second world (17-material-pools; needs the fixture mp-fixture and the lab's proof file).

  • vfx.budget, blocks.vfx_registration: ran in host tests against a simulated game only; a dedicated server has no VFX table. Confirm in a game client a ready budget of about 2,048 with 1,575 used by the game, the fixture's three effects accepted for the next start and registered after a restart, and all three bursts playing (two checks around one restart of the game: 17-vfx-budget.before prepares the three effects and ends as Skip, 17-vfx-budget.after needs another game process, exactly three more resources in use and your word on the bursts; fixture mod vfx-test). While a definition's file is being written its place shows as Reserved, and a world's end clears the budget until the next world's table is read.

  • items.equip_sets: ran on a dedicated lab server with a stand-in character, not a player (29 rows, the 15-form matrix, and the rollback series: a failure at every operation of every form, with every byte of the program's components and of each item's durability, level, perks and fuel compared). A lab cannot save and reload a stand-in character, so nothing about a set has been seen across a save. Confirm with a real player one decision for the whole set and both rings and the helmet appearing at once (10-items.equip-set), no in-between state for a second player watching (10-items.equip-set.observer), and the result kept over leaving and rejoining (10-items.equip-set.persist, .persist.after). After a set that succeeded Kiln checks slots, identities, stamps and owners, not each item's durability, level or perks; after one that rolled back it compares every byte of the inventory components, and durability, level and perks byte for byte only in the lab series. Derived stats and set bonuses after a swap were not measured.

  • npcs.expanded_roster, npcs.client_roster_read: the roster ran on a dedicated lab server in nine boots on one save (64, 65, 128 and a restart; 129, 65 with the hooks not installed, and 129 as a boot mod, not required and required: all four stopped at the start through kiln.boot with exit status 2, boot.json and progress.json saying why, the save byte for byte unchanged; a dropped page computed again on the context the game passed (dedicated servers only: a game client computes no lost page again); a negative control without the page, which failed where it must); the hooks ran on the tick thread only. No game client has run it, and neither the stopped start's message box nor a hosting game's two worlds have been seen; the stop waits for boot.json, progress.json and kiln.log as text another reader can see, without flushing every file to disk, and the writer calls FlushFileBuffers on roster-refused.json before the stop. Confirm in a world you host that entries 0 and 64 show different states in the Survivors directory, that entries 63 and 65 can be summoned and sent to beds, the same after a rejoin, and a second world where 63 to 65 are locked (17-roster-client; needs the fixture mod roster-cap-fixture), and that a start with a roster that cannot be held shows the message box, which closes by itself, and loads no world (17-roster.refused-start).

  • items.tool_wear_debit: mods can change how much durability a tool spends in a world you host and on servers; hooks install when a mod first sets a valid rule, rather than at start; 16b-g checks a host’s pickaxe worn 7 per debit and its bar, while joined players, wear to zero and repair display still need checks.

  • queries.voxel_ray, queries.ground, queries.line_of_sight, queries.overlap_origins: mods can ask about voxel surfaces, ground, sight through voxels and nearby entity origins on servers and in a world you host; confirm ground, walls and query-only safety (01-queries.voxel-ray-hosted).

  • queries.path, queries.reachability: mods can ask for walking routes or whether a place can be reached on servers and in a world you host; confirm routes around a wall, cleanup and reload (02-queries.path-hosted).

  • systems.wraps, systems.wraps.typed, systems.threads: program wraps (Kiln.Systems) ran on dedicated lab servers, with the worker threads forced; a world you host with a second player, where the game itself spreads a program over its workers, has not run them (06a-wraps.waterworks: the well's water bar visibly faster, the wrap on more than one worker thread, no stutter).

  • systems.define: ran on a dedicated lab server (133,077 entity calls, handlers on seven threads with the workers forced). A world you host with a second player has not run it: confirm the reservation is bound, that it runs on the game's worker threads with Fuel read on every call, and that nothing calls it after Dispose (06a-define.hosted).

  • world.programs.client (and EMF's client-world calls through it): ran in host tests and on a dedicated lab server, where it is refused as it must be; no game client has run it. At a client world's stop the core first waits for that world's jobs (world.stop_drain.client), so no callback is inside when the world is destroyed. Where that row is on, a callback found inside at the stop is an error and switches client-world programs off until the game restarts at once; where it is off, a slice stops at its next entity and a callback still running after a 2 s wait does the same (logged, the row says faulted). Confirm, in this order: a start without any client program looks and runs as before (programs.client-baseline); hosted, the programs register and run on the threads they should (14-client-world-programs); joined, the prediction program runs (programs.client-joined); the event lists (14-q4); an EMF client event with its payload (programs.client-emf); a visible write that a second, vanilla player does not see (programs.client-visual, the second player by hand); leaving, rejoining twice and unloading with callbacks active (programs.client-rejoin); a save and a reload after client writes (programs.client-persistence); a callback that is slow on purpose when the world stops (programs.client-delayed-stop); the previous session's log after an exit (programs.client-exit). At every leave kiln.log must say "its jobs are drained by the engine (WaitWorldJobs, ...) before STOPPING" for the client world, and the game's own log must not say "TaskQueue ... is not idle during destroy".

  • Smaller rows that are on and go with the features above: world.program_budget (World.GetProgramBudget), world.slice_record (the slice record WhenArchetype reads), npcs.roster_read and npcs.roster_budget (the roster's reads and its budget), quests.npc_pages (the game functions behind the 128-entry roster), decisions.native_guards (decision guards set by native plugins). Three rows are registered and always unavailable in this build: events.build.pieces, events.build.terraform and events.component_writes.exact.

  • systems.wraps.client: mods and native plugins can wrap the client world's programs in every game; confirm that a wrap of a client program and one of a hosted world's program each reach their own world, that the game looks and runs as before, and that nothing runs after the wrap is removed (06a-wraps.client). Leaving a world, joining another, hosting again and quitting with a wrap in place have their own checks, which read kiln.log for the wait and the stop lines in order at every leave (06a-wraps.client-stop, 06a-wraps.client-exit); none has been run.

  • terrain.overlays: mods can apply patches of ground on servers and in a world you host; confirm what the hosting and joined player see (19f-overlay-client) Also not run in a real game: writes while the client streams and meshes the same chunks, what a joined player without Kiln sees and can dig, a crash between the game's save and Kiln's record, and the frame time of two or more plans applied at once.

  • ui.slots.inspect: mods can read the inventory slots drawn in every game; confirm cursor, gamepad, geometry and chest transfer (05a-c5).

  • ui.values.detail, ui.values.slot: mods can change the numbers and bars drawn for items in every game; confirm detail numbers and slot bars (05a-c1).

  • ui.values.held: mods can change the held item's water indicator in every game; confirm nonzero held water (05a-c3).

  • ui.values.hud: mods can change the drawn health, stamina and mana in every game; confirm retained HUD writes and visible stamina identity (05a-c2, 05a-c3).

  • ui.values.tooltip_lines: mods can add lines to Kiln's Item details window in every game; confirm Kiln’s separate Item details window (05a-c4-viewer).

  • world.transform_scale: mods can write and read back an entity's transform scale on servers and in a world you host; confirm its rendered size, collision and save behavior (13-world.transform-scale) A lab server showed a placed chest's scale coming back after a restart; no size range and no entity kind is refused (players, ridden mounts and physics bodies can be scaled).

Known limits

  • The 128-entry roster is verified on dedicated servers only. In a game client, a hosted world included, a missing second page is not computed again, so its locked NPCs from index 64 up are kept until the game's next evaluation. A world saved while a page is missing keeps such a locked NPC, and the first cleanup after a page exists again removes it; pages are not saved, and nothing unlocked is ever removed by being kept.

  • A roster past 64 NPCs and an older Kiln: a world whose mods add more than 29 roster NPCs, opened with a Kiln before 0.2.0-dev.29 (which refuses that roster), loses those mods' NPC and quest progress when it is saved. Update Kiln on the server and in every player's game before such a mod is added.

  • Kept earlier versions: a roll back's settings wait when the game folder has moved since they were kept (the launcher says so); a 0.2.0-dev.28 launcher shows a kept version as one more version and its Clean up may remove it.

  • Values and slots in the game UI (ui.values.*, ui.slots.inspect) exist only on a game client, never on a dedicated server; hooks install on first use by a mod, and after a game update these rows stay off until Kiln is updated for that client build.

  • Receiving replication (repl.client) is still unavailable: there is no receive implementation in this build; opening its gate changed no feature behavior, and 11-repl.receive-watch has no implemented guided check yet.

  • Transform scale accepts any finite positive size on any entity with a writable transform, including players, occupied mounts and physics bodies; no safe range or entity-family restriction is enforced, and extreme sizes can break downstream calculations. Collision, interaction and attachments keep their sizes.

  • A kept scale is reapplied by template and position. Kiln replays it only when exactly one candidate is there and drops the record of an entity that was destroyed or replaced, but the identity is positional, not proof: a single other entity of the same template at that place can still get the scale. Removing a mod in a running world does not restore its live scales; the tested chest reloaded at its original size without replay, but other entity families have not been established.

  • Moving a world to another PC without kiln/data: the world save alone does not carry the overlay ledger and witness, so Kiln reads the cells first. Where every addressed cell still matches, Kiln adopts the overlay without writing. Where a quarter or more but not all still match, nothing is written and the overlay waits for adoption; below a quarter it is written again, including ground the player dug away.

  • ShroudForge's spawn search beside other loaders' code patches. ShroudForge reads the game's original code only while the file matches what is in memory apart from function-entry detours, Kiln-style jumps inside functions and its own menu patch. Other loaders' byte patches (EMF's memory writes, SET, Flame) and a Kiln mod writing code through kiln.hooks still make it fall back to what is in memory, where a detoured PlaceProp can hide the spawn helper. On a game client the Steam wrapper's own code section has not been compared yet: one start of a client with a spawning mod shows it in kiln.log.

  • Terrain overlays share one work budget per host (4,096 written and 32,768 read cells, for all mods together). After 2 ms of measured work no more is admitted that step, but a running game call can overrun it; host frame time has not been measured with players.

  • Same-step impact natives (abilities.natives.sync, abilities.natives.attach, abilities.natives.ecs, EffectBlock.Run) are server only. Sync handlers and attachments run on the thread that runs the program (the world's or one of the game's workers), must not block, and share 19 registry keys for all mods together; an attachment does nothing while it is Pending or Off. A native may touch the world's entities only inside a live native call on the server world's thread while impact_simulation runs serially; when that no longer holds, Kiln closes that access for the world, and a write that failed may already have changed state. Run needs a matching synchronous declaration (sync, the argument count and each parameter's type and byte size), runs before the effect's own parts with the attackMod, damage and target position of that effect's additional hit (not the weapon strike's), and false skips that effect and its Then; when the handler is unavailable nothing runs in its place.

  • Boot mods next to other loaders' mods on a game client were confirmed in one hosted game; the guided check of both loader orders (08-loader-order) has not been played yet.

  • Required boot VFX: read or cook failures can stop startup, but the capability row does not prove successful initialization, and a late shader-binding mismatch can remove effects after commit without reporting a required-content activation failure.