API v4 migration guide
Version: 4 · Status: Historical (migration guide of the era; the target build is noted in the text) Superseded 2026-11-03: the live API is now version 5 — v4 packs are rejected at load exactly as described here for v3. Apply this part and then the v5 guide (v4 → v5: the
BloxdFlagsstruct replacesblockFlags,bloxdLit()and the public lighting recipe, the enchant/overlay inputs, the 9-hook default pack). This part’s internals (§56–§66) remain accurate for the v4 builds they were measured on.
Target build: cnty9.main.669f8081.js — live on production and preprod simultaneously since 2026-10-26. Unlike the v3 rollout (a preprod build promoted to production), v4 flipped both environments to the same new bundle in one move, and the two bundles are byte-identical (main and every shader-pack chunk md5-checked), so everything here applies to production as-is. The bundle was also reorganised around this release — the main bundle shrank from 4.73 MB to 3.03 MB (-36%), the chunk count grew from 169 to 193, and the whole shader-pack pipeline (loader, validator, code generator, WebGPU compiler) now lives in a contiguous c49–c54 cluster. The pack model itself keeps its shape: same pack.json fields, same loader limits, same 64 B uniform, same six hooks.
Re-verified on tcwczu.main.357faec1.js (2026-10-30, production and preprod again byte-identical): the whole v4 API surface is unchanged. The engine header (6,021 B decoded), the default pack template (1,122 B as shipped), the 27 bloxdSp* symbols, the blockFlags bits, the loader limits, and the 12 allow titles are all byte-identical to the cnty9 baseline this part documents — the v4 freeze held through the first post-v4 bundle refresh. The bundle layout moved on: the main bundle grew to 3.28 MB, the chunk map now has 202 ids (195 emitted), the shader pipeline cluster sits at c51–c56 with the default pack in c124, and the §66 “chunk c8” references for the lift/cone constants are now c9. None of that is visible to a pack. The one thing this re-verification did not re-measure is the texture-name registry (§68): its cnty9 ids remain a snapshot, and names remain the stable API.
One thing changed around this release that is not in the bundle: the engine now cites reference files by name. Its own error messages point at bloxd-api.wgsl (the annotated engine header) and BLOCK_TEXTURES.md (the complete texture-name list) — ...BLOCK_TEXTURES.md lists them. This guide carries the content of both instead of pointing you elsewhere: the complete header, restored verbatim from the live build, is embedded in Engine Internals: Engine header, and the complete catalogue of usable texture names (905 in the v4 build) is the Texture catalog. Every pack-facing fact in this part was restored from the production bundle.
The v4 change set in one screen:
| Area | v3 | v4 |
|---|---|---|
pack.json apiVersion | 3 (strict) | 4 (strict) — v3 packs are rejected at load |
| Texture access | none (“cannot sample textures”) | new texture API: bloxdTexel(), bloxdTextureSize(), bloxdTextureId* constants |
| Hook inputs | 13/5 fields | +4 fields each: textureId, textureRotation, uv, mipLevel (surface and light) |
fogVisibility | 1 = no fog | renamed fogAlpha, meaning inverted: 0 = no fog, 1 = only fogColour |
bloxdFaceBlock() | — | renamed bloxdFragmentBlockPosition() (same math) |
BloxdOpaqueBehind.found | found | renamed hit |
| Strict games | policy + guards documented | now enforced by the bundled validator with exact diagnostics (§60) |
| Everything else | — | frozen: 6 hooks, blockFlags bits, uniform layout, loader limits, variant matrix, pack @group(3) bindings |
Conversion from v3 is mechanical (§61) except for one silent trap: if you port everything but ignore the fogAlpha inversion, your fog-dependent code runs with inverted fog and compiles fine. As always, verify with an in-game compile before distributing.
55. Fate of v3 packs (conclusion first)
Every v3 pack — including every pack distributed as v3 — now fails on production exactly at load. The loader compares manifest.apiVersion !== 4 with strict JavaScript !==, so the comparison is type- and value-exact: the JSON must carry the number 4. A string "4" fails and is reported with its JSON spelling ({{packVersion}} is JSON.stringify-ed, so the settings screen shows This pack is for shader pack API version "4"... with quotes — a useful tell that you wrote a string).
The two load-time messages, verbatim from the live i18n dictionary:
This pack is for shader pack API version {{packVersion}}. Bloxd supports version {{version}}.— the key is present but doesn’t equal 4.
A stored (previously working) v3 pack doesn’t throw anything at the player. The stored-pack outcome resolves to {kind: "none", reason: "otherApiVersion"}, the pack is silently inactive, and the shader-pack settings tab explains itself with the status line:
This shader pack is for API version {{packVersion}}, so it won't run. Load a version {{version}} pack to replace it.
The manifest rules around apiVersion are otherwise unchanged and worth re-stating because the loader enforces them before anything else:
pack.jsonmust be a JSON object at the root of the pack (not an array, not a number).apiVersionmust be present and=== 4.nameis required, a string, and non-empty after trimming.authoris optional, but if present it must be a string — explicitnullis rejected (pack.json's "author" must be a string.).- Everything else in the manifest is ignored by the loader.
56. pack.json and the uniform buffer (what stays unchanged)
The whole non-texture pack model carries over from v3 byte-for-byte, so §41 of the v3 guide remains the reference. The v4 re-measurements, from the live loader chunk (c51):
| Limit | Value | Message when exceeded |
|---|---|---|
.wgsl files per pack | 256 | The pack has more than 256 .wgsl files. |
Total .wgsl source | 256 KB | The pack's .wgsl files are over 256 KB in total. |
pack.json size | 64 KB | pack.json is over 64 KB. |
| Zip size | 32 MB | The zip is over 32 MB. |
| Zip entries | 1,024 | The zip has more than 1024 entries. |
| Zip shape | — | split zips, Zip64, encrypted entries, and unsupported compression methods are each rejected with a dedicated message; every file must be valid UTF-8; exactly one pack.json; no duplicate paths |
The per-frame uniform is untouched: @group(3) @binding(0) var<uniform> bloxdPackInputs: BloxdPackInputs, 64 bytes, std140-style layout:
| Offset | Field | Type | Note |
|---|---|---|---|
| 0 | seconds | f32 | backs bloxdSeconds() |
| 16 | renderOffset | vec3i | backs bloxdRenderOffset() |
| 32 | sunDirection | vec3f | backs bloxdSunDirection() |
| 48 | eyePosition | vec3f | backs bloxdEyePosition() |
The six-hook template ships with only comment polish (1059 → 1122 bytes; the v3 behaviour described in §45 is unchanged). The v4 template, verbatim — still the best starting skeleton, and still the strict-games pattern to copy:
// Every hook here returns its engine default.
// Copy a hook and change its output to start a shader pack.
// Strict games keep terrain where it is. We use #ifndef to define the hook for
// non-strict games, but to disable it in strict games, so our pack can stay on.
#ifndef BLOXD_STRICT
fn bloxdTerrainVertex(vertex: BloxdVertexIn) -> BloxdVertex {
return bloxdDefaultVertex(vertex);
}
#endif
fn bloxdTerrainSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
return bloxdDefaultSurface(surface);
}
fn bloxdTerrainLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
return bloxdDefaultLight(surface, light);
}
// Water uses liquid hooks. If deleted, water uses your terrain hooks instead.
#ifndef BLOXD_STRICT
fn bloxdLiquidVertex(vertex: BloxdVertexIn) -> BloxdVertex {
return bloxdDefaultVertex(vertex);
}
#endif
fn bloxdLiquidSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
return bloxdDefaultSurface(surface);
}
fn bloxdLiquidLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
return bloxdDefaultLight(surface, light);
}57. The texture API: bloxdTexel, bloxdTextureSize, bloxdTextureId* (the headline)
v3 packs could read a face’s colour but not its texture. v4 opens the block-texture atlas itself: three new engine functions, one named-constant family, and four new input fields (§58). The engine header’s own one-line summary of the headline: “This face’s texture. Compare with bloxdTextureId*.”
57.1 bloxdTexel(textureId: u32, uv: vec2f, mipLevel: f32) -> vec4f
Samples the block-texture atlas exactly as the engine’s own sampler does — the same texture_2d_array<f32> atlases, the same atlasSampler, textureSampleLevel at round(mipLevel) — so a texel you read and the texel the engine rendered agree by construction. Semantics, all restored from the generated WGSL (§63 has the verbatim source):
textureId == 0returnsvec4f(1.0)— white. That is the “no texture” id, and it is also what the four input fields carry when a face has no texture, sobloxdTexel(surface.textureId, ...)is always safe to call.- Animated textures return the current frame, automatically. The frame advances with the game’s animation clock — you cannot freeze or step it, and you don’t need to: sampling an animated texture’s id is sampling its live frame (§63.3 for the frame math).
mipLevelis clamped the way the engine clamps its own:clamp(round(mipLevel), 0, textureNumLevels(textureAtlas0) - 1). Out-of-range mips saturate instead of erroring.- The current fragment’s
textureRotationis applied to the uv you pass — see 57.4; this is the one subtlety with real visual consequences.
textureId is 1-based: bloxdTextureIdGrassTop is the id, and the atlas layer the engine samples for it is id - 1. Ids are stable per texture name, not per atlas layout — the engine re-lays-out the atlas freely across builds while your bloxdTextureId* comparisons keep meaning “this texture”.
57.2 bloxdTextureSize(mipLevel: f32) -> vec2u
textureDimensions(textureAtlas0, <clamped mip>) — the size in texels of the atlas at that mip level. Since every texture occupies one array layer of that atlas, this is also the texel size of any one texture at that mip (all block textures in an atlas tier are the same square size). Pair it with bloxdTexel when you want texel-grid effects:
// A texel-aligned "pixel art" re-sample of this face's own texture.
let size = bloxdTextureSize(surface.mipLevel);
let uv = fract(surface.uv);
let texel = bloxdTexel(surface.textureId, uv, surface.mipLevel);57.3 bloxdTextureId*: named texture constants
Every usable texture name becomes a const you can compare against — spelled CamelCase over the texture’s file name:
| Texture file | Constant | Note |
|---|---|---|
grass_top.png | bloxdTextureIdGrassTop | the engine’s own example |
lava0.png (frames lava0–lava7) | bloxdTextureIdLava | animated family: the frame suffix is dropped from the canonical name |
black_portal0.png (frames 0–3) | bloxdTextureIdBlackPortal | same rule |
radar_screen0 (turned copies [rot[1–[rot[4) | bloxdTextureIdRadarScreen0 | turned family: folds to the root name |
The spelling rule, restored from the validator: split the name on every non-alphanumeric run, capitalise each part, concatenate after the bloxdTextureId prefix. Lookup is case- and underscore-insensitive in the other direction (the engine folds your spelling the same way before matching), with three dedicated error families when a spelling doesn’t resolve — all verbatim from the live validator:
Misspelt prefix / wrong case:
bloxdTextureIdGrassTop isn't part of the shader pack API. Texture names start with exactly bloxdTextureId: did you mean bloxdTextureIdGrassTop?A frame of an animated texture:
...names a frame of the animated texture lava: use bloxdTextureIdLava, which bloxdTexel animates.A turned copy:
...names a turned copy of radar_screen0: use bloxdTextureIdRadarScreen0, which bloxdTexel turns as each face shows it.Ambiguous after folding:
...could name X and Y, which differ only by case or underscores, so it can't be used.Not found, with a suggestion:
There's no texture called X. Did you mean bloxdTextureIdY?— the suggestion threshold is Levenshtein distancemax(2, floor(len/4)) + 1.Not found, no suggestion:
There's no texture called X. Texture names are the file names texture packs use, as in bloxdTextureIdGrassTop for grass_top.png; BLOCK_TEXTURES.md lists them.
That last message points at a file this guide embeds instead: the complete measured catalogue — every one of the 905 usable names with its then-current id, plus the turned and animated family tables — is §68 below; §64 has the registry measurement and the folding rules behind it. The live successor of that catalogue is the Texture catalog.
57.4 The rotation subtlety — and the neutral-sampling helper
bloxdTexel un-rotates the uv you pass by the current fragment’s textureRotation, whatever id you hand it. For the two common cases this is exactly right:
- Re-sampling this face’s own texture with
surface.uv— the uv is in the face’s rotated frame, the un-rotation converts it to the atlas frame, and you get the true texel. This is the intended primary use. - Sampling with a uv you computed in atlas terms for a different texture on a face whose rotation isn’t 0 — the un-rotation still fires, and your sample lands rotated. This is the trap.
The engine has no per-texture rotation to consult (rotation is face geometry data, §63.2), so it always uses the fragment’s. To sample another texture rotation-neutrally, pre-rotate your uv by the same quarter-turn — the inverse of the un-rotation — which cancels it:
// Rotation-neutral texel sampling: pre-turn the uv so bloxdTexel's
// un-turn (by this face's textureRotation) cancels out.
// Pass surface.textureRotation as r from your hook.
fn texelNeutral(id: u32, uv: vec2f, mip: f32, r: u32) -> vec4f {
var turned = uv;
if (r == 1u) { // turn: (x,y) -> (1-y, x)
turned = vec2f(1.0 - uv.y, uv.x);
} else if (r == 2u) { // (x,y) -> (1-x, 1-y)
turned = vec2f(1.0 - uv.x, 1.0 - uv.y);
} else if (r == 3u) { // (x,y) -> (y, 1-x)
turned = vec2f(uv.y, 1.0 - uv.x);
}
return bloxdTexel(id, turned, mip);
}
// usage, inside a surface hook:
// let t = texelNeutral(bloxdTextureIdLava, fract(surface.uv),
// surface.mipLevel, surface.textureRotation);(When textureRotation == 0 no compensation is needed. In practice most faces carry 0; turned faces are the minority — but a distribution pack should not assume it.)
57.5 Worked examples
Emission from texel luminance. The engine already multiplies texture × tint × AO into surface.colour; here we instead drive emission from the texture’s own brightness, sampling one mip above the face’s for a soft, blocky average that survives distance:
fn bloxdTerrainSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
var out = bloxdDefaultSurface(surface);
// +1 mip = quarter resolution: a 4x4-texel average, cheap and stable
let avg = bloxdTexel(surface.textureId, surface.uv, surface.mipLevel + 1.0);
let lum = dot(avg.rgb, vec3f(0.2126, 0.7152, 0.0722));
if ((surface.blockFlags & bloxdBlockFlagEmissive) != 0u) {
// keep the engine look, add a gentle bloom source proportional to the texture itself
out.emission += avg.rgb * lum * 0.5;
}
return out;
}Texture-specific effects. Compare textureId and act only on chosen textures — the v4 replacement for “guess from colour”, and the sanctioned way to make e.g. ores glint:
fn bloxdTerrainLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
var out = bloxdDefaultLight(surface, light);
if (light.textureId == bloxdTextureIdDiamondOre) {
// sparkle: phase from world position + time
let p = bloxdWorldPosition(light.position);
let s = sin(bloxdSeconds() * 3.0 + p.x * 2.7 + p.y * 1.3 + p.z * 4.1);
out.colour += vec3f(0.35, 0.45, 0.55) * max(0.0, s);
}
return out;
}Depth-of-field-style distance blur on terrain detail — read a high mip far away, the native mip up close:
fn bloxdTerrainSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
var out = bloxdDefaultSurface(surface);
let d = distance(surface.position, bloxdEyePosition());
if (d > 40.0 && surface.textureId != 0u) {
// the engine's own texel for this face — carries tint and AO with it
let own = bloxdTexel(surface.textureId, surface.uv, surface.mipLevel);
if (any(abs(own.rgb - vec3f(0.0)) > vec3f(1e-6))) { // guard the division
// blur level rises with distance, up to +3 mips
let blur = clamp((d - 40.0) / 60.0, 0.0, 3.0);
let t = bloxdTexel(surface.textureId, surface.uv, surface.mipLevel + blur);
// restore tint & AO by ratio: (t / own) * colour
out.colour = t.rgb / own.rgb * out.colour;
}
}
return out;
}(The ratio trick keeps the engine’s colour = texture × tint × AO intact: dividing the blurred texel by the native texel cancels the texture content, leaving a blur factor you multiply back into surface.colour. On white vec4f(1.0) reads — untextured faces and anti-X-ray-culled faces — the guard skips the effect entirely.)
57.6 Where the texture API does not reach
- Vertex hooks cannot call it.
bloxdTexel/bloxdTextureSizeare surface/light-hook functions; a vertex hook reaching them is rejected with the “reaches” diagnostic (§65.3). - You cannot add textures. The atlas is the engine’s; the API reads it, nothing more. Custom textures remain the texture-pack system’s job, not the shader pack’s.
- Non-atlas renderer configurations degrade to stubs. On a configuration where the terrain material isn’t atlas-based, the engine compiles
bloxdTextureSize() -> vec2u(1u)andbloxdTexel(...) -> vec4f(1.0)and feeds the four input fields as0u, 0u, vec2f(0.0), 0.0. Code written against the real atlas still compiles and runs there — it just sees white texels and a 1×1 size. Write such code to toleratetextureId == 0and it tolerates this too.
58. The four new input fields
Both BloxdSurfaceIn and BloxdLightIn gain the same four trailing fields, quoted from the v4 header (the light struct carries the same quartet the surface struct does — your light hook can act on the texture without plumbing anything through the surface hook):
// These are 0 if the face has no texture.
textureId: u32, // This face's texture. Compare with bloxdTextureId*.
textureRotation: u32, // Quarter turns clockwise, which bloxdTexel applies.
uv: vec2f, // Texture coordinates in blocks; fract(uv) is drawn.
mipLevel: f32, // Texture mipmap level. 0 = full size, 1 = half, etc.textureId— the stable, name-derived id (§57.3).0on untextured faces; otherwise never0.textureRotation—0–3, quarter turns clockwise as the face displays the texture. Comes from geometry/texture-pack overrides (§63.2); same value in both hooks.uv— the interpolated texture coordinate in block units: one block of face area maps to one1.0of uv span, sofract(uv)is the within-block texture tile — the header’s own phrasing. On a wall of repeated stone,uvgrows along the wall whilefract(uv)tiles.mipLevel— the engine’s own choice of mip for this fragment, derived from screen-space derivatives of the texel position and clamped to the atlas’ level range (§63.1 has the exact formula).0on screen-filling faces, rising with distance/obliquity. It is a read — you can’t steer the engine’s sampling with it, but you can pass it (or± n) tobloxdTexel.
Recipe idea unique to v4 — uv-anchored detail patterns that respect the block grid without world coordinates:
// Fine grid keyed to the texture's own tiling: visible on every textured
// face, stable under camera motion, and free of floating-point world drift.
fn bloxdTerrainSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
var out = bloxdDefaultSurface(surface);
let cell = fract(surface.uv * 8.0); // 8x8 sub-tiles per block
let edge = min(min(cell.x, 1.0 - cell.x), min(cell.y, 1.0 - cell.y));
out.colour *= mix(vec3f(0.86), vec3f(1.0), step(0.06, edge));
return out;
}59. Renames and semantic changes
Four renames, one of which inverts its meaning. Everything else in the header — bloxdPi, bloxdTau, the six bloxdBlockFlag* constants and their bits (1/2/4/8/16/32), bloxdEyePosition / bloxdRenderOffset / bloxdSunDirection / bloxdSeconds, bloxdWorldPosition, the default hooks, the BLOXD_* macro matrix, the 8-variant matrix — is unchanged from v3, and the blockFlags name-classifier rules of §42 carry over verbatim.
| v3 | v4 | Note |
|---|---|---|
l.fogVisibility | l.fogAlpha | meaning inverted — port expressions, don’t just rename |
bloxdFaceBlock(pos, nrm) | bloxdFragmentBlockPosition(pos, nrm) | identical body: vec3i(floor(pos - nrm * 0.5)) + bloxdRenderOffset() |
behind.found | behind.hit | BloxdOpaqueBehind field rename |
| header first line | — | // Engine-provided and read-only, prepended to all packs. apiVersion 3. → // The Bloxd shader pack API, apiVersion 4. Read-only, prepended to all packs. |
59.1 fogVisibility → fogAlpha: the inverted one
v3: fogVisibility: f32, // 1 = no fog, 0 = fully fogged. v4: fogAlpha: f32, // 0 = no fog, 1 = only fogColour. The default fog application flipped with it:
// v3
fn bloxdApplyFog(colour: vec3f, light: BloxdLightIn) -> vec3f {
return mix(light.fogColour, colour, light.fogVisibility);
}
// v4
fn bloxdApplyFog(colour: vec3f, light: BloxdLightIn) -> vec3f {
return mix(colour, light.fogColour, light.fogAlpha);
}Port table — every v3 fog idiom has a mechanical v4 replacement:
| v3 expression | v4 port |
|---|---|
l.fogVisibility | 1.0 - l.fogAlpha |
mix(l.fogColour, col, l.fogVisibility) | mix(col, l.fogColour, l.fogAlpha) (or bloxdApplyFog(col, l)) |
mix(l.fogColour, col, max(l.fogVisibility, 0.15)) (fog floor) | mix(col, l.fogColour, min(l.fogAlpha, 0.85)) |
| “fog visibility is 1 up close” | “fogAlpha is 0 up close” |
The fog-distance behaviour is unchanged — same curve, same colours; only the field’s polarity and name moved. Note also the comment change on fogColour: v3 said games “always have fog”; v4 documents 0 when the game has no fog (and the engine indeed feeds vec3f(0.0) when the scene’s fog is off) — relevant if you divide by or compare against fogColour.
59.2 bloxdFaceBlock → bloxdFragmentBlockPosition
A pure rename — the engine’s own doc comment changed from “the world block the face … belongs to” to “identify the block’s world position”, the body is byte-identical, and parameter names remain free. Recipe R4 and every bloxdFaceBlock(l.position, l.normal) call site ports by search-and-replace.
59.3 found → hit
bloxdOpaqueBehind() still returns BloxdOpaqueBehind, still compiled only where BLOXD_SCENE_DEPTH is defined (liquid programs — §60.4), and its implementation is unchanged apart from the field name. Port behind.found → behind.hit and re-read the semantics from the v4 header comments: position and distance are 0 (not “meaningless”) when !hit. R-E (water absorption) and friends port mechanically.
60. The strict-games contract: vertex hooks, discard, and X-ray
Strict games are the rule, not the exception: everything defaults to strict, and only the 12 allow titles enumerated in the game policy list opt out (re-verified verbatim on the v4 bundle, 2026-10-27 — the same 12 titles: Test Gym, Doodle Cube, Rocket Obby, Creative, Bloxd Hop, Fishing, Dress Up, Evil Tower, Plots, Test Mode, Tsunami Steal Brainrots, Work at a Restaurant; every other title — survival, bedwars, skywars, custom games, … — is strict). v4 turns what used to be a documentation-level contract into an enforced one: the bundled validator analyses every strict variant and emits dedicated diagnostics.
60.1 The two enforced rules and their exact diagnostics
bloxdTerrainVertex moves terrain, which strict games prevent.
discard makes terrain see-through, which strict games prevent.
The mechanics, restored from the validator:
- A vertex hook defined in a strict variant (i.e. not wrapped in
#ifndef BLOXD_STRICT) triggers the first message. “Moves terrain” is taken literally: any vertex hook that isn’t the exact default passthrough counts (the check ismovesVertices = vertexHook && !isExactDefault— even a hook that returns the input unchanged but through different spelling counts as movement). - A
discardreachable from the surface or light hooks triggers the second.discarditself is newly legal in v4 for non-strict games — the v1–v3 hard prohibition is gone — but strict games treat it as X-ray (see below). - One trip disables everything in strict games. If a strict variant’s analysis produces any such diagnostic, the validator nulls all three hooks for the strict variants: the pack still loads, still runs in allow games, and in strict games does exactly nothing. An unguarded vertex hook therefore doesn’t just lose the sway — it loses your lighting too.
- Guarded code keeps the rest alive. With the template’s
#ifndef BLOXD_STRICTwraps, the strict variants define no vertex hook, produce no diagnostic, and your surface/light hooks keep running in strict games. That is the entire point of the template’s comment: “so our pack can stay on.”
The settings UI walks the author through exactly this. The status line, verbatim:
Off in strict games. To run any other parts of the pack in them, wrap each one listed below in #ifndef BLOXD_STRICT ... #endif
…followed by the offending hook list, each entry optionally suffixed (only in {{variants}}) with the variant axes spelled strict / non-strict, lighting on / off, terrain / liquid. And in-game, when a pack has nothing left to run under the current mode, the chat shows: Your shader pack is off in this game.
60.2 Why: X-ray
Both rules exist for the same reason — in competitive games, a shader that moves terrain or punches holes in it can reveal buried structures and ores: a vertex hook that pulls occluding blocks aside is a wall-hack, and discard on selected fragments is a pinhole X-ray. This is also why the engine’s own template guards only the vertex hooks: surface/light effects (colour, lighting, emission) can’t move geometry, so they’re safe everywhere. The community tutorial channel confirms the policy from the player side — grass-sway packs are the canonical “doesn’t work in strict games” example, and the anti-X-ray culling that strict games perform also hides some textures from the render path entirely, so even texel reads can come back white there. Design for strict-first: treat allow-games-only effects (sway, holes) as progressive enhancement, never as the headline feature.
60.3 What’s not in v4: the shadow API
The same community channel records the engine author as having a shadow-API draft (a bloxd-api companion file) that did not ship in this release, with block/grass shadows expected to arrive together with a future shader-pack API update. Nothing shadow-related exists in the v4 bundle (no shadow symbols, no reserved names beyond §63.4’s list) — treat shadows as announced-but-unshipped, and don’t build distribution packs against them yet. The skyLight-based projected-shadow recipes of R9.12 remain the only shadow look available in v4.
60.4 Strict recap for liquid authors
The macro matrix is unchanged from §46: BLOXD_ALPHA in every liquid variant plus non-strict terrain; BLOXD_SCENE_DEPTH in every liquid variant; BLOXD_STRICT / BLOXD_LIGHTING on their axes. Strict liquid programs still give you alpha and depth — only terrain alpha is strict-gated.
61. v3 → v4 migration checklist
pack.json:"apiVersion": 4— the number, not a string.- Rename
bloxdFaceBlock→bloxdFragmentBlockPositioneverywhere (arguments unchanged; parameter names free as always). - Port fog (the silent one — a pack that skips this compiles and looks wrong):
- every read
l.fogVisibility→1.0 - l.fogAlpha - every hand-rolled
mix(l.fogColour, col, VIS)→mix(col, l.fogColour, ALPHA)— or better, replace withbloxdApplyFog(col, l)and let the engine own the formula - floor/cap idioms invert with the field:
max(VIS, 0.15)→min(ALPHA, 0.85)
- every read
- Port depth recipes:
behind.found→behind.hit;position/distanceare0when!hit. - (Optional) Adopt the texture API:
bloxdTexel/bloxdTextureSize/bloxdTextureId*and the four new fields (§57–§58). Remember the rotation subtlety (57.4) and that texel code must toleratetextureId == 0. - Strict audit (required for distribution): wrap every vertex hook in
#ifndef BLOXD_STRICT ... #endif; if you usediscard, wrap it (or the hook containing it) the same way, or accept that strict games disable the whole pack’s hooks. - In-game compile check across the 8 variants: the loader screen’s “Checking the pack…” validates every variant at once — strict/non-strict × lighting on/off × terrain/liquid — so one pass covers it. Then eyeball one allow game (Test Mode is the fastest) and one strict game.
- Bump your own version metadata and re-distribute: stored v3 copies on players’ machines are silently inactive (§55) and only the settings tab says why.
61.1 A complete v3 → v4 port, before and after
// ---- v3 pack: hot sand shimmer + fog-aware emission ----
fn bloxdTerrainSurface(s: BloxdSurfaceIn) -> BloxdSurface {
var out = bloxdDefaultSurface(s);
if ((s.blockFlags & bloxdBlockFlagSand) != 0u) {
let p = bloxdWorldPosition(s.position);
out.colour *= 1.0 + 0.04 * sin(p.x * 7.0 + bloxdSeconds() * 2.0);
}
return out;
}
fn bloxdTerrainLight(s: BloxdSurface, l: BloxdLightIn) -> BloxdLight {
var out = bloxdDefaultLight(s, l);
// v3: keep glowing at distance by adding emission AFTER fog
let col = mix(l.fogColour, out.colour, l.fogVisibility);
out.colour = col + s.emission * l.fogVisibility;
return out;
}// ---- v4 port: same look, plus texel-aware sand and a texture guard ----
fn bloxdTerrainSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
var out = bloxdDefaultSurface(surface);
if ((surface.blockFlags & bloxdBlockFlagSand) != 0u) {
let p = bloxdWorldPosition(surface.position);
out.colour *= 1.0 + 0.04 * sin(p.x * 7.0 + bloxdSeconds() * 2.0);
}
// v4 extra: real texture knowledge — darken fine grain on close faces
if (surface.textureId != 0u && surface.mipLevel < 1.0) {
let t = bloxdTexel(surface.textureId, surface.uv, surface.mipLevel);
let grain = abs(dot(t.rgb, vec3f(0.33)) - 0.5);
out.colour *= 1.0 - 0.08 * grain;
}
return out;
}
fn bloxdTerrainLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
var out = bloxdDefaultLight(surface, light);
// v4: fogAlpha port — emission added after fog, gated by (1 - fogAlpha)
let col = mix(out.colour, light.fogColour, light.fogAlpha);
out.colour = col + surface.emission * (1.0 - light.fogAlpha);
return out;
}Both hooks are surface/light-only, so this pack needs no #ifndef BLOXD_STRICT wraps and runs (with its new texel effects) in strict games too. The textureId != 0u guard covers untextured faces; for strict games’ anti-X-ray culling, style effects should also degrade gracefully if a texel read comes back white despite a non-zero id — branch on ranges and ratios, never on one expected texel value.
62. Other v4 changes and notes
- The bundle reorg (numbers in the intro) moved the shader pipeline into chunks c49 (loader/persistence), c50–c51 (loader UI + zip), c53 (validator + header + registry builder), c54 (WGSL code generator + Lite renderer). For anyone re-researching the bundle after a v3-era guide: the anchors all moved, the code didn’t.
- The header text was rewritten for clarity — every doc comment re-worded (terser, second person), no semantic change beyond §59. Size 5,637 → 6,021 bytes, 128 → 150 lines; the first line is now
// The Bloxd shader pack API, apiVersion 4. Read-only, prepended to all packs. - Emission ordering is now documented in-header:
emission: vec3f, // Emissive RGB output, added after lighting, before fog.— v3’s §43 finding, now official wording. - i18n surface for the shader-pack feature is 58 keys (v4 build); the loader family (
load*) is quoted across §55–§56, the status family (status*) in §55, the variant labels in §60.1. - Reference material, embedded (intro): the engine’s error messages cite
bloxd-api.wgslandBLOCK_TEXTURES.md; this guide ships their content instead of citing them — the complete restored header (§67) and the complete measured catalogue (§68) — so nothing external is needed to author or debug a pack. - Auto-recheck now also fires on texture-registry changes (§65.1) — a consequence of the registry hash joining HEADER_VERSION. A saved pack can flip to “needs re-check” after an engine update that merely adds textures, even when the header text didn’t change. This is by design: your
bloxdTextureId*constants are baked at validation time. bloxdSp*reservation expanded to 27 symbols (§63.4) — the engine-private namespace inside generated shaders. The pack-level reservation rule is unchanged and broader: anything matching/^bloxd/i(case-insensitive) is reserved.
63. Engine internals: how bloxdTexel actually samples
As with §49–§51 for v3, the following is restored verbatim from the production bundle (chunk c54’s code generator, build cnty9, 2026-10-26) and is the deepest public account of the mechanism. Nothing in §57 goes beyond what these snippets prove.
63.1 The generated functions, verbatim
On renderer configurations with the atlas texture mode and no animation, the engine emits exactly:
var<private> bloxdSpTextureRotation: u32;
@group(3) @binding(2) var<storage, read> bloxdSpTextureLayers: array<u32>;
fn bloxdTextureSize(bloxdSpMipLevel: f32) -> vec2u {
return textureDimensions(textureAtlas0,
u32(clamp(round(bloxdSpMipLevel), 0.0,
f32(textureNumLevels(textureAtlas0) - 1u))));
}
fn bloxdTexel(bloxdSpTextureId: u32, bloxdSpUv: vec2f, bloxdSpMipLevel: f32) -> vec4f {
if (bloxdSpTextureId == 0u) {
return vec4f(1.0);
}
// Each quarter turn clockwise the face shows its texture at reads the
// unturned texture at (v, 1 - u)
var bloxdSpTurned = bloxdSpUv;
if (bloxdSpTextureRotation == 1u) {
bloxdSpTurned = vec2f(bloxdSpUv.y, 1.0 - bloxdSpUv.x);
} else if (bloxdSpTextureRotation == 2u) {
bloxdSpTurned = 1.0 - bloxdSpUv;
} else if (bloxdSpTextureRotation == 3u) {
bloxdSpTurned = vec2f(1.0 - bloxdSpUv.y, bloxdSpUv.x);
}
let bloxdSpLayer = bloxdSpTextureId - 1u;
return textureSampleLevel(textureAtlas0, atlasSampler, bloxdSpTurned,
bloxdSpLayer, round(bloxdSpMipLevel));
}With more than one atlas, the tail becomes a layer-window ladder — atlas k owns layers [k * layersPerAtlas, (k+1) * layersPerAtlas):
if (bloxdSpLayer < 2u * layersPerAtlas) {
return textureSampleLevel(textureAtlas1, atlasSampler, bloxdSpTurned,
bloxdSpLayer - layersPerAtlas, round(bloxdSpMipLevel));
}
// ... one rung per atlas, the last one unguarded ...
return textureSampleLevel(textureAtlasLast, atlasSampler, bloxdSpTurned,
bloxdSpLayer - N * layersPerAtlas, round(bloxdSpMipLevel));Note what this proves: textureId is the global 1-based layer index across all atlases (bloxdSpLayer = textureId - 1u), and bloxdTextureSize reads atlas 0 only — valid because all atlas tiers share dimensions.
63.2 Where the fragment’s texture quartet comes from
The per-vertex attribute texAtlasIndices (the geometry’s texture-slot index) is resolved through the storage buffer, not used directly:
// vertex stage (injected):
vertexOutputs.vPackTexture = bloxdSpTextureLayers[
min(u32(vertexInputs.texAtlasIndices), arrayLength(&bloxdSpTextureLayers) - 1u)];bloxdSpTextureLayers is filled on the JS side, one u32 per slot, packed exactly as:
layers[slot] = (id & 0xffff) | ((rotation & 3) << 16);The fragment stage unpacks both halves before your surface hook runs:
// fragment stage (injected, ahead of the surface hook):
let bloxdSpTexture = fragmentInputs.vPackTexture;
bloxdSpTextureRotation = bloxdSpTexture >> 16u; // -> textureRotation field
// BloxdSurfaceIn constructor tail:
// bloxdSpTexture & 0xffffu, // textureId
// bloxdSpTextureRotation, // textureRotation
// fragmentInputs.vMainUV1, // uv
// bloxdSpMipLevel // mipLevel (derived below)and the mip is derived exactly as the engine derives its own:
let bloxdSpTexelUV = fragmentInputs.vMainUV1 * atlasWidth;
let bloxdSpDdx = dpdx(bloxdSpTexelUV);
let bloxdSpDdy = dpdy(bloxdSpTexelUV);
let bloxdSpLod = 0.5 * log2(max(max(dot(bloxdSpDdx, bloxdSpDdx),
dot(bloxdSpDdy, bloxdSpDdy)), 1e-10));
let bloxdSpMipLevel = clamp(bloxdSpLod, 0.0,
f32(textureNumLevels(textureAtlas0) - 1u));Two consequences worth internalising: the rotation really is per-slot geometry data (there is no rotation-per-texture lookup anywhere — which is why §57.4’s subtlety exists), and the default (pack-less) terrain shader samples the atlas differently — it uses the pre-rotated layer copies directly at the raw uv, while the pack path normalises to the unturned layer and re-applies rotation in bloxdTexel. Same pixels, two representations.
63.3 Animation: the frame ladder
For animated textures the layer assignment grows a frame computation (this is the entire difference — sampling, rotation, and mip logic are unchanged):
let atlasIdxIn = f32(bloxdSpTextureId - 1u);
let animTick = material.anim.x; // animation clock
let animTickStride = material.anim.y;
let numAnimTextures = material.anim.z;
let animParamIndex = 3.0 * min(numAnimTextures, floor(atlasIdxIn));
let animStateMask = animDataPerTex[i32(animParamIndex)]; // frames - 1
let animTexIndexStart = animDataPerTex[i32(animParamIndex + 1.0)];
let animInterval = max(animTickStride, animDataPerTex[i32(animParamIndex + 2.0)]);
let animTickForTex = floor((animTickStride / animInterval) * animTick);
let animState = animTickForTex
- (animStateMask + 1.0) * floor(animTickForTex / (animStateMask + 1.0));
let isAnimTex = min(1.0, animState);
let bloxdSpFrame = (1.0 - isAnimTex) * atlasIdxIn
+ isAnimTex * (animTexIndexStart + animState - 1.0);
let bloxdSpLayer = u32(round(bloxdSpFrame));animDataPerTex (group 2, array<f32>) carries one {mask, startLayer, interval} triplet per animated texture, frames are power-of-two counted (a JS-side build check rejects non-power-of-2 frame counts with <block> has N animation states, which is not a power of 2), and the static-sentinel design means non-animated indices resolve through the same arithmetic without a branch. Pack-facing summary, once more: the id is stable, the frame is automatic. The intervals are engine content, and measured on cnty9 they take exactly three values — 200 ms (lava, toxic_waste, radar_screen), 250 ms (smoke, homestead_core_mid, the machine *_running families), 300 ms (the seventeen portals, toxic_waste_barrel_top) — the per-family column is §68.4.
63.4 The bloxdSp* namespace — all 27 symbols
Everything the generator can inject into your shader, i.e. everything you cannot redeclare (the pack-level /^bloxd/i reservation makes most of this moot, but for engine-source readers this is the complete v4 set, extracted from the generator’s templates):
bloxdSpBehind · bloxdSpDdx · bloxdSpDdy · bloxdSpEye · bloxdSpFrame · bloxdSpLayer · bloxdSpLight · bloxdSpLightIn · bloxdSpLitColour · bloxdSpLod · bloxdSpMipLevel · bloxdSpPixel · bloxdSpPositionW · bloxdSpScale · bloxdSpSceneDepth · bloxdSpSurface · bloxdSpSurfaceIn · bloxdSpTexelUV · bloxdSpTexture · bloxdSpTextureId · bloxdSpTextureLayers · bloxdSpTextureRotation · bloxdSpTurned · bloxdSpUv · bloxdSpVertex · bloxdSpVertexIn · bloxdSpZ
63.5 The full bind-group layout (Lite renderer, pack variant)
| Group | Binding | Resource | Notes |
|---|---|---|---|
| 0 | 0 | uniform scene | LiteSceneUniforms — viewProjection / view / vEyePosition |
| 1 | 2–3 | storage quads, quadLight | chunk geometry |
| 2 | 0 | uniform material | TerrainMaterialUniforms; anim drives §63.3 |
| 2 | 1+ | storage animDataPerTex | animated-texture triplets (animated configs only) |
| 2 | next | textureAtlas0..N-1 | texture_2d_array<f32>, one layer per texture |
| 2 | next | sampler atlasSampler | the one sampler bloxdTexel uses |
| 3 | 0 | uniform bloxdPackInputs | the pack’s 64 B per-frame uniform (§56) |
| 3 | 1 | texture_2d<f32> scene depth | liquid programs; backs bloxdOpaqueBehind() (§51) |
| 3 | 2 | storage bloxdSpTextureLayers | the id+rotation table (§63.2) |
Group 3 is the pack’s group: three engine-provided slots, none of them nameable by pack code.
64. The texture name registry
The engine builds the name catalogue once per session from the block registry — the same pipeline that produced the texture-pack system’s textureNameToIndex. The builder (module 28833 in the bundle), restored as pseudocode:
for each (name, index) in textureNameToIndex: # e.g. ("lava0", 0), ("radar_screen0[rot[2", 19)
if name matches /(.*)\[rot\[([1-4])$/ : # a turned copy slot
turnedSlot → { id: rootUnturnedId, rotation: N-1 } # §63.2's table entry
register alias: name → root, kind "rotation"
else if index is an animation frame (not the base): # via animDataPerTex
register alias: name → base, kind "frame"
else:
canonical name = strip trailing "_?0" if this texture is animated
named[canonical] = index + 1 # the bloxdTextureId* valueThe rules that matter to an author, deduplicated:
- Usable names are canonical names: animation bases drop their frame suffix (
lava0→lava), turned families fold to their root (chest_top[rot[1..4]→chest_top), and the two folds compose (radar_screen0[rot[1..4]→radar_screen, because that family is animated as well). Every other file name is itself. The constant spelling then CamelCases the canonical name (§57.3). - Frame and turned aliases are known and error-explained — using one isn’t a “did you mean” guess, it gets the specific frame/turned message (§57.3). This is deliberate API shaping:
bloxdTexelhandles both animation and turning for you, so addressing a frame or a turned copy directly is always the wrong move. - Ambiguity kills the name: two names that fold to the same case/underscore-insensitive key are both unusable (
could name X and Y ... it can't be used). Rare, but real — if a name you expect isn’t in the §68 catalogue, this is one reason. - The id is 1-based and equals “atlas layer + 1”; the no-texture id 0 is reserved as white.
Measured on the live registry (build cnty9, 2026-10-27, by running the engine’s own builder module on the shipped data): 1,219 atlas entries, folding 57 turned families (228 turned spellings) and 42 animated families (188 frame spellings), leaving 905 usable named constants — the complete list, with per-name ids and both family tables, is embedded as §68 below (and, in its current form, as the Texture catalog). The registry-hash mechanism in §65.1 is what keeps baked bloxdTextureId* values from silently going stale as those numbers drift.
65. Validation internals v4: HEADER_VERSION, the registry hash, special functions
65.1 HEADER_VERSION grows a second hash
The v3 format was 6.<fnv1a32> over five inputs (§53). v4 keeps the same five inputs — per-variant header tokens, the parser’s lexical universe, the four macro names, the special-function map, and the BloxdPackInputs declaration — but the prefix moves to 8. and a second FNV-1a-32 is appended, hashed over the sorted "<name> <id>" list of the entire texture registry:
v2 (sjr0p7): 6.bc5e8338
v3 (3ymzdd): 6.5bc26a63
v4 (cnty9): 8.<header-hash>.<registry-hash> ← format restored from the bundle(The concrete v4 hashes weren’t measured for this guide — they’re runtime-computed — but the format is exact, and the v2/v3 values above are the previously published measurements. Any pack settings screen after an engine update shows the current one.)
The consequence is the important part: a stored pack’s saved validation now also invalidates when the texture registry changes — engine adds textures, renames, re-orders — because your bloxdTextureId* comparisons were resolved against the old registry. The “needs re-check” flow that v3 triggered on header edits now has a second, content-driven trigger. Authors don’t act on this (the engine re-validates automatically); distributors should just expect it.
65.2 Reserved names, again, precisely
The rule is the regex /^bloxd/i — case-insensitive, so BloxdFoo is as reserved as bloxdFoo, and bloxdTextureIdAnything falls under it even when it names nothing (that’s why the misspelt-prefix diagnostic in §57.3 exists as its own message family). The 27-symbol bloxdSp* set of §63.4 is the engine-side complement inside generated code.
65.3 Special functions: now three
The validator’s special-function registry grew from v3’s one entry to three — the texture API’s two functions registered alongside depth:
[
["bloxdOpaqueBehind", { params: "", returns: "BloxdOpaqueBehind", symbol: "BLOXD_SCENE_DEPTH" }],
["bloxdTexel", { params: "textureId: u32, uv: vec2f, mipLevel: f32", returns: "vec4f", symbol: null }],
["bloxdTextureSize", { params: "mipLevel: f32", returns: "vec2u", symbol: null }]
]symbol: null means “no variant gate” — callable wherever the function exists (surface/light hooks). The two “reaches” diagnostics carry over verbatim, now also covering texture misuse:
${hook} reaches ${name}, which only surface and light hooks can use.— e.g.bloxdTexelfrom a vertex hook.
${hook} reaches ${name}, which needs ${symbol}, but this hook also runs on ${program}, which doesn't define it; guard the call with #ifdef ${symbol}.— e.g.bloxdOpaqueBehind()from terrain hooks without the wrap (unchanged from v3 §53).
65.4 What else carries over from v3 §53 unchanged
Hook signature checking (token-exact on types, free on names — the three signature entries are byte-identical to v3’s), the pack_-prefix renaming with diagnostic mapping, the undeclared-identifier message family, the parser’s extra lexical universe (bufferView, bufferArrayView, bufferLength, atomicStoreMax, atomicStoreMin — still not guaranteed in browsers), and the two-stage validation (built-in parser, then the browser’s WGSL compiler — still stricter; §38’s lessons hold).
66. Confirmed constants, limits, and layouts (v4)
The v4 row of the guide’s measurement ledger — everything here measured on cnty9 (2026-10-26, prod = preprod, byte-identical) unless a date is given:
| Item | Value |
|---|---|
apiVersion | 4 (strict ===, number) |
| Engine header | 6,021 B / 150 lines; first line // The Bloxd shader pack API, apiVersion 4. Read-only, prepended to all packs. — full text embedded in §67 |
| Hooks | 6 (terrain/liquid × vertex/surface/light); template comment-polished only |
| Variants | 8 (strict × lighting × program); names strict|allow.lit|unlit.terrain|liquid |
| Macros | BLOXD_STRICT (strict) · BLOXD_LIGHTING (lit) · BLOXD_ALPHA (all liquid + non-strict terrain) · BLOXD_SCENE_DEPTH (all liquid) |
| Pack uniform | @group(3) @binding(0), 64 B: seconds@0, renderOffset@16, sunDirection@32, eyePosition@48 |
| Pack bindings | group 3: 0 uniform · 1 scene depth (liquid) · 2 bloxdSpTextureLayers storage |
| blockFlags bits | opaque 1 · emissive 2 · vegetation 4 · dirt 8 · sand 16 · rock 32 (unchanged; §42 name rules carry over) |
| Loader limits | 256 .wgsl / 256 KB source / 64 KB pack.json / 32 MB zip / 1,024 zip entries; UTF-8; one manifest; unique paths |
| Texture registry | 1,219 entries (measured 2026-10-27, build cnty9) → 905 usable names; complete catalogue: §68 below (current form: Texture catalog) |
| Light curve | 0–15 levels → 0–1 on the ease-out curve (6 → 0.45, 12 → 0.92) — in-header, unchanged |
| Lift curve | 1 - (1 - x / (3 - 2x))^3 — unchanged, now in chunk c8 |
| Directional cone | 0.12 / 0.65 / 0.62 / 0.95 — unchanged, now in chunk c8 |
| Fog colour | vec3f(183/255, 191/255, 195/255) — unchanged; fogAlpha is the v4 name (§59.1) |
| Reserved names | /^bloxd/i (case-insensitive) + 27 bloxdSp* engine symbols |
| HEADER_VERSION | 8.<fnv1a32(header)>.<fnv1a32(texture registry)> |
| Strict titles | everything except the 12 allow titles listed in Game policy (re-verified 2026-10-27, unchanged) |
67. The complete v4 engine header, verbatim
This is the 6,021-byte, 150-line header the engine prepends to every pack, exactly as shipped in cnty9 — the same text whose first line opens // The Bloxd shader pack API, apiVersion 4. Read-only, prepended to all packs. (§66). It is reproduced here in full because a pack author should never have to wonder what the engine declares on their behalf: every free function you may call, every const you may compare against, and both input structs with all their fields and comments are below, in engine order.
Two things are not in this text and never were, because they are generated per renderer configuration at compile time rather than prepended per pack: the bloxdTexel/bloxdTextureSize pair (§63.1 has the verbatim generated WGSL) and the 27 bloxdSp* engine symbols (§63.4). The #ifdef BLOXD_ALPHA gate you see in BloxdSurface and bloxdDefaultSurface is resolved by the engine’s own preprocessor per variant — the canonical text keeps the gate, and §59.1/§56 explain which variants define it.
// The Bloxd shader pack API, apiVersion 4. Read-only, prepended to all packs.
const bloxdPi: f32 = 3.1415926535898;
const bloxdTau: f32 = 6.2831853071796;
// These functions return 1 value per frame, the same for every call site.
// The camera's render position.
fn bloxdEyePosition() -> vec3f {
return bloxdPackInputs.eyePosition;
}
// Changes as the player travels, so render positions stay close to 0,0,0.
// Integer distance, in blocks. Render position + this offset = world position.
// See bloxdWorldPosition for how this can be used.
fn bloxdRenderOffset() -> vec3i {
return bloxdPackInputs.renderOffset;
}
// This unit vector points towards the sun, in world orientation; 0 when no sun.
fn bloxdSunDirection() -> vec3f {
return bloxdPackInputs.sunDirection;
}
// Seconds since the page loaded. As an f32, it has sub-millisecond precision
// for the first 4.5 hours. Get a recurring timer using bloxdSeconds() % period.
fn bloxdSeconds() -> f32 {
return bloxdPackInputs.seconds;
}
// Each bit of the binary representation of blockFlags is a flag corresponding
// to a collection of blocks. The collections overlap, so blocks can be in 0-2+.
// (blockFlags & bloxdBlockFlagRock) != 0 // The block has this flag.
// (blockFlags & bloxdBlockFlagRock) == 0 // The block doesn't have this flag.
// Opaque blocks, leaves and ice included. Not glass, water, spawners, etc.
const bloxdBlockFlagOpaque: u32 = 1;
// These blocks emit light, e.g. neon, portals, lamps, lava, and glowing ores.
const bloxdBlockFlagEmissive: u32 = 2;
// 'Leafy', e.g. leaves, and grass blocks. Not cacti, mushroom blocks or hay.
const bloxdBlockFlagVegetation: u32 = 4;
// Dirt and soil, grass blocks included. Rocky Dirt is both dirt and rock.
const bloxdBlockFlagDirt: u32 = 8;
// Sand, Red Sand, and every sandstone, which is rock too.
const bloxdBlockFlagSand: u32 = 16;
// Stone variants, and more, e.g. gravel, ores, sandstone, magma and obsidian.
const bloxdBlockFlagRock: u32 = 32;
// Convert a render position to a world position, with possible f32 inaccuracy.
fn bloxdWorldPosition(position: vec3f) -> vec3f {
return position + vec3f(bloxdRenderOffset());
}
// Using a fragment's position and normal, identify the block's world position.
fn bloxdFragmentBlockPosition(position: vec3f, normal: vec3f) -> vec3i {
return vec3i(floor(position - normal * 0.5)) + bloxdRenderOffset();
}
struct BloxdVertexIn {
position: vec3f, // Render position.
normal: vec3f, // Unit vector direction pointing away from the face.
blockFlags: u32, // What kind of block. See bloxdBlockFlag*.
}
struct BloxdVertex {
position: vec3f, // The render position output.
}
struct BloxdSurfaceIn {
colour: vec3f, // RGB colour = texture * tint * ambient occlusion.
alpha: f32, // Opacity.
normal: vec3f, // Unit vector direction pointing away from the face.
position: vec3f, // Render position.
blockFlags: u32, // What kind of block. See bloxdBlockFlag*.
// These are 0 if the face has no texture.
textureId: u32, // This face's texture. Compare with bloxdTextureId*.
textureRotation: u32, // Quarter turns clockwise, which bloxdTexel applies.
uv: vec2f, // Texture coordinates in blocks; fract(uv) is drawn.
mipLevel: f32, // Texture mipmap level. 0 = full size, 1 = half, etc.
}
struct BloxdSurface {
colour: vec3f, // RGB colour output.
#ifdef BLOXD_ALPHA
alpha: f32, // Opacity output.
#endif
emission: vec3f, // Emissive RGB output, added after lighting, before fog.
}
// blockLight, skyLight and heldLight are 0-1, from the 0-15 light levels on an
// ease-out curve, e.g. 6->0.45, 12->0.92. They all exclude ambientLightColour.
struct BloxdLightIn {
litColour: vec3f, // RGB surface colour, lit, before emission and fog.
directional: f32, // Summed Lambert from directional lights; 0 when off.
ambient: vec3f, // RGB ambient colour, added to directional light.
blockLight: vec3f, // RGB block light; 0 without BLOXD_LIGHTING.
skyLight: f32, // Sky light; 1 without BLOXD_LIGHTING.
ambientLightColour: vec3f, // Minimum RGB light; 1 without BLOXD_LIGHTING.
skyLightColour: vec3f, // RGB colour of skyLight; 1 without BLOXD_LIGHTING.
heldLight: vec3f, // 0 without BLOXD_LIGHTING. 0 with no light source held.
fogColour: vec3f, // The game's RGB fog colour. 0 when the game has no fog.
fogAlpha: f32, // 0 = no fog, 1 = only fogColour.
position: vec3f, // Render position.
normal: vec3f, // Unit vector direction pointing away from the face.
blockFlags: u32, // What kind of block. See bloxdBlockFlag*.
// These are 0 if the face has no texture.
textureId: u32, // This face's texture. Compare with bloxdTextureId*.
textureRotation: u32, // Quarter turns clockwise, which bloxdTexel applies.
uv: vec2f, // Texture coordinates in blocks; fract(uv) is drawn.
mipLevel: f32, // Texture mipmap level. 0 = full size, 1 = half, etc.
}
struct BloxdLight {
colour: vec3f, // RGB colour output.
}
struct BloxdOpaqueBehind {
hit: bool, // False where nothing opaque is behind (sky).
position: vec3f, // The render position; 0 when !hit.
distance: f32, // From the camera; 0 when !hit.
}
fn bloxdDefaultVertex(vertex: BloxdVertexIn) -> BloxdVertex {
return BloxdVertex(vertex.position);
}
fn bloxdDefaultSurface(surface: BloxdSurfaceIn) -> BloxdSurface {
#ifdef BLOXD_ALPHA
return BloxdSurface(surface.colour, surface.alpha, vec3f(0.0));
#else
return BloxdSurface(surface.colour, vec3f(0.0));
#endif
}
// Applies this fragment's fog to colour, as the engine does.
fn bloxdApplyFog(colour: vec3f, light: BloxdLightIn) -> vec3f {
return mix(colour, light.fogColour, light.fogAlpha);
}
fn bloxdDefaultLight(surface: BloxdSurface, light: BloxdLightIn) -> BloxdLight {
return BloxdLight(bloxdApplyFog(light.litColour + surface.emission, light));
}68. The complete texture catalogue (905 names, measured)
68.1 How to read it
The Name column is the registry name — the handle you actually write. The constant spelling then CamelCases it on _ and - boundaries exactly as §57.3 documents: grass_top → bloxdTextureIdGrassTop, lava → bloxdTextureIdLava, chest_double_top_1_lo → bloxdTextureIdChestDoubleTop1Lo. Names are the API; they survive registry drift because the validator re-resolves them against the live registry at load.
The id column is what that constant compares equal to — the atlas layer + 1, measured on cnty9. Use it to interpret surface.textureId dumps and debug output, and to cross-check a misbehaving pack against today’s build. Do not hardcode it in WGSL: it is a snapshot of one build’s atlas order (§68.5 shows how fast it moves).
The Notes column marks the two folded families. animated (N frames) means sampling this name returns the current animation frame automatically — never address a frame suffix (lava0, radar_screen2), those are known aliases with dedicated diagnostics. turned (4 rotated copies) means the texture exists only as pre-rotated atlas slots; the name addresses the root and bloxdTexel re-applies the rotation (§57.4). One name carries both notes (radar_screen).
What is deliberately absent: the other 416 registry spellings — 188 frame aliases and 228 turned aliases — are not usable constants, and the engine explains each with its specific error message family when you try them (§57.3). The 1,219-row layer table behind everything (including the 171 pre-rotated slots) is engine-internal and covered in §63.2/§63.4.
68.2 The catalogue
Every usable name, alphabetically. The id column is the bloxdTextureId* value — the atlas layer + 1, measured on build cnty9 (2026-10-27). Treat ids as a snapshot, names as the API: between the two October builds measured for this guide, 779 of 1121 unchanged names got a different id (§68.5). The engine resolves names at validation time, so a pack written with names survives registry drift; a pack written with raw ids does not.
| Name | id (cnty9) | Notes |
|---|---|---|
alloy_kiln_back | 1091 | |
alloy_kiln_front | 1085 | |
alloy_kiln_side | 1086 | |
alloy_kiln_side_running | 33 | animated (4 frames) |
alloy_kiln_top | 1087 | turned (4 rotated copies) |
andesite_brick | 465 | |
apple_block_bottom | 441 | |
apple_block_side | 439 | |
apple_block_top | 440 | |
armour_lucky_block | 995 | |
armour_lucky_block_rare | 997 | |
armour_lucky_block_super | 999 | |
artisan_table_side | 367 | |
artisan_table_top | 368 | |
ash | 1031 | |
auto_bench_back | 1106 | |
auto_bench_front | 1100 | |
auto_bench_side | 1101 | |
auto_bench_side_running | 35 | animated (4 frames) |
auto_bench_top | 1102 | turned (4 rotated copies) |
autocrafter_bottom | 962 | |
autocrafter_lunite_bottom | 973 | |
autocrafter_lunite_side | 972 | |
autocrafter_side | 961 | |
banana_block_side | 899 | |
banana_block_top | 900 | |
beacon | 330 | |
bedrock | 334 | |
beetroot_block_bottom | 925 | |
beetroot_block_side | 923 | |
beetroot_block_top | 924 | |
belt_drop_side | 1185 | |
belt_drop_top | 1184 | |
belt_lift_side | 1183 | |
belt_lift_top | 1182 | |
belt_loader_slab_front | 1110 | |
belt_loader_top | 1109 | |
belt_tunnel_back | 1199 | |
belt_tunnel_exit_top | 1200 | turned (4 rotated copies) |
belt_tunnel_mouth | 1193 | |
belt_tunnel_side | 1194 | |
belt_tunnel_top | 1195 | turned (4 rotated copies) |
black_concrete | 273 | |
black_glazed_terracotta | 429 | turned (4 rotated copies) |
black_planks | 366 | |
black_portal | 2 | animated (4 frames) |
black_spawn_block_side | 760 | |
black_spawn_block_top | 756 | turned (4 rotated copies) |
block_destroyer_tnt_side | 1017 | |
block_destroyer_tnt_top | 1018 | |
blue_concrete | 274 | |
blue_gen_spawn_coal | 774 | |
blue_gen_spawn_iron | 775 | |
blue_gen_spawn_top | 773 | |
blue_glazed_terracotta | 413 | turned (4 rotated copies) |
blue_lucky_block | 994 | |
blue_lucky_block_rare | 996 | |
blue_lucky_block_super | 998 | |
blue_planks | 362 | |
blue_portal | 3 | animated (4 frames) |
blue_spawn_block_side | 755 | |
blue_spawn_block_top | 751 | turned (4 rotated copies) |
bone_block_side | 818 | |
bone_block_top | 819 | |
bookshelf | 564 | |
bookshelf_1 | 566 | |
bookshelf_2 | 567 | |
bookshelf_3 | 568 | |
bookshelf_4 | 569 | |
bookshelf_5 | 570 | |
bookshelf_empty | 565 | |
bouncy_bomb_block | 591 | |
bowling_alley_floor | 978 | |
bread_block_back | 435 | |
bread_block_front | 434 | |
bread_block_side | 436 | |
bread_block_top | 437 | |
brick | 315 | |
brown_concrete | 275 | |
brown_glazed_terracotta | 417 | turned (4 rotated copies) |
brown_mushroom_block | 536 | |
brown_planks | 363 | |
brown_portal | 4 | animated (4 frames) |
brown_spawn_block_side | 750 | |
brown_spawn_block_top | 746 | turned (4 rotated copies) |
building_lucky_block | 989 | |
building_lucky_block_rare | 991 | |
building_lucky_block_super | 993 | |
burner_drill_back | 1048 | |
burner_drill_bottom | 1047 | |
burner_drill_front | 1041 | |
burner_drill_side | 1042 | |
burner_drill_side_running | 27 | animated (4 frames) |
burner_drill_top | 1043 | turned (4 rotated copies) |
cactus_dry | 350 | |
cactus_top | 349 | |
carrot_block_bottom | 921 | |
carrot_block_side | 919 | |
carrot_block_top | 920 | |
carved_messy_stone | 827 | |
carved_pumpkin | 543 | |
chalk | 839 | |
chalk_black | 855 | |
chalk_blue | 854 | |
chalk_bricks_black | 871 | |
chalk_bricks_blue | 870 | |
chalk_bricks_brown | 869 | |
chalk_bricks_cyan | 868 | |
chalk_bricks_gray | 867 | |
chalk_bricks_green | 866 | |
chalk_bricks_light_blue | 865 | |
chalk_bricks_light_gray | 864 | |
chalk_bricks_lime | 863 | |
chalk_bricks_magenta | 862 | |
chalk_bricks_orange | 861 | |
chalk_bricks_pink | 860 | |
chalk_bricks_purple | 859 | |
chalk_bricks_red | 858 | |
chalk_bricks_slab_side_black | 887 | |
chalk_bricks_slab_side_blue | 886 | |
chalk_bricks_slab_side_brown | 885 | |
chalk_bricks_slab_side_cyan | 884 | |
chalk_bricks_slab_side_gray | 883 | |
chalk_bricks_slab_side_green | 882 | |
chalk_bricks_slab_side_light_blue | 881 | |
chalk_bricks_slab_side_light_gray | 880 | |
chalk_bricks_slab_side_lime | 879 | |
chalk_bricks_slab_side_magenta | 878 | |
chalk_bricks_slab_side_orange | 877 | |
chalk_bricks_slab_side_pink | 876 | |
chalk_bricks_slab_side_purple | 875 | |
chalk_bricks_slab_side_red | 874 | |
chalk_bricks_slab_side_white | 873 | |
chalk_bricks_slab_side_yellow | 872 | |
chalk_bricks_white | 857 | |
chalk_bricks_yellow | 856 | |
chalk_brown | 853 | |
chalk_cyan | 852 | |
chalk_gray | 851 | |
chalk_green | 850 | |
chalk_light_blue | 849 | |
chalk_light_gray | 848 | |
chalk_lime | 847 | |
chalk_magenta | 846 | |
chalk_orange | 845 | |
chalk_pink | 844 | |
chalk_purple | 843 | |
chalk_red | 842 | |
chalk_white | 841 | |
chalk_yellow | 840 | |
charge_vault_side | 1114 | |
charge_vault_top | 1113 | |
charging_pad_side | 1159 | |
charging_pad_top | 1158 | |
checkpoint_block | 761 | turned (4 rotated copies) |
cherry_block_bottom | 590 | |
cherry_block_side | 588 | |
cherry_block_top | 589 | |
chest_back | 347 | |
chest_double_back_hi | 1219 | |
chest_double_back_lo | 1218 | |
chest_double_front_hi | 1213 | |
chest_double_front_lo | 1212 | |
chest_double_top_1_hi | 1215 | |
chest_double_top_1_lo | 1214 | |
chest_double_top_2_hi | 1217 | |
chest_double_top_2_lo | 1216 | |
chest_front | 341 | |
chest_side | 342 | |
chest_top | 343 | turned (4 rotated copies) |
chili_pepper_block_bottom | 678 | |
chili_pepper_block_side | 676 | |
chili_pepper_block_top | 677 | |
chiseled_red_sandstone | 456 | |
chiseled_sandstone | 325 | |
clay | 195 | |
coal_block | 233 | |
coal_deposit | 1032 | |
coal_ore | 227 | |
coarse_dirt | 191 | |
coconut_block_bottom | 522 | |
coconut_block_side | 520 | |
coconut_block_top | 521 | |
code_block | 679 | |
comet_heart | 1170 | |
comet_ore | 1169 | |
compressed_messy_stone | 530 | |
conveyor_belt_bottom | 1081 | |
conveyor_belt_slab_side | 1080 | |
conveyor_belt_top | 1079 | |
conveyor_belt_turn_left | 1171 | |
conveyor_belt_turn_right | 1172 | |
copper_deposit | 1035 | |
copper_ore | 1040 | |
corn_block_bottom | 594 | |
corn_block_side | 592 | |
corn_block_top | 593 | |
crafting_table_side | 338 | |
crafting_table_top | 339 | |
crate | 918 | |
crop_harvester_back | 1192 | |
crop_harvester_back_running | 45 | animated (4 frames) |
crop_harvester_front | 1186 | |
crop_harvester_side | 1187 | |
crop_harvester_side_running | 44 | animated (4 frames) |
crop_harvester_top | 1188 | turned (4 rotated copies) |
crusher_back | 1055 | |
crusher_front | 1049 | |
crusher_side | 1050 | |
crusher_side_running | 28 | animated (4 frames) |
crusher_top | 1051 | turned (4 rotated copies) |
crystal_block | 1029 | |
crystal_vat_back | 1166 | |
crystal_vat_front | 1160 | |
crystal_vat_side | 1161 | |
crystal_vat_side_running | 42 | animated (4 frames) |
crystal_vat_top | 1162 | turned (4 rotated copies) |
custom_lobby_block_side | 769 | |
custom_lobby_block_top | 765 | turned (4 rotated copies) |
cut_red_sandstone | 457 | |
cut_sandstone | 453 | |
cyan_concrete | 276 | |
cyan_gen_spawn_coal | 783 | |
cyan_gen_spawn_iron | 784 | |
cyan_gen_spawn_top | 782 | |
cyan_glazed_terracotta | 405 | turned (4 rotated copies) |
cyan_planks | 360 | |
cyan_portal | 5 | animated (4 frames) |
cyan_spawn_block_side | 745 | |
cyan_spawn_block_top | 741 | turned (4 rotated copies) |
dark_green_bricks | 460 | |
darkstone | 1206 | |
darkstone_bricks | 1207 | |
darkstone_bricks_cracked | 1208 | |
darkstone_bricks_lava | 1209 | |
darkstone_engraved | 1210 | |
darkstone_smooth | 1211 | |
deep_drill_back | 1140 | |
deep_drill_bottom | 1139 | |
deep_drill_front | 1133 | |
deep_drill_side | 1134 | |
deep_drill_side_running | 39 | animated (4 frames) |
deep_drill_top | 1135 | turned (4 rotated copies) |
diamond_block | 340 | |
diamond_gen_spawn_side | 807 | |
diamond_gen_spawn_top | 806 | |
diamond_ore | 232 | |
diorite_brick | 463 | |
dirt | 190 | |
drop_location_block_side | 814 | |
drop_location_block_top | 813 | |
drop_pad | 1038 | |
dry_grass_block | 980 | |
dry_grass_block_side | 979 | |
electric_drill_back | 1099 | |
electric_drill_bottom | 1098 | |
electric_drill_front | 1092 | |
electric_drill_side | 1093 | |
electric_drill_side_running | 34 | animated (4 frames) |
electric_drill_top | 1094 | turned (4 rotated copies) |
emerald_block | 237 | |
emerald_ore | 231 | |
end_stone | 226 | |
engraved_andesite | 464 | |
engraved_diorite | 462 | |
engraved_granite | 466 | |
evil_lucky_block | 1022 | |
evil_lucky_block_face | 1023 | |
explosive_paint_black_side | 626 | |
explosive_paint_black_top | 627 | |
explosive_paint_blue_side | 624 | |
explosive_paint_blue_top | 625 | |
explosive_paint_brown_side | 622 | |
explosive_paint_brown_top | 623 | |
explosive_paint_cyan_side | 620 | |
explosive_paint_cyan_top | 621 | |
explosive_paint_gray_side | 618 | |
explosive_paint_gray_top | 619 | |
explosive_paint_green_side | 616 | |
explosive_paint_green_top | 617 | |
explosive_paint_light_blue_side | 614 | |
explosive_paint_light_blue_top | 615 | |
explosive_paint_light_gray_side | 612 | |
explosive_paint_light_gray_top | 613 | |
explosive_paint_lime_side | 610 | |
explosive_paint_lime_top | 611 | |
explosive_paint_magenta_side | 608 | |
explosive_paint_magenta_top | 609 | |
explosive_paint_orange_side | 606 | |
explosive_paint_orange_top | 607 | |
explosive_paint_pink_side | 604 | |
explosive_paint_pink_top | 605 | |
explosive_paint_purple_side | 602 | |
explosive_paint_purple_top | 603 | |
explosive_paint_quick_black | 643 | |
explosive_paint_quick_blue | 642 | |
explosive_paint_quick_brown | 641 | |
explosive_paint_quick_cyan | 640 | |
explosive_paint_quick_gray | 639 | |
explosive_paint_quick_green | 638 | |
explosive_paint_quick_light_blue | 637 | |
explosive_paint_quick_light_gray | 636 | |
explosive_paint_quick_lime | 635 | |
explosive_paint_quick_magenta | 634 | |
explosive_paint_quick_orange | 633 | |
explosive_paint_quick_pink | 632 | |
explosive_paint_quick_purple | 631 | |
explosive_paint_quick_red | 630 | |
explosive_paint_quick_white | 629 | |
explosive_paint_quick_yellow | 628 | |
explosive_paint_red_side | 600 | |
explosive_paint_red_top | 601 | |
explosive_paint_seeking_black | 659 | |
explosive_paint_seeking_blue | 658 | |
explosive_paint_seeking_brown | 657 | |
explosive_paint_seeking_cyan | 656 | |
explosive_paint_seeking_gray | 655 | |
explosive_paint_seeking_green | 654 | |
explosive_paint_seeking_light_blue | 653 | |
explosive_paint_seeking_light_gray | 652 | |
explosive_paint_seeking_lime | 651 | |
explosive_paint_seeking_magenta | 650 | |
explosive_paint_seeking_orange | 649 | |
explosive_paint_seeking_pink | 648 | |
explosive_paint_seeking_purple | 647 | |
explosive_paint_seeking_red | 646 | |
explosive_paint_seeking_white | 645 | |
explosive_paint_seeking_yellow | 644 | |
explosive_paint_sticky_black | 675 | |
explosive_paint_sticky_blue | 674 | |
explosive_paint_sticky_brown | 673 | |
explosive_paint_sticky_cyan | 672 | |
explosive_paint_sticky_gray | 671 | |
explosive_paint_sticky_green | 670 | |
explosive_paint_sticky_light_blue | 669 | |
explosive_paint_sticky_light_gray | 668 | |
explosive_paint_sticky_lime | 667 | |
explosive_paint_sticky_magenta | 666 | |
explosive_paint_sticky_orange | 665 | |
explosive_paint_sticky_pink | 664 | |
explosive_paint_sticky_purple | 663 | |
explosive_paint_sticky_red | 662 | |
explosive_paint_sticky_white | 661 | |
explosive_paint_sticky_yellow | 660 | |
explosive_paint_white_side | 598 | |
explosive_paint_white_top | 599 | |
explosive_paint_yellow_side | 596 | |
explosive_paint_yellow_top | 597 | |
extra_compressed_messy_stone | 531 | |
fallen_cherry_leaves_side | 586 | |
fallen_maple_leaves_side | 478 | |
farmland | 433 | |
fast_belt_slab_side | 1157 | |
fast_belt_top | 1156 | |
fast_belt_turn_left | 1173 | |
fast_belt_turn_right | 1174 | |
fertilised_soil | 926 | |
finish_block | 812 | |
fireball_block | 539 | |
food_lucky_block | 1007 | |
food_lucky_block_rare | 1009 | |
food_lucky_block_super | 1011 | |
forge_hopper_top | 1168 | |
furnace_front | 335 | |
furnace_side | 336 | |
furnace_top | 337 | |
generator_side | 1063 | |
generator_side_running | 30 | animated (4 frames) |
generator_top | 1064 | |
ghost_chest_back | 956 | |
ghost_chest_front | 953 | |
ghost_chest_side | 954 | |
ghost_chest_top | 955 | |
ghost_lucky_block | 957 | |
ghost_mystery_block | 958 | |
glass | 294 | |
glass_black | 295 | |
glass_blue | 296 | |
glass_brown | 297 | |
glass_cyan | 298 | |
glass_gray | 299 | |
glass_green | 301 | |
glass_light_blue | 302 | |
glass_light_gray | 300 | |
glass_lime | 303 | |
glass_magenta | 304 | |
glass_orange | 305 | |
glass_pink | 306 | |
glass_purple | 307 | |
glass_red | 308 | |
glass_silver | 311 | |
glass_white | 309 | |
glass_yellow | 310 | |
glowstone | 331 | |
gold_block | 235 | |
gold_deposit | 1036 | |
gold_ore | 229 | |
granite_brick | 467 | |
grass_block_side | 192 | |
grass_top | 193 | |
gravel | 196 | |
gray_concrete | 271 | |
gray_gen_spawn_coal | 792 | |
gray_gen_spawn_iron | 793 | |
gray_gen_spawn_top | 791 | |
gray_glazed_terracotta | 397 | turned (4 rotated copies) |
gray_planks | 358 | |
gray_portal | 6 | animated (4 frames) |
gray_spawn_block_side | 740 | |
gray_spawn_block_top | 736 | turned (4 rotated copies) |
green_bricks | 459 | |
green_concrete | 285 | |
green_glazed_terracotta | 421 | turned (4 rotated copies) |
green_lucky_block | 1006 | |
green_lucky_block_rare | 1008 | |
green_lucky_block_super | 1010 | |
green_planks | 364 | |
green_portal | 7 | animated (4 frames) |
green_spawn_block_side | 735 | |
green_spawn_block_top | 731 | turned (4 rotated copies) |
green_stone | 458 | |
grenade_block | 581 | |
grey_portal | 8 | animated (4 frames) |
gun_lucky_block | 952 | |
hardened_clay | 254 | |
hardened_clay_stained_black | 270 | |
hardened_clay_stained_blue | 266 | |
hardened_clay_stained_brown | 267 | |
hardened_clay_stained_cyan | 264 | |
hardened_clay_stained_gray | 262 | |
hardened_clay_stained_green | 268 | |
hardened_clay_stained_light_blue | 258 | |
hardened_clay_stained_lime | 260 | |
hardened_clay_stained_magenta | 257 | |
hardened_clay_stained_orange | 256 | |
hardened_clay_stained_pink | 261 | |
hardened_clay_stained_purple | 265 | |
hardened_clay_stained_red | 269 | |
hardened_clay_stained_silver | 263 | |
hardened_clay_stained_white | 255 | |
hardened_clay_stained_yellow | 259 | |
harvester_bottom | 969 | |
harvester_lunite_bottom | 977 | |
harvester_lunite_side_0 | 974 | |
harvester_lunite_side_1 | 975 | |
harvester_lunite_top | 976 | |
harvester_side0 | 966 | |
harvester_side1 | 967 | |
harvester_top | 968 | |
hay_block_side | 328 | |
homestead_core | 1037 | |
homestead_core_cap | 1122 | |
homestead_core_crown | 1121 | |
homestead_core_mid | 26 | animated (4 frames) |
hyper_compressed_messy_stone | 533 | |
ice | 326 | |
ice_brick | 468 | |
iceball_block | 540 | |
invisible_solid | 314 | |
iron_block | 234 | |
iron_chest_back | 917 | |
iron_chest_front | 911 | |
iron_chest_side | 912 | |
iron_chest_top | 913 | turned (4 rotated copies) |
iron_deposit | 1033 | |
iron_ore | 228 | |
iron_watermelon_side | 546 | |
iron_watermelon_top | 547 | |
jungle_grass_block | 889 | |
jungle_grass_block_side | 888 | |
lapis_block | 236 | |
lapis_ore | 230 | |
lava | 1 | animated (8 frames) |
leather_block_side | 908 | |
leather_block_top | 909 | |
leaves_aspen | 288 | |
leaves_aspen_autumn | 910 | |
leaves_cedar | 470 | |
leaves_cherry | 585 | |
leaves_cherry_fruity | 906 | |
leaves_jungle | 290 | |
leaves_mango | 894 | |
leaves_mango_fruity | 907 | |
leaves_maple | 289 | |
leaves_maple_autumn | 477 | |
leaves_maple_fruity | 901 | |
leaves_palm | 471 | |
leaves_palm_fruity | 904 | |
leaves_pear | 525 | |
leaves_pear_fruity | 905 | |
leaves_pine | 287 | |
leaves_pine_cone | 902 | |
leaves_plum | 469 | |
leaves_plum_fruity | 903 | |
leaves_spectral | 831 | |
light_blue_concrete | 277 | |
light_blue_glazed_terracotta | 381 | turned (4 rotated copies) |
light_blue_lucky_block | 933 | |
light_blue_planks | 354 | |
light_blue_spawn_block_side | 730 | |
light_blue_spawn_block_top | 726 | turned (4 rotated copies) |
light_gray_concrete | 272 | |
light_gray_glazed_terracotta | 401 | turned (4 rotated copies) |
light_gray_planks | 359 | |
light_gray_spawn_block_side | 725 | |
light_gray_spawn_block_top | 721 | turned (4 rotated copies) |
lightblue_portal | 9 | animated (4 frames) |
lightgray_portal | 10 | animated (4 frames) |
lime_concrete | 278 | |
lime_gen_spawn_coal | 777 | |
lime_gen_spawn_iron | 778 | |
lime_gen_spawn_top | 776 | |
lime_glazed_terracotta | 389 | turned (4 rotated copies) |
lime_planks | 356 | |
lime_portal | 11 | animated (4 frames) |
lime_spawn_block_side | 720 | |
lime_spawn_block_top | 716 | turned (4 rotated copies) |
log_ancient_maple | 1021 | |
log_aspen | 202 | |
log_cedar | 201 | |
log_cherry | 582 | |
log_jungle | 203 | |
log_mango | 891 | |
log_maple | 198 | |
log_palm | 472 | |
log_pear | 523 | |
log_pine | 199 | |
log_plum | 200 | |
log_spectral | 828 | |
lucky_block_pink_question | 959 | |
lucky_block_pink_question_rare | 1013 | |
lucky_block_pink_question_super | 1015 | |
lunite_block | 971 | |
lunite_ore | 970 | |
machine_bench_side | 1115 | |
machine_bench_top | 1116 | |
machine_side | 1039 | |
magenta_concrete | 279 | |
magenta_glazed_terracotta | 377 | turned (4 rotated copies) |
magenta_planks | 353 | |
magenta_portal | 12 | animated (4 frames) |
magenta_spawn_block_side | 715 | |
magenta_spawn_block_top | 711 | turned (4 rotated copies) |
magma | 451 | |
mailbox_front | 571 | |
mailbox_front_full | 573 | |
mailbox_side | 572 | |
mango_block_bottom | 898 | |
mango_block_side | 896 | |
mango_block_top | 897 | |
mega_compressed_messy_stone | 535 | |
melon_side | 544 | |
melon_top | 545 | |
melting_ice | 595 | |
messy_stone | 216 | |
mob_spawner_block_empty_side | 823 | |
mob_spawner_block_top | 821 | |
mob_spawner_hostile_block_side | 822 | |
mob_spawner_neutral_block_side | 838 | |
mob_spawner_passive_block_side | 820 | |
moonstone_block | 450 | |
moonstone_chest_back | 449 | |
moonstone_chest_front | 443 | |
moonstone_chest_side | 444 | |
moonstone_chest_top | 445 | turned (4 rotated copies) |
moonstone_explosive_side | 332 | |
moonstone_explosive_top | 333 | |
moonstone_gen_spawn_side | 809 | |
moonstone_gen_spawn_top | 808 | |
moonstone_ore | 442 | |
mossy_cobblestone | 438 | |
mushroom_stem | 538 | |
mystery_block | 578 | |
neon_black | 951 | |
neon_blue | 950 | |
neon_brown | 949 | |
neon_cyan | 948 | |
neon_gray | 947 | |
neon_green | 946 | |
neon_light_blue | 945 | |
neon_light_gray | 944 | |
neon_lime | 943 | |
neon_magenta | 942 | |
neon_orange | 941 | |
neon_pink | 940 | |
neon_purple | 939 | |
neon_red | 938 | |
neon_white | 937 | |
neon_yellow | 936 | |
nether_brick | 317 | |
netherrack | 318 | |
obby_absorb_block | 816 | |
obby_absorb_death_block | 817 | |
obby_death_block | 815 | |
obsidian | 327 | |
orange_concrete | 280 | |
orange_glazed_terracotta | 373 | turned (4 rotated copies) |
orange_lucky_block | 1000 | |
orange_lucky_block_rare | 1002 | |
orange_lucky_block_super | 1004 | |
orange_planks | 352 | |
orange_portal | 13 | animated (4 frames) |
orange_spawn_block_side | 710 | |
orange_spawn_block_top | 706 | turned (4 rotated copies) |
ore_gen_spawn_side | 811 | |
ore_gen_spawn_top | 810 | |
packed_snow | 826 | |
parts_bench_side | 1117 | |
parts_bench_top | 1118 | |
patterned_glass_black | 548 | |
patterned_glass_blue | 549 | |
patterned_glass_brown | 550 | |
patterned_glass_cyan | 551 | |
patterned_glass_gray | 552 | |
patterned_glass_green | 554 | |
patterned_glass_light_blue | 555 | |
patterned_glass_light_gray | 553 | |
patterned_glass_lime | 556 | |
patterned_glass_magenta | 557 | |
patterned_glass_orange | 558 | |
patterned_glass_pink | 559 | |
patterned_glass_purple | 560 | |
patterned_glass_red | 561 | |
patterned_glass_white | 562 | |
patterned_glass_yellow | 563 | |
pear_block_bottom | 529 | |
pear_block_side | 527 | |
pear_block_top | 528 | |
pet_lucky_block | 960 | |
pine_cone_block_side | 836 | |
pine_cone_block_top | 837 | |
pine_grass_block | 834 | |
pine_grass_block_side | 833 | |
pink_concrete | 281 | |
pink_gen_spawn_coal | 789 | |
pink_gen_spawn_iron | 790 | |
pink_gen_spawn_top | 788 | |
pink_glazed_terracotta | 393 | turned (4 rotated copies) |
pink_planks | 357 | |
pink_portal | 14 | animated (4 frames) |
pink_spawn_block_side | 705 | |
pink_spawn_block_top | 701 | turned (4 rotated copies) |
planks_aspen | 205 | |
planks_cedar | 209 | |
planks_cherry | 584 | |
planks_jungle | 207 | |
planks_mango | 893 | |
planks_maple | 204 | |
planks_palm | 473 | |
planks_pear | 524 | |
planks_pine | 208 | |
planks_plum | 206 | |
planks_spectral | 830 | |
plum_block_bottom | 519 | |
plum_block_side | 517 | |
plum_block_top | 518 | |
podzol_top | 452 | |
potato_block | 922 | |
potion_lucky_block | 1012 | |
potion_lucky_block_rare | 1014 | |
potion_lucky_block_super | 1016 | |
press_back | 1071 | |
press_front | 1065 | |
press_side | 1066 | |
press_side_running | 31 | animated (4 frames) |
press_top | 1067 | turned (4 rotated copies) |
protector | 348 | |
protector_faction | 575 | |
protector_tribe | 574 | |
pumpkin_face_on | 291 | |
pumpkin_side | 541 | |
pumpkin_top | 542 | |
pure_coal_ore | 1024 | |
pure_copper_ore | 1204 | |
pure_diamond_ore | 1027 | |
pure_gold_ore | 1026 | |
pure_iron_ore | 1025 | |
pure_moonstone_ore | 1028 | |
pure_voltite_ore | 1205 | |
purple_concrete | 282 | |
purple_glazed_terracotta | 409 | turned (4 rotated copies) |
purple_lucky_block | 988 | |
purple_lucky_block_rare | 990 | |
purple_lucky_block_super | 992 | |
purple_planks | 361 | |
purple_portal | 15 | animated (4 frames) |
purple_spawn_block_side | 700 | |
purple_spawn_block_top | 696 | turned (4 rotated copies) |
quartz_block_chiseled | 320 | |
quartz_block_side | 319 | |
radar_bottom | 929 | |
radar_screen | 19 | animated (4 frames) · turned (4 rotated copies) |
radar_side_active | 927 | |
radar_side_inactive | 930 | |
radar_top_active | 928 | |
radar_top_inactive | 931 | |
recycler_back | 1181 | |
recycler_front | 1175 | |
recycler_side | 1176 | |
recycler_side_running | 43 | animated (4 frames) |
recycler_top | 1177 | turned (4 rotated copies) |
red_concrete | 283 | |
red_gen_spawn_coal | 771 | |
red_gen_spawn_iron | 772 | |
red_gen_spawn_top | 770 | |
red_glazed_terracotta | 425 | turned (4 rotated copies) |
red_lucky_block | 934 | |
red_lucky_block_rare | 984 | |
red_lucky_block_super | 986 | |
red_mushroom_block | 537 | |
red_planks | 365 | |
red_portal | 16 | animated (4 frames) |
red_sand | 474 | |
red_sandstone | 454 | |
red_sandstone_brick | 475 | |
red_sandstone_top | 455 | |
red_spawn_block_side | 695 | |
red_spawn_block_top | 691 | turned (4 rotated copies) |
redstone_lamp_off | 313 | |
redstone_lamp_on | 312 | |
rocket_block | 579 | |
rocky_dirt | 476 | |
rope_block | 1030 | |
sand | 194 | |
sandstone_brick | 461 | |
sandstone_normal | 225 | |
sandstone_top | 324 | |
shatter_mill_back | 1147 | |
shatter_mill_front | 1141 | |
shatter_mill_side | 1142 | |
shatter_mill_side_running | 40 | animated (4 frames) |
shatter_mill_top | 1143 | turned (4 rotated copies) |
shop_trader_spawn_face | 799 | |
shop_trader_spawn_side | 798 | |
shop_trader_spawn_top | 794 | turned (4 rotated copies) |
shop_wizard_spawn_face | 805 | |
shop_wizard_spawn_side | 804 | |
shop_wizard_spawn_top | 800 | turned (4 rotated copies) |
sky_tap_back | 1155 | |
sky_tap_bottom | 1154 | |
sky_tap_front | 1148 | |
sky_tap_side | 1149 | |
sky_tap_side_running | 41 | animated (4 frames) |
sky_tap_top | 1150 | turned (4 rotated copies) |
slab_andesite_brick_side | 498 | |
slab_aspen_side | 483 | |
slab_brick_side | 515 | |
slab_cedar_side | 482 | |
slab_cherry_side | 587 | |
slab_chiseled_red_sandstone_side | 512 | |
slab_chiseled_sandstone_side | 508 | |
slab_cobblestone_side | 488 | |
slab_cut_red_sandstone_side | 513 | |
slab_cut_sandstone_side | 509 | |
slab_diorite_brick_side | 502 | |
slab_dirt_side | 486 | |
slab_dry_grass_top_side | 981 | |
slab_engraved_andesite_side | 497 | |
slab_engraved_diorite_side | 501 | |
slab_engraved_granite_side | 505 | |
slab_granite_brick_side | 506 | |
slab_grass_top_side | 487 | |
slab_ice_brick_side | 516 | |
slab_jungle_grass_top_side | 890 | |
slab_jungle_side | 484 | |
slab_mango_side | 895 | |
slab_maple_side | 479 | |
slab_mossy_cobblestone_side | 493 | |
slab_palm_side | 485 | |
slab_pear_side | 526 | |
slab_pine_grass_top_side | 835 | |
slab_pine_side | 480 | |
slab_plum_side | 481 | |
slab_red_sandstone_brick_side | 514 | |
slab_red_sandstone_side | 511 | |
slab_sandstone_brick_side | 510 | |
slab_sandstone_normal_side | 507 | |
slab_smooth_stone_side | 490 | |
slab_spectral_side | 832 | |
slab_stone_andesite_side | 495 | |
slab_stone_andesite_smooth_side | 496 | |
slab_stone_diorite_side | 499 | |
slab_stone_diorite_smooth_side | 500 | |
slab_stone_granite_side | 503 | |
slab_stone_granite_smooth_side | 504 | |
slab_stone_side | 489 | |
slab_stonebrick_carved_side | 491 | |
slab_stonebrick_mossy_side | 494 | |
slab_stonebrick_side | 492 | |
smelter_back | 1062 | |
smelter_front | 1056 | |
smelter_side | 1057 | |
smelter_side_running | 29 | animated (4 frames) |
smelter_top | 1058 | turned (4 rotated copies) |
smoke | 23 | animated (4 frames) |
smooth_stone | 218 | |
snow | 197 | |
snowy_messy_stone | 824 | |
snowy_messy_stone_side | 825 | |
solar_panel_bottom | 965 | |
solar_panel_side | 963 | |
solar_panel_top | 964 | |
sorting_gate_slab_side | 1108 | |
sorting_gate_top | 1107 | |
splitter_slab_side | 1083 | |
splitter_top | 1082 | |
sponge | 329 | |
starframe | 1167 | |
stone | 217 | |
stone_andesite | 221 | |
stone_andesite_smooth | 222 | |
stone_deposit | 1034 | |
stone_diorite | 219 | |
stone_diorite_smooth | 220 | |
stone_granite | 223 | |
stone_granite_smooth | 224 | |
stonebrick | 316 | |
stonebrick_carved | 321 | |
stonebrick_cracked | 323 | |
stonebrick_mossy | 322 | |
storage_silo_side | 1112 | |
storage_silo_top | 1111 | |
stripped_aspen_log | 211 | |
stripped_cedar_log | 215 | |
stripped_cherry_log | 583 | |
stripped_jungle_log | 213 | |
stripped_mango_log | 892 | |
stripped_maple_log | 210 | |
stripped_palm_log | 576 | |
stripped_pear_log | 577 | |
stripped_pine_log | 214 | |
stripped_plum_log | 212 | |
stripped_spectral_log | 829 | |
super_compressed_messy_stone | 532 | |
super_rocket_block | 580 | |
tool_bench_side | 1119 | |
tool_bench_top | 1120 | |
tools_lucky_block | 1001 | |
tools_lucky_block_rare | 1003 | |
tools_lucky_block_super | 1005 | |
toxic_waste | 25 | animated (8 frames) |
toxic_waste_barrel_bottom | 1020 | |
toxic_waste_barrel_side | 1019 | |
toxic_waste_barrel_top | 24 | animated (4 frames) |
toxin_ball_block | 680 | |
tree_cutter_back | 1129 | |
tree_cutter_back_running | 37 | animated (4 frames) |
tree_cutter_front | 1123 | |
tree_cutter_side | 1124 | |
tree_cutter_side_running | 36 | animated (4 frames) |
tree_cutter_top | 1125 | turned (4 rotated copies) |
ultra_compressed_messy_stone | 534 | |
unloaded | 189 | |
volt_engine_side | 1131 | |
volt_engine_side_running | 38 | animated (4 frames) |
volt_engine_top | 1132 | |
voltite_deposit | 1130 | |
voltite_ore | 1084 | |
watermelon_side | 292 | |
watermelon_top | 293 | |
weapon_lucky_block | 935 | |
weapon_lucky_block_rare | 985 | |
weapon_lucky_block_super | 987 | |
white_concrete | 284 | |
white_gen_spawn_coal | 786 | |
white_gen_spawn_iron | 787 | |
white_gen_spawn_top | 785 | |
white_glazed_terracotta | 369 | turned (4 rotated copies) |
white_planks | 351 | |
white_portal | 17 | animated (4 frames) |
white_spawn_block_side | 690 | |
white_spawn_block_top | 686 | turned (4 rotated copies) |
wire_mill_back | 1078 | |
wire_mill_front | 1072 | |
wire_mill_side | 1073 | |
wire_mill_side_running | 32 | animated (4 frames) |
wire_mill_top | 1074 | turned (4 rotated copies) |
wool_colored_black | 253 | |
wool_colored_blue | 249 | |
wool_colored_brown | 250 | |
wool_colored_cyan | 247 | |
wool_colored_gray | 245 | |
wool_colored_green | 251 | |
wool_colored_light_blue | 241 | |
wool_colored_light_grey | 246 | |
wool_colored_lime | 243 | |
wool_colored_magenta | 240 | |
wool_colored_orange | 239 | |
wool_colored_pink | 244 | |
wool_colored_purple | 248 | |
wool_colored_red | 252 | |
wool_colored_white | 238 | |
wool_colored_yellow | 242 | |
yellow_concrete | 286 | |
yellow_gen_spawn_coal | 780 | |
yellow_gen_spawn_iron | 781 | |
yellow_gen_spawn_top | 779 | |
yellow_glazed_terracotta | 385 | turned (4 rotated copies) |
yellow_lucky_block | 932 | |
yellow_lucky_block_rare | 982 | |
yellow_lucky_block_super | 983 | |
yellow_planks | 355 | |
yellow_portal | 18 | animated (4 frames) |
yellow_spawn_block_side | 685 | |
yellow_spawn_block_top | 681 | turned (4 rotated copies) |
68.3 Turned families (57 roots)
These textures exist only as pre-rotated copies (name[rot[1..4). The registry folds them to the root below; bloxdTexel re-applies the rotation when sampling (§57.4), so you address the root and never the copies. Aliasing one of the [rot[N spellings gets the dedicated turned-name diagnostic (§57.3).
alloy_kiln_top(id 1087)auto_bench_top(id 1102)belt_tunnel_exit_top(id 1200)belt_tunnel_top(id 1195)black_glazed_terracotta(id 429)black_spawn_block_top(id 756)blue_glazed_terracotta(id 413)blue_spawn_block_top(id 751)brown_glazed_terracotta(id 417)brown_spawn_block_top(id 746)burner_drill_top(id 1043)checkpoint_block(id 761)chest_top(id 343)crop_harvester_top(id 1188)crusher_top(id 1051)crystal_vat_top(id 1162)custom_lobby_block_top(id 765)cyan_glazed_terracotta(id 405)cyan_spawn_block_top(id 741)deep_drill_top(id 1135)electric_drill_top(id 1094)gray_glazed_terracotta(id 397)gray_spawn_block_top(id 736)green_glazed_terracotta(id 421)green_spawn_block_top(id 731)iron_chest_top(id 913)light_blue_glazed_terracotta(id 381)light_blue_spawn_block_top(id 726)light_gray_glazed_terracotta(id 401)light_gray_spawn_block_top(id 721)lime_glazed_terracotta(id 389)lime_spawn_block_top(id 716)magenta_glazed_terracotta(id 377)magenta_spawn_block_top(id 711)moonstone_chest_top(id 445)orange_glazed_terracotta(id 373)orange_spawn_block_top(id 706)pink_glazed_terracotta(id 393)pink_spawn_block_top(id 701)press_top(id 1067)purple_glazed_terracotta(id 409)purple_spawn_block_top(id 696)radar_screen0(id 19) · also animatedrecycler_top(id 1177)red_glazed_terracotta(id 425)red_spawn_block_top(id 691)shatter_mill_top(id 1143)shop_trader_spawn_top(id 794)shop_wizard_spawn_top(id 800)sky_tap_top(id 1150)smelter_top(id 1058)tree_cutter_top(id 1125)white_glazed_terracotta(id 369)white_spawn_block_top(id 686)wire_mill_top(id 1074)yellow_glazed_terracotta(id 385)yellow_spawn_block_top(id 681)
68.4 Animated families (42 names)
Sampling one of these names returns the current animation frame automatically (§63.3’s frame ladder). The engine advances frames per texture at a fixed, per-family interval — measured on cnty9 it takes exactly three values: 200 ms (lava, toxic_waste, radar_screen), 250 ms (smoke, homestead_core_mid, every machine *_running family), 300 ms (the seventeen portals and toxic_waste_barrel_top) — see the Interval column — so packs never address a frame suffix (lava0 is an error; lava is the name).
| Name | Frames | Interval | Registry base |
|---|---|---|---|
lava | 8 | 200 ms | lava0 |
toxic_waste | 8 | 200 ms | toxic_waste0 |
alloy_kiln_side_running | 4 | 250 ms | alloy_kiln_side_running0 |
auto_bench_side_running | 4 | 250 ms | auto_bench_side_running0 |
black_portal | 4 | 300 ms | black_portal0 |
blue_portal | 4 | 300 ms | blue_portal0 |
brown_portal | 4 | 300 ms | brown_portal0 |
burner_drill_side_running | 4 | 250 ms | burner_drill_side_running0 |
crop_harvester_back_running | 4 | 250 ms | crop_harvester_back_running0 |
crop_harvester_side_running | 4 | 250 ms | crop_harvester_side_running0 |
crusher_side_running | 4 | 250 ms | crusher_side_running0 |
crystal_vat_side_running | 4 | 250 ms | crystal_vat_side_running0 |
cyan_portal | 4 | 300 ms | cyan_portal0 |
deep_drill_side_running | 4 | 250 ms | deep_drill_side_running0 |
electric_drill_side_running | 4 | 250 ms | electric_drill_side_running0 |
generator_side_running | 4 | 250 ms | generator_side_running0 |
gray_portal | 4 | 300 ms | gray_portal0 |
green_portal | 4 | 300 ms | green_portal0 |
grey_portal | 4 | 300 ms | grey_portal0 |
homestead_core_mid | 4 | 250 ms | homestead_core_mid0 |
lightblue_portal | 4 | 300 ms | lightblue_portal0 |
lightgray_portal | 4 | 300 ms | lightgray_portal0 |
lime_portal | 4 | 300 ms | lime_portal0 |
magenta_portal | 4 | 300 ms | magenta_portal0 |
orange_portal | 4 | 300 ms | orange_portal0 |
pink_portal | 4 | 300 ms | pink_portal0 |
press_side_running | 4 | 250 ms | press_side_running0 |
purple_portal | 4 | 300 ms | purple_portal0 |
radar_screen | 4 | 200 ms | radar_screen0[rot[1 |
recycler_side_running | 4 | 250 ms | recycler_side_running0 |
red_portal | 4 | 300 ms | red_portal0 |
shatter_mill_side_running | 4 | 250 ms | shatter_mill_side_running0 |
sky_tap_side_running | 4 | 250 ms | sky_tap_side_running0 |
smelter_side_running | 4 | 250 ms | smelter_side_running0 |
smoke | 4 | 250 ms | smoke0 |
toxic_waste_barrel_top | 4 | 300 ms | toxic_waste_barrel_top0 |
tree_cutter_back_running | 4 | 250 ms | tree_cutter_back_running0 |
tree_cutter_side_running | 4 | 250 ms | tree_cutter_side_running0 |
volt_engine_side_running | 4 | 250 ms | volt_engine_side_running0 |
white_portal | 4 | 300 ms | white_portal0 |
wire_mill_side_running | 4 | 250 ms | wire_mill_side_running0 |
yellow_portal | 4 | 300 ms | yellow_portal0 |
One structural note the raw data makes visible: the atlas holds 45 animated roots, not 42 — radar_screen’s four pre-rotated copies each carry their own 4-frame ladder, which is also why radar_screen is the one name bearing both family notes.
68.5 Registry drift, measured (sjr0p7 → cnty9)
The registry is content shipped with the build, so it drifts with block updates. The two builds this guide measured (2026-10-17 and 2026-10-27, ten days apart) show exactly how fast:
- Entries: 1200 → 1219 (98 added, 79 removed)
- Names that kept their spelling: 1121 — of which 779 changed id (69%)
- A naming convention migrated mid-month: 68
_rot1..4suffix names (e.g.chest_top_rot1) became[rot[1..4slots (e.g.chest_top[rot[1), and the double-chest textures (chest_double_*, 8 entries) appeared with them - The usable-name count moved 900 → 905, and the registry hash in
HEADER_VERSION(§65.1) re-invalidated every saved pack that had baked ids
That last point is the operational lesson: write bloxdTextureIdLava, not 19 — a name-constant survives every one of those bullets unchanged, because the validator re-resolves it against the live registry at load.
68.6 The drift lists, in full (98 added, 79 removed)
§68.5’s headline numbers, spelled out name by name — because a texture-pack author updating an October pack needs to know exactly which file names stopped matching. The lists compare the spelling layer (the file names texture packs use); §64’s folding rules are what turn spellings into the usable constants of §68.2.
Turned-fold migration — 17 machine tops (68 spellings out, 68 slots in). alloy_kiln_top, auto_bench_top, belt_tunnel_exit_top, belt_tunnel_top, burner_drill_top, crop_harvester_top, crusher_top, crystal_vat_top, deep_drill_top, electric_drill_top, press_top, recycler_top, shatter_mill_top, sky_tap_top, smelter_top, tree_cutter_top, wire_mill_top moved from _rot1..4 variant spellings to [rot[1..4 pre-rotated slots; the folded root is the usable name, so a texture pack now ships one X_top.png instead of four X_top_rotN.png files.
Chest tops folded — 3 families (6 spellings out, 12 slots in). chest_top_1/chest_top_2 → chest_top, iron_chest_top_1/_2 → iron_chest_top, moonstone_chest_top_1/_2 → moonstone_chest_top: the two-variant spellings became pre-rotated slots under the root — rename the PNG files accordingly.
New textures — 17 names. The double chest (chest_double_back_hi/_lo, chest_double_front_hi/_lo, chest_double_top_1_hi/_lo, chest_double_top_2_hi/_lo), the darkstone family (darkstone, darkstone_bricks, darkstone_bricks_cracked, darkstone_bricks_lava, darkstone_engraved, darkstone_smooth), pure_copper_ore, pure_voltite_ore, and forge_hopper_top.
One plain fold. ghost_chest_top_1/ghost_chest_top_2 collapsed to a single ghost_chest_top.
Removed outright — 3 names. shaft_hopper_top, sun_panel_side, sun_panel_top have no successor spelling in the new registry — the content left the game with this build. forge_hopper_top is a genuinely new texture, not a verified rename.
The raw spelling diff, for verification:
+ 98 added (cnty9):
alloy_kiln_top[rot[1, alloy_kiln_top[rot[2, alloy_kiln_top[rot[3, alloy_kiln_top[rot[4, auto_bench_top[rot[1, auto_bench_top[rot[2
auto_bench_top[rot[3, auto_bench_top[rot[4, belt_tunnel_exit_top[rot[1, belt_tunnel_exit_top[rot[2, belt_tunnel_exit_top[rot[3, belt_tunnel_exit_top[rot[4
belt_tunnel_top[rot[1, belt_tunnel_top[rot[2, belt_tunnel_top[rot[3, belt_tunnel_top[rot[4, burner_drill_top[rot[1, burner_drill_top[rot[2
burner_drill_top[rot[3, burner_drill_top[rot[4, chest_double_back_hi, chest_double_back_lo, chest_double_front_hi, chest_double_front_lo
chest_double_top_1_hi, chest_double_top_1_lo, chest_double_top_2_hi, chest_double_top_2_lo, chest_top[rot[1, chest_top[rot[2
chest_top[rot[3, chest_top[rot[4, crop_harvester_top[rot[1, crop_harvester_top[rot[2, crop_harvester_top[rot[3, crop_harvester_top[rot[4
crusher_top[rot[1, crusher_top[rot[2, crusher_top[rot[3, crusher_top[rot[4, crystal_vat_top[rot[1, crystal_vat_top[rot[2
crystal_vat_top[rot[3, crystal_vat_top[rot[4, darkstone, darkstone_bricks, darkstone_bricks_cracked, darkstone_bricks_lava
darkstone_engraved, darkstone_smooth, deep_drill_top[rot[1, deep_drill_top[rot[2, deep_drill_top[rot[3, deep_drill_top[rot[4
electric_drill_top[rot[1, electric_drill_top[rot[2, electric_drill_top[rot[3, electric_drill_top[rot[4, forge_hopper_top, ghost_chest_top
iron_chest_top[rot[1, iron_chest_top[rot[2, iron_chest_top[rot[3, iron_chest_top[rot[4, moonstone_chest_top[rot[1, moonstone_chest_top[rot[2
moonstone_chest_top[rot[3, moonstone_chest_top[rot[4, press_top[rot[1, press_top[rot[2, press_top[rot[3, press_top[rot[4
pure_copper_ore, pure_voltite_ore, recycler_top[rot[1, recycler_top[rot[2, recycler_top[rot[3, recycler_top[rot[4
shatter_mill_top[rot[1, shatter_mill_top[rot[2, shatter_mill_top[rot[3, shatter_mill_top[rot[4, sky_tap_top[rot[1, sky_tap_top[rot[2
sky_tap_top[rot[3, sky_tap_top[rot[4, smelter_top[rot[1, smelter_top[rot[2, smelter_top[rot[3, smelter_top[rot[4
tree_cutter_top[rot[1, tree_cutter_top[rot[2, tree_cutter_top[rot[3, tree_cutter_top[rot[4, wire_mill_top[rot[1, wire_mill_top[rot[2
wire_mill_top[rot[3, wire_mill_top[rot[4
- 79 removed (sjr0p7):
alloy_kiln_top_rot1, alloy_kiln_top_rot2, alloy_kiln_top_rot3, alloy_kiln_top_rot4, auto_bench_top_rot1, auto_bench_top_rot2
auto_bench_top_rot3, auto_bench_top_rot4, belt_tunnel_exit_top_rot1, belt_tunnel_exit_top_rot2, belt_tunnel_exit_top_rot3, belt_tunnel_exit_top_rot4
belt_tunnel_top_rot1, belt_tunnel_top_rot2, belt_tunnel_top_rot3, belt_tunnel_top_rot4, burner_drill_top_rot1, burner_drill_top_rot2
burner_drill_top_rot3, burner_drill_top_rot4, chest_top_1, chest_top_2, crop_harvester_top_rot1, crop_harvester_top_rot2
crop_harvester_top_rot3, crop_harvester_top_rot4, crusher_top_rot1, crusher_top_rot2, crusher_top_rot3, crusher_top_rot4
crystal_vat_top_rot1, crystal_vat_top_rot2, crystal_vat_top_rot3, crystal_vat_top_rot4, deep_drill_top_rot1, deep_drill_top_rot2
deep_drill_top_rot3, deep_drill_top_rot4, electric_drill_top_rot1, electric_drill_top_rot2, electric_drill_top_rot3, electric_drill_top_rot4
ghost_chest_top_1, ghost_chest_top_2, iron_chest_top_1, iron_chest_top_2, moonstone_chest_top_1, moonstone_chest_top_2
press_top_rot1, press_top_rot2, press_top_rot3, press_top_rot4, recycler_top_rot1, recycler_top_rot2
recycler_top_rot3, recycler_top_rot4, shaft_hopper_top, shatter_mill_top_rot1, shatter_mill_top_rot2, shatter_mill_top_rot3
shatter_mill_top_rot4, sky_tap_top_rot1, sky_tap_top_rot2, sky_tap_top_rot3, sky_tap_top_rot4, smelter_top_rot1
smelter_top_rot2, smelter_top_rot3, smelter_top_rot4, sun_panel_side, sun_panel_top, tree_cutter_top_rot1
tree_cutter_top_rot2, tree_cutter_top_rot3, tree_cutter_top_rot4, wire_mill_top_rot1, wire_mill_top_rot2, wire_mill_top_rot3
wire_mill_top_rot4