Changelog:
## 1.2.0 Release

SHA256 Checksum: 4a1d0352e5d6e2fa017e3a6909ed54b5eb3ecacbdd6291dc37df82d5b74a2cb7 Komet_v1.2.0.zip

Github Release: https://github.com/xToast-dev/komet/releases/v1.2.0

Everything since 1.1.0, in one list. The four pre-releases and the work after them add up to: a far LOD that finally fixes the frame rate when you look at the horizon, the GPU side of the shadow passes, a worker pool instead of four thread sets, a measurement layer that can now answer “CPU or GPU?” and “which of my mods?”, and two crashes that should never have shipped.

The headline: a far LOD

• Beyond the far distance a chunk is drawn as cells of two blocks, beyond twice that as cells of four. At view distance 1536 the camera pass drew 16,1 million triangles when looking at the horizon, 12,7 million of them beyond 640 blocks — where a block covers one to three pixels and the chunk vertex shader still exports thirteen vec4 and evaluates 3D noise for each of them.
• Measured in the same scene, same session: 53 → 113 fps (19,0 → 8,9 ms/frame), camera-pass triangles 16,1 → 6,9 million, GPU frame 14,9 → 7,0 ms, and the camera opaque pass — timed bottom-of-pipe with a GPU elapsed query — 11,7 → 4,2 ms.
• The picture is built from what the engine already tesselated, on the tesselation thread: unit faces mark their block solid, air floods through the rest, a cell is solid if any of its blocks is, and each solid cell gets one face per air neighbour carrying a real source face's texture, light and colour map. No shader is touched.
• Plants, leaves, stairs and fences keep one representative per cell, scaled to fill it — a tree stays a tree, a house stays a house. The picture is never thinner than the world, only up to a block fatter, which is why chunks at different levels never leave a gap.
• The engine's own meshes are not modified and not re-tesselated: they simply stop at the far distance. Switch the feature off and they are drawn everywhere again on the next frame. The shadow maps always use the engine's meshes, never the pictures.
• Costs about 1,3 ms per chunk on the tesselation thread and roughly a third more vertices in the mesh pools. FarMesh, FarMeshDistance, FarMeshTier2; .komet farmesh <blocks|off|on> and .komet toggle farlod2 live.

Faster

• One dynamic worker pool instead of four thread sets that could not see each other. Five cull helpers, four occlusion helpers, a window-prebuild thread and a prefetch thread became one pool whose workers take whichever job is worth most. Same sweep on fewer threads: 0,70 ms against 0,77 ms, and the workload that holds cores for milliseconds can no longer starve the one on the frame's deadline.
• The far shadow map is no longer redrawn on every frame while you move. It was kept for a few frames and reprojected exactly, but a reprojection cannot extend what a kept map covers — so 15 cm of camera movement forced a redraw and the saving existed only while standing still. The map is now drawn 16 blocks wider than the fade needs, which is exactly the room the camera needs, and the redraw threshold rises with it.
• The near shadow cascade gets a map of its own size (4096 px). The engine allocated both cascades from one expression, so a cascade covering the 39 blocks around you had over a hundred texels per block against the far map's fifteen.
• The solid shadow passes use a depth-only shader and back-face culling. The engine's shadow shader samples the terrain texture and discards for every fragment of every pass; a closed block's back faces sit behind its front faces along the light ray too. Same depth map, half the faces, no texture fetch. Leaves and grass keep the engine's shader and cast from both sides.
• The near cascade stops drawing what cannot cast a shadow on anything visible — the half of its depth range that faces away from the light, and casters that cannot reach a receiver on screen.
• Far-detail stand-in geometry stays out of the shadow maps where the detailed version is already in them, decided per grid cell. On by default now; the old per-pool test never fired in a streamed world.
• A new creature type no longer costs a hitch the first time you see one. The engine builds an animation's frames on the main thread the moment it first plays: 12 ms for a rooster, 53 ms for a pig, always in the frame the animal comes into view. They are now built on a worker while the entity is still held back.
• The edge-repair sweep stopped rehashing the whole tesselation queue every 50 ms (4,6× to 7,3× on that sweep), the neighbour prefetcher stopped re-walking the same queue front hundreds of times a second, and the window prebuilder now predicts the chunk the tesselator will really mesh.
• World joins hitch less and entities are finished under a per-frame budget, nearest one first. Distant creatures animate every second or third frame with the skipped time folded in — same speed, sampled less.
• Server packets that are not chunk data run under a per-frame budget instead of stopping one frame dead, and the hitch that remains names the packet type behind it.
• Less garbage per chunk. The mesh buffer recycler, tight clones, a pooled extras store and now the far LOD's own output arrays: 45,6 KB → 0,8 KB allocated per chunk build, measured against a real recycler.
• Particle instance buffers are renamed instead of waited on, so a frame does not block on a buffer the GPU is still reading.

New

• A performance window on .komet and Ctrl+F7 — nineteen pages, one per question, with every switch flippable in place. It takes no measurement of its own; the blocks it draws are the same methods the overlay and the report call.
• A mod profiler with its own HUD (Shift+F7). Which of your mods costs what per frame, what each one does (patched methods, registered classes) and what it cost during loading, client and integrated server separately. .komet mods prints it as text for a bug report.
• 1 % and 0,1 % lows, and a live frametime graph, next to the averages the mod always showed — the numbers that describe stutter rather than throughput.
• A three-way answer to “CPU-bound or GPU-bound?”: GPU time per render stage, the driver's own busy figure where the system exposes it, and per-pass GPU timings measured bottom-of-pipe with fragment counts — the one measurement that tells fill rate from geometry without arguing.
• The camera pass's triangles by render pass, distance band and LOD level, which is what turned “the horizon is slow” into a number and then into the far LOD.
• .komet alloctrace [seconds] — the process records its own allocations with call stacks into a file next to the logs.
• Komet notices when another mod patches the same engine method and says so once, with a severity and a reason, and fingerprints the engine at world start so a game update that changed a patched method is named instead of silently misbehaving. .komet conflicts lists it.
• A warning at world join when Optimum or OptiTime is present. Both replace the same engine code, each unaware of the other; finding that out used to need a bisect. Komet stays enabled — which side should win is your call.
• The HUD and the chat replies speak German when the game does. Logs, reports and hitch lines stay English on purpose: they end up in bug reports.
• Server-side sync tuning for singleplayer — position updates thin out with distance, entity tracking gets a hysteresis band, attribute paths whose bytes did not change are not sent.
• Live knobs for the visual trades, all reversible mid-session: .komet farmesh, .komet foliagerange, .komet shadowfoliagerange, .komet shadownear, .komet shadowneardepth, and a toggle table that lists every one of them with what it does.

Fixed

• Crash on joining a world (NullReferenceException in WeatherSystemClient). The new task budget could spread a join's backlog over frames and let a renderer draw before the packet that initialises it had run. Joining is lifecycle, not load: the budget now starts only once the world is finalised.
• Crash on the first frame with the Optimum client build (MissingFieldException: ClientMain.MainThreadTasksLock). The fork declares that field with a different type. It is now read by name and locked the way its type demands.
• A German client's log filled with “Translation string format exception” — an error and a warning per HUD refresh for every label with a number, thousands per session.
• Two budgets could stop for good instead of falling back. If their frame-boundary reset ever stopped arriving, entity tesselation skipped every further shape and held entities never loaded. Both now detect it, run vanilla and count it. A budget that loses its reset has to degrade to slower, never to never.
• The patch guard was quiet about the collisions that matter most — where Komet replaces an engine method outright, another mod's transpiler never runs. Reported as high severity now, with the reason.
• One malformed animation no longer costs a creature its whole warm-up, and the shadow cull range no longer forgot the light eye's 50-block offset.
• Two toggles reported success and did nothing. Several measurements were booked to the wrong place: particles folded twice, GPU timing and GC statistics while the HUD was closed, mesh pool allocations, hitches in the 2D stage now name the dialog that caused them, and no more false hitch reports while the pause menu is open.

Changed

• Config layout is now version 26 (a great many new settings since 1.1.0). An existing komet.json is backed up next to itself and regenerated from the current defaults — re-apply your custom values afterwards.
• CullingThreads and OcclusionCullingThreads are gone, replaced by the worker pool's own sizing (physical cores minus two, so the render and tesselation threads keep theirs).
• The mod zip is stored, not compressed (~180 KB → ~450 KB). Identical data does not give identical deflate streams across zlib implementations, so compressing would make the checksum below unreproducible on a different machine.
• Minimum game version stays 1.22.0. Built and verified against 1.22.7; on other 1.22.x builds any patch whose engine code changed logs a warning and switches itself off individually.

Internals

• The culling core is still proved byte-identical to vanilla on every build — 3.120/3.120 sweeps with identical triangles in identical order, 1.440/1.440 with the pool-box early-out, 2.304/2.304 pixel-equivalent gap merges — and the far LOD's picture is checked against the cell picture computed from a heightmap alone, on twelve random terrains, at both levels.
• Every build runs on GitHub Actions: both mods built, the full patch and behaviour suite executed against the real game assemblies, the packaged zips attached to the run.
• Release builds are reproducible: the same commit produces the same bytes, so the checksum below can be recomputed rather than merely trusted.

Changelog
## Komet 1.2.0-pre.4

SHA256 Checksum: d643a8e24ac1ce5e514fec3746f3e07f689b51bec6563de6ceccc2f74425590d Komet_v1.2.0-pre.4.zip

Github Release: https://github.com/xToast-dev/komet/releases/tag/v1.2.0-pre.4

Changes since 1.2.0-pre.3. This release is mostly the GPU side of the frame: the first report
that could measure it found the two shadow passes taking 86 % of a GPU-bound frame, and four of
the five performance changes below come out of that one number.

### Faster

- The far shadow map is no longer redrawn on every frame while you move. It was already kept
  for a few frames and re-projected exactly — but a re-projection can only keep a kept map
  correctly *positioned*, not extend what it *covers*, so any camera movement of 15 centimetres
  forced a redraw. Walking, and especially flying, meant the saving never happened; it existed
  only while standing still. The map is now drawn a little wider than the shadow fade needs
  (16 blocks by default), which is exactly the room the camera needs to move without leaving it,
  and the redraw threshold rises to about 14 blocks in step. Costs about 6 % coarser far shadows;
  `ShadowFarBoxMargin` sets the trade, `.komet toggle shadowmargin` flips it live.
- The near shadow cascade gets a map of its own size. Both cascades used to be allocated from
  one expression, so the near map was as large as the far one — over a hundred texels per block
  for the ~39 blocks around you, against the far map's fifteen. Now 4096 px by default: a third
  of the fill rate for a difference nobody can see. `.komet shadownear 3072` changes it live.
- The solid parts of the shadow passes do a lot less work per fragment. Back-face culling
  drops half of every solid face before a fragment exists (a closed block's back faces sit behind
  its front faces along the light ray too, so the depth map is identical), and a depth-only shader
  spares the rest a terrain texture lookup. Leaves and grass are untouched and still cast from
  both sides.
- Far-detail stand-in geometry stays out of the shadow maps wherever the detailed version is
  already in them — the shadow pass had no distance rule at all and rasterised both.
- A new creature type no longer costs a hitch the first time you see one. The engine builds an
  animation's frames on the main thread the moment it first plays — 12 ms for a rooster, 53 ms for
  a pig, always in the frame the animal comes into view. They are now built on a worker while the
  entity is still held back, and the main thread finds them ready.

### New

- A mod profiler with its own HUD (Shift+F7). Every measurement this mod made so far named a
  part of the *engine* — a render stage, a renderer, a tick listener — and none of them answered
  the question somebody with forty mods installed actually asks: *which of mine is it*. The
  overlay lists your mods by what they cost per frame, what they do (engine methods patched,
  block/item/entity classes registered) and what each one cost during loading, client and
  integrated server separately. `.komet mods` prints the same as text for a bug report.
- It also prints what it cannot see instead of leaving it out: a Harmony patch runs inside the
  method it patches, so its time is booked to the engine — which is why the patch count sits next
  to the milliseconds — and block entity ticks, mod worker threads and GUI dialogs are not
  attributed at all.
- A warning at world join when Optimum or OptiTime is present. Both replace the same engine
  code Komet does, each unaware of the other, and finding that out used to take a bisect. Komet
  stays enabled — which side should win is your call.

### Fixed

- Crash on the first frame with the Optimum client build (`MissingFieldException:
  ClientMain.MainThreadTasksLock`, reported with Optimum v0.3.14). The fork declares that field
  with a different type, so the mod's binding no longer resolved. It is now read by name and
  locked the way its type demands; anything unexpected leaves that part vanilla instead of taking
  the client down.
- German clients filled their log with "Translation string format exception" — an error and a
  warning per HUD refresh for every label containing a number, thousands per session.

- A ton of more Bugfixes :)

### Changed

- Config layout is now version 15 (eight new settings since pre.3, five of them
  shadow-related). An existing `komet.json` is backed up next to itself and regenerated with
  defaults — re-apply your custom values afterwards.
- Minimum game version stays 1.22.0. Built and verified against 1.22.7; on other 1.22.x builds any
  patch whose engine code changed logs a warning and switches itself off individually.

Check with `sha256sum Komet_v1.2.0-pre.4.zip` (Linux) or `Get-FileHash Komet_v1.2.0-pre.4.zip`
(PowerShell). Release builds are reproducible: check out the tagged commit, run
`./build.sh release`, and the file comes out with exactly that checksum on any machine.

Changelog:
## 1.2.0-pre.3

SHA256 Checksum: d80c94ed06854f9a8d7cdcfc7fd56272481df03e1efcbc11ab7ef4b99be9fb59  Komet_v1.2.0-pre.3.zip

Github Release: https://github.com/xToast-dev/komet/releases/edit/v1.2.0-pre.3

Everything here answers a report from someone running pre.2, or follows from one.

### Fixed

- Joining a world could crash the client with a `NullReferenceException` in
  `WeatherSystemClient.OnRenderFrame`. pre.2 introduced a per-frame budget on the main-thread
  task drain, and a world join queues hundreds of those tasks — including the one that
  finalises the level. Spreading that backlog over frames let a renderer that was already
  registered draw before the packet initialising it had run. The budget now starts only once
  the world is finalised: everything a join queues runs in the frame it arrives, exactly like
  vanilla. Joining is lifecycle, not load, and it is not the place to save milliseconds.
- Two budgets could stop working instead of falling back. The entity tesselation and
  entity loading budgets reopen their window on the frame boundary and nowhere else. If that
  signal ever stopped arriving while the patch stayed applied, the tesselation budget skipped
  *every* further entity shape — permanently, for every animated creature in the world — and
  held entities were never loaded. Both now notice the missing signal, run vanilla instead,
  and count it on the HUD; and neither arms itself at all if the measurement it depends on
  failed to apply. A budget that loses its reset has to degrade to slower, never to never.
- The patch guard was quiet about the collisions that matter most. Where Komet replaces an
  engine method outright (its prefix returns false), another mod's transpiler never runs, a
  prefix ordered behind Komet's is never called, and a postfix sees the result of Komet's
  transcription rather than the original's. All three used to be reported as "info". They are
  now high/high/medium with the reason spelled out — this is the shape behind reports of the
  "entities are invisible since I installed this mod" kind, and it should not need a bisect.

### Added

- German HUD and chat. The F7 overlay and the `.komet` replies follow the game language;
  English and German ship in `assets/komet/lang`. Missing translations fall back to the English
  text in the source, never to a raw key.
- **Reproducible release builds with a published checksum.** The same commit produces the same
  bytes, so the SHA-256 on the download page can be recomputed rather than merely trusted. The
  number is also published on the GitHub release, written by the build job.

### Changed

- Logs, reports and hitch lines are English. They used to be German. These end up in bug
  reports and get read by people who do not run the client that produced them — the HUD and the
  chat replies are the surfaces that follow the player's language, and nothing else does.
- The mod zip is stored, not compressed (~180 KB → ~450 KB). Identical data does not give
  identical deflate streams across zlib implementations, so compressing would have made the
  checksum unreproducible on a different machine. The download is larger; the promise holds.
- The unused `MeasureRenderStages` setting is gone from the config class. It was never read.
  The config layout version stays at 11 on purpose: an existing `komet.json` keeps working,
  the leftover key is ignored, and nobody's settings get regenerated over a dead entry.

### Internals

• Every build runs on GitHub Actions: both mods built, the full patch and behaviour suite run
    against the real game assemblies, the packaged zips attached to the run, previews published
    under Releases. The SDK version is pinned in `global.json` — a different patch level produces
    a different assembly, which is measurable and would otherwise break reproducibility silently.
  - Source folders sit next to the project file and each one is its own namespace
    (`Culling/` → `Komet.Culling`, `Measure/` → `Komet.Measure`). Not cosmetic: an editor rule
    that derives namespaces from paths had rewritten a generated file and silently disabled the
    engine-drift check.

CHANGELOG:

• Fixed measurement patch failures on overloaded engine methods

• Fixed frozen GPU timing and added GPU usage tracking

• Fixed GC/allocation statistics when HUD is disabled

• Improved CPU thread budgeting for low-end hardware

• Fixed excessive shadow map quality on low-end GPUs

• Ignored false hitch reports while the game is paused

• Fixed misleading Linux thread priority reporting

• Added Harmony patch collision detection

• Added engine build fingerprint verification

• Added client-side allocation tracking and GC survivor statistics

• Added allocation sampling by thread and object type

• Added server block packet source tracking

• Added mesh pool allocation tracking

• Added per-stage GPU timing

• Added dialog identification for large Ortho hitches

• Improved diagnostics and crash/report accuracy

• Expanded verification and regression test

Changes

• Incremental Cull Cache Removal
  • Replaced full cache rebuilds with direct slot removal for re-tessellated chunks.
  • Reduced unnecessary cache misses across 4–8 pools.
  • Added support for open appends during streaming to avoid unnecessary rebuild fallbacks.
• Rebuild Attribution in Hitch Logs
  • Hitch log entries now report rebuild contribution as (X rebuilds, N pools).
  • Makes it easier to identify whether 11–16 ms sweeps are caused by cache rebuilds.
• Frustum Culling for AnimatableRenderer
  • Added stage-specific frustum checks for animated block entities.
  • Skips rendering only when fully outside the relevant stage frustum.
  • Shadow stages use the corresponding light-space bounds.
  • Avoids unnecessary shader, lighting, uniform, UBO, and draw calls.
• Dedicated Pool for Chunk Mesh Clones
  • Added size-class pooling for per-face arrays and custom-part data.
  • Reduced recurring 18 MB/s clone allocations.
  • Objects are now recycled instead of being allocated and discarded after Gen1 promotion.
  • Pool return is handled via TesselatedChunkPart.AddToPools rather than Dispose.
• Added new Compact F7 Hud (Toggle by Pressing F7)

New

• Visible border holes close first. While chunks stream in, the repair of an already-visible chunk border used to wait at the back of the tesselation queue, behind thousands of chunks nobody can see yet — up to several seconds of staring at a hole in the terrain (most obvious on the ocean surface). These repairs now jump the queue and upload immediately. Capped so block edits are never delayed noticeably; toggle live with .komet toggle edgeprio.
• Allocation attribution. The F7 HUD and .komet report now split the process allocation rate by thread (main / network / prefetch / tesselation / rest) — the number that matters when hunting GC stutter.

Changed

• Minimum game version is now 1.22.0 (was 1.22.7). Built and verified against 1.22.7; on other 1.22.x builds any patch whose engine code changed logs a warning and switches itself off individually — the game keeps running vanilla in that spot.
• Config layout is now version 2 (new setting EdgeRetessPriority). An existing komet.json is backed up next to itself and regenerated with defaults — re-apply any custom values afterwards.
• The edge-priority stat row always shows its sweep count while the feature is on, so a healthy-but-idle feature can never look like a broken one.

- Initial release