Vitrail Shaders

Added

• A pack's three dimensional lookup table is served whatever it holds. Some packs ship a block of numbers rather than a picture, a table their shaders read in three directions: an atmosphere sampled by height, by sun angle and by view angle, a noise field a cloud is carved out of. The engine laid out the small ones and turned away any table written in full precision numbers, and it read no pack file over eight megabytes at all, a limit meant for shader text. It also read such a table only where the shader asked for it in the plainest of the two ways GLSL offers, and a program that asked the other way was turned away with its table sitting ready in memory. A pack hitting any of the three lost every program that read the table: on iterationT that was every pass it draws the overworld with bar a handful, which left the bare picture on screen with none of its sky, its clouds or its water put in. Such a table is now read to the length its own declaration announces, however long the file is, at the precision the pack wrote it, and through either way of asking.

  Where a card cannot blend between two of those values, Apple's among them, the table is read at its nearest entry instead and the log says so.

• A pack's geometry stage is drawn. Some packs put a third shader between the two the engine builds every draw from, and use it to work something out per triangle rather than per corner: how coarse the texture on a block face is, whether a sky quad is the moon or the sun. The engine bound the first and the last and nothing in between, so the last one asked for values nobody had written and the whole program was turned away: on iterationT that took the terrain and the moon out of the picture entirely. Those programs now draw.

  It needs a card that can run such a shader, which the desktop cards do and Apple's do not. On a card without one, a geometry stage that only passes each corner of a triangle on is folded into the shader after it, which is what iterationT's terrain stage does, so its ground is drawn on a Mac too. That stage also works out how fine a block's texture is from the whole triangle, and the folded shader works the same size out for each pixel instead. Any other geometry stage is named in the log on such a card, and the world keeps the game's own shader for that program rather than drawing it with its middle missing: iterationT's sun and moon stay with the game on a Mac, its stage telling the moon from the sun by a measure of the whole quad that no single pixel can see.

• A pack may now blend one of a pass's targets differently from the others. A shader pack can ask for a blend function per target rather than one for the whole program, and the engine read those lines and then dropped them the moment two targets of one pass disagreed, putting the program's plain function on all of them. Each line now lands on the target it names, which is what decides the shape of anything drawn over something else: an overlay that should multiply, a surface that should add, a second target written straight through while the first blends. The shadow map is in, the same as anywhere else.

  With it, PER_BUFFER_BLENDING is served, so that name alone no longer turns a pack away. It needs a driver that lets the targets of one pass differ; where there is none the name is refused as before and the whole-program function stands, which is the ground Iris refuses it on too.

• Temporal Fold, a new setting on the engine page. A world drawn at a lower render scale loses the thin things first, and those are what crawls as you move. The upscale cannot put them back, because it only sees one frame. This blends each frame with the ones before it, matching every pixel to where it stood a frame ago, so detail one frame missed can come from the frames before it.

  It is off until you turn it on, and the checkbox is greyed out at a render scale of 100 percent, where there is nothing to rebuild. It costs two more passes and three more images, about 40 MiB of them at 1920x1080. Things that move on their own can leave a faint trail, because the match is worked out from the camera and not from what each object did.

• Shadow Reuse, a new setting on the engine page. Filling the shadow map means walking the whole world a second time, for the sun, and it is the most expensive thing the frame does. Between two frames of a player standing still nothing in that map moves, so it is now kept and reused instead of drawn again, and the passes that sample it are handed the matrices of the map they actually have. Measured on a Mac mini M4 with Complementary Reimagined at its defaults, in a savanna beside a village, in a window of 854x480 with a shadow distance of 32: 116 frames a second with the map drawn every frame, 133 with it kept. Those figures belong to that window and that distance, not to every setup: on flat ground with little to draw into the map, putting the kept map back can cost more than drawing it, and turning the setting off is then the faster choice.

  It does nothing on a pack that voxelises into its shadow pass, which Complementary Unbound and Photon do with their coloured lighting on. A pack whose shadow programs fill a volume the rest of the frame reads has to fill it every frame, so the engine refuses the reuse there and says so once in the log. That is decided from the shadow programs as the pack's settings leave them, so what is left is every pack that does not voxelise, and the same packs with coloured lighting off.

  What is kept is the ground alone. Everything that moves, a mob, a boat, your own shadow, is drawn into the kept map afresh on every frame, so none of it is ever late. The price is on the ground itself: a block you place or break casts the shadow it had for as many frames as the setting keeps. One frame is what it ships at, and the slider goes to two and stops there. Turning it off restores the previous behaviour exactly.

• A pack that ships no final program now draws. Some packs end their chain on their last composite and expect what it wrote to be the picture; they were refused outright, with nothing on screen. What the chain leaves in colortex0 is now brought to the screen, which is what Iris does with the same packs. I Like Vanilla and Pegasus were both refused for it, and both now load.

  Neither loaded in a released version, so nothing else they needed was ever visible either. I Like Vanilla reads the screen under one of the game's texture names, which the entry on those names covers, and on a Mac its water declares the values it hands on through a shorthand of its own, now read like the full spelling, where one of them would otherwise take the place of the next and Apple's graphics refuse it. Pegasus defines one of its settings twice under two values, which refused every program of it; where the two cannot be told apart the later one now stands, as a driver takes it, and where a use sits between them the pack is left exactly as it wrote it. Its terrain, its water, its entities and its particles needed two things more. It builds its texture reads out of shorthands of its own, and the name texture inside them was left as written while the engine renamed it everywhere else, so those passes read a name nothing declared; the shorthands are renamed with the rest now. And it compares settings against numbers with a decimal point, "if the falloff equals 1" with the setting at 1.0, and those lines were read as whole numbers and then refused. They are now reduced the way a driver reduces them.

• Compute passes are announced as a capability. They have been running for a while, so a pack that says it cannot draw without them was being refused for something it would have got. Clarity and Noble now load.

  More stood between those two packs and their picture, and none of it was ever visible in a released version, since neither pack loaded at all. Clarity spells the matrix that places a texture under a plain name rather than the old fixed function one, and nothing here answered that spelling, so every corner of the sun and of the moon was handed the same texture coordinate and both came out flat; it also lost two compute programs to a setting compared against a number with a decimal point, the same reading the Pegasus paragraph above describes. Noble names, in the shader itself, the format of the image that shader writes to, and that word was being dropped as the declaration was moved to where this backend wants it, so the pass never built and nothing wrote its screen space reflections.

  Noble keeps what each surface is made of as whole numbers packed out of its colours. Apple's graphics store and read those numbers wrong, so on a Mac they are packed and read back by plain arithmetic the engine writes into the shader, and the game's own picture is no longer copied into a target holding such numbers, which a Mac refuses outright. On any machine, whatever the game still draws in the pack's place, a mob the pack has no program for among it, is missing from the targets its terrain and its water write rather than painted in flat, and the log says which.

• The pack is told what you are holding. A shader recognises an item by the number the pack gives it in its own table, and nothing was looking your hands up in that table, so whatever you carried the pack was told you carried nothing it knew. What that drives on most packs is the light in your hand, which now follows the item the pack's table names. Both hands are read. The block you are aiming at and the mount you are riding go through tables of the same kind and are read with them.

• A pack that says it cannot be drawn without the translucent entity program now loads. RenderPearl names that capability in its own file, the engine did not count the name among the ones it serves, and the pack was turned away before any of its programs was read, with nothing of it on screen. The capability itself was already there: a blending entity draw asks for the pack's gbuffers_entities_translucent and a blending block entity for its gbuffers_block_translucent, each falling back on the opaque file of its own family where the pack ships neither. The name is now served, and announced as a define beside the others so that a pack testing for it reads the truth. RenderPearl, which names compute shaders as well, now loads.

  Much more stood between RenderPearl and its picture, and none of it was visible in a released version, since the pack never loaded. It computes in sixteen and eight bit numbers: the line enabling those types is kept instead of dropped, the card is asked for that arithmetic wherever it reports it, a colour output declared under one of those types is declared under its ordinary width, and the values the pack passes between its two stages in a block of its own are passed one by one, at the cost of the packing it had chosen. Its shared vertex header narrows the block a vertex stage writes its position through, which the language allows only ahead of any use of that block, and pasting the headers in moved that line past one, so every vertex stage of the pack was refused; the line is dropped now and the full block stands. It asks whether the card has an AMD instruction, which the shader compiler answered yes on every card and which takes the driver down on a GeForce, and now gets the card's own answer. It tests its own transparency and keeps a light level where a transparency usually sits, so the engine's own test is now written only into programs that fill their first buffer the old way, which is where the reference writes it; otherwise it would throw away every leaf, every blade of grass and the item in hand. On a Mac, the pack is told which steps of a program the card lets share values between neighbouring pixels, the one placing the terrain not among them, and what it includes is decided on the compiler's own answer, so its water, particles and translucent blocks and mobs are lit by the pack there too. Its picture is painted with compute shaders, which the entry of that name below covers.

• A pack that paints its picture with compute shaders draws it. A few packs do their whole post-processing in compute programs rather than in full screen passes, and store the finished frame into a colour buffer of their own. The engine only ever opened a colour buffer for what a drawing program painted into or read from, so the buffer such a pack hands the screen was never opened at all and the program holding the picture was dropped on every frame. Those buffers are opened now, on the strength of the program that writes them. RenderPearl paints its picture that way.

  Two more things stood between that pack and its picture. It ships two of its lookup tables as plain blocks of numbers rather than pictures, and the engine read a block of numbers only where it was a three dimensional table, so the program reading them found nothing under the name and was dropped; those are read now. And where the engine has to compare shadow depths in arithmetic rather than on the sampler, it only knew the two plainest ways a shader asks for the comparison, so a pack asking any other way did not compile at all: it now knows the forms that carry an offset as well, the offset being how a pack samples the neighbourhood of a texel for a soft edge, and it is carried through rather than dropped.

• A compute a pack ships for a step of the chain that draws nothing now runs. It was left out on the grounds that there was no pass to run it before; it is now dispatched on its own, at the moment the program it hangs off would have run at, which is what Iris does with it: its family says whether that falls before the world, before its translucents or after them, and its name says where it lands among the passes drawn there. A pack reaches that state by shipping the compute and no drawing program for the step, or by shipping one and switching it off itself, its switch never naming the compute file. A pack may go further and build every one of its worlds out of such computes with no full screen pass at all, and such a pack is drawn now as well: RenderPearl is written that way. Noble computes the sun's illuminance and the sky's coefficients in one, and everything that lights its world reads what that leaves behind.

• A pack that calls the screen by one of the game's texture names draws its picture. In a full screen pass, OptiFine leaves the first colour target as the default texture, so a pack may read the scene under a name that means something else in the world pass, tex and texture among them. Those names read nothing here, so every pass of such a chain worked on black and what reached the screen was black. They now read the screen, in the compute passes of those stages as well, and a pack that lays a picture of its own over the first colour target has that picture read instead, as it does under the reference. The log names them once per pass. I Like Vanilla reads its screen that way throughout.

• A pack asking for a coarser copy of its shadow map gets one. A shader pack can ask for the shadow map to be kept at several sizes at once, each half the one above it, and then read the size it wants: a soft, wide shadow is worked out from a small copy in one read where a sharp one needs many. The engine kept one size, and a shader asking for any other was silently handed the full one, so the estimate that decides how soft a shadow edge should be was made from the wrong picture. The copies are now made, once at the end of the pass that draws the map, and a shader that names the size it wants gets that size, unless it reads through the hardware comparison, which always reads the full map.

  One pack of those at hand asks: iterationT, on the first of the map's two images, for the width of its soft shadows. A pack that says nothing keeps one size and pays for nothing. A shader that leaves the size to be worked out for it, rather than naming one, still reads the full map: that is a separate limitation of this engine and it is unchanged. The same request on the shadow's colour buffer stays ignored, and that is the reference's own behaviour rather than an omission: it makes that copy and then reads the buffer through a setting that can never reach it.

  A card that will not copy between two sizes of a depth image, which the reference's own graphics interface always allowed and this one does not require, keeps a single size and says so in the log.

• A pack asking for a hard shadow edge gets one. A shader pack can say that its shadow map is to be read without smoothing, and the engine listed those lines among the pack's settings and then bound the map smoothed anyway. They are read now, on the full screen passes, the world's own programs and the compute passes alike, so one map is read one way across a whole frame.

  A pack that says nothing is unchanged, its map staying smoothed, which is where both engines start. One pack of those at hand does say something: Pegasus, which loads for the first time in this version, asks for its shadow map to be read without smoothing and gets it. The same request on the shadow's colour buffer stays ignored, as it is by the engine packs are tuned against.

Changed

• The compiled shaders kept on disk are two to three times smaller. Every one of them carried a copy of the whole shader text and a marker in front of nearly every instruction, which is what a driver would need to name a line inside a shader and which nothing else reads. What is stored is what is read back at every load, so there is less of everything to read, check and hand to the driver. A compile error still names its line exactly as before.

• A pack read twice in one session is opened once. Reading a pack means mounting its archive, walking it for the settings it offers, parsing what it declares and pasting every shared header into every file that includes one, and all of that was done again from nothing each time: at a world join, at a portal, and every time you apply a setting. The engine now keeps the archive it opened and serves the next reading from it where the pack, its settings, its profile and the values the engine defines for it are all as they were and its files carry the sizes and dates they had. A setting you changed, or a world that moves those values, still has the pack read afresh. Only that reading is spared: the pack's textures, its translation and its compiles go as they did before. A file edited on disk changes its size or its date, so a pack you are editing is still read as you left it.

• Reloading resources no longer rebuilds the pack. Pressing F3 and T, or anything else that reloads the game's resources, threw away every program the pack had compiled and built them all again, with the world held back while it happened. A pack's programs come out of its own archive, which a resource reload does not touch, so the ones being drawn with are kept across it now and the reload costs the pack nothing. Programs left over from a pack that has been replaced are still freed there, which is the one thing that ever frees them.

• Joining a world builds the pack once instead of twice. The pack is read while the client starts up, before any world has arrived, and joining one makes it read again against what that world brings. That second reading used to come after the first had already built the whole chain, so everything was compiled and then thrown away; the question of whether the world moved is asked before the building starts now. Leaving a world and joining another paid the same bill in a different order, reallocating everything for the first frame and then again for the reading, and it does not any more. Nothing about the picture changes.

• The pack screen names itself at the bottom left. Vitrail and its version sit in grey in the corner, where Iris puts its own name on its screen, with the engine's news on the line under them when there is any, so a player with both mods installed can tell which screen is open.

• An empty pack folder offers both stores. The pack screen with no pack in its folder had one button, to CurseForge's shader search. It has two now, CurseForge and Modrinth, each asking before it opens the page, since Vitrail is on both and a player finds packs where they found the mod.

• The pack list is in the order Iris shows it. A few packs colour their name with a formatting code at the start of the file name, and the list sorted on the name as written, so those came after the packs named in plain letters. The codes are left out of the sort now, as Iris does, and two names that differ only in case keep Iris's order too.

• On OpenGL, Vitrail offers to switch to Vulkan. Vitrail draws nothing on OpenGL, yet its pack screen and its settings page still opened there, so a pack picked or a setting moved changed nothing you could see. Its page in the video settings and NeoForge's Config button now open a screen saying Vitrail cannot run on OpenGL, with a button that sets the game to Vulkan and closes it, and one that goes back. Its settings page is no longer listed there, its keys and its lines on the F3 screen do nothing and show nothing, and the game's own Graphics API setting is where it always was. Beside Iris it is the same offer, the way Iris's own page offers OpenGL on Vulkan.

Fixed

• Iris and Vitrail installed together no longer close the game on OpenGL. Both mods reshape Sodium's texture filtering option, and Sodium refuses two of them, so a game set to OpenGL with both installed closed before the title screen. Past it, joining a world with some packs closed the game again, Reverie among them, because Vitrail still ran parts of its frame inside Iris's; it now runs none of its frame on a backend it does not draw on. Vitrail now only touches that option where it draws the world itself and Iris does not, and where Iris draws it no longer puts a red line in the chat saying the picture is missing, nor answers Iris's reload key, which is also its own, with a red line of its own. After a startup that ended badly, the backend is kept as it was set rather than put back to Vulkan while Iris is installed, since Iris has already chosen its side for that backend. Where Iris draws, Vitrail's key for the pack screen leaves the press to Iris's own, which sits on the same I, so the I opens Iris's screen alone. On Vulkan, where Vitrail draws, that I opens Vitrail's screen and not Iris's offer to switch to OpenGL over it.

• Reverie draws on a Mac. Two of its passes read more textures at once than the sixteen a Mac takes when a pass is handed its textures one by one, which is how the game hands them over, so Apple's graphics card refused those passes and the pack could not draw there. On a Mac whose card takes textures as one table, which every Apple Silicon Mac does, a pass reading more than sixteen is now handed them that way. Every other pass, and every pass on any other machine, is handed its textures as before.

• A graphics card lost in the middle of a session now closes the game on the error that lost it. When the card stopped answering, the engine caught the error at whichever step of the frame met it first, switched the pack or one of its parts off and went on drawing against a card that was gone, until a later step crashed the game on a report about something else. That error now goes straight through, so the crash report opens on the lost device itself.

• A pack the graphics card will not build no longer closes the game. When the card refused one of a pack's programs while the pack was being prepared, which Apple's hardware does with a program reading more textures at once than it has slots for or naming something the way Metal names its own, the error went all the way up and the game closed on a crash report: on a Mac that was BSL, Bliss, Reverie and Photon on 0.10.0-beta, which all draw there now through the entries on them. A pack the card still refuses is put away instead and the world is drawn by the game, the way it is for a pack refused when it loads, and the settings screen says an error stopped it.

• Three more programs the graphics card will not build no longer close the game. The render scale's upscale, a pack's particle program rebuilt for particles another mod draws in a format of its own, and the game's entity programs rebuilt when a pack starts drawing the entities or the hand were all built in the middle of a frame with nothing to catch a refusal, so a card that refused one closed the game. The render scale now falls back to a plain stretch, and turns itself off when nothing builds; that other mod's particles are drawn through the pack's program as it stands; and the entities and the hand go back to the game for the rest of the session. The log says which.

• Water no longer goes missing on a Mac. The engine keeps one drawing pass open across the world's geometry when it can, and the hand wrote its own data to the graphics card inside that pass right after the water had been drawn in it, which Vulkan does not allow; on a Mac that write cost the water already drawn. The pass is now closed before any such write, unless something is still drawing into it.

• Banners no longer flicker with light stripes on a Mac. On Apple Silicon a banner could show fine light stripes coming and going across its colour, seen on the banners of a village with the camera moving. A banner is drawn twice at the same place, the cloth and then its colour over it, by two different programs of the pack, and the Mac's shader compiler was free to round each program's arithmetic its own way, so the colour could land a hair behind the cloth and be hidden by it. Every vertex program of a pack now asks for its position to come out identical wherever two programs compute it with the same code.

• The world stops being shaded twice, and the sides and undersides of blocks come back to the brightness the pack drew them at. The game tints a block face by which of the six directions it faces, out of a small table each dimension carries: in the overworld full strength on top, half underneath and two values between on the sides, which is what gives an unshaded world its relief. A pack works its own lighting out of the direction each surface faces, so that tint left underneath darkened everything the pack had already shaded, each face by its own fixed amount and an underside by half. It showed most where a pack lights a surface the game leaves dark, the plainest of those being a canopy seen from below. A pack that wants the old behaviour writes oldLighting=true, which the engine reads now.

• A pack no longer brings the game down on a Mac over a name it chose. Apple hardware has no driver of its own for the interface this engine draws through, so a translation layer rewrites every shader into Metal's language, which is C++, and it carries over the names a pack gave its own functions and variables. A pack that had named something bias, length_squared or new then collided with words that language already owns, and Apple's compiler refused the whole pass: the game came down while it warmed the pack's pipelines up, on one it could not compile. BSL, Bliss and Photon all came down on a name of their own on 0.10.0-beta. The engine now drops the names of everything outside a shader never asks for, which is where a pack names its own working parts, and BSL draws. The names of what a pack exposes stay, its uniforms and its textures, because the engine binds those by name; none of the packs tried collides there. Bliss and Photon also needed the entry below, and draw with it.

• A pack that declares more textures than a pass reads draws on a Mac. Apple offers one pass sixteen slots for the textures it reads, and numbers them off the whole list of textures the engine hands that pass rather than off the ones its shaders touch. A pack usually declares every texture it owns in one file all its programs include, so a pass reading thirteen of them was handed a list of forty-eight and given slot numbers running past the sixteenth: Apple's compiler refused it and the game came down while it warmed the pack's pipelines up, on a pass wanting three fewer slots than the hardware has. The engine now numbers a pass off the textures its two shader stages read between them, which is the count that has to fit, so the numbering is dense and anything under sixteen gets in. Bliss and Photon draw.

  Reverie has two passes whose stages read seventeen and eighteen textures between them, more than sixteen slots hold however they are numbered, and those two are handed their textures as one table instead, as the entry on Reverie says. Everywhere else this is invisible: the same textures are bound as before and the same ones are read, and what changes is only which of them the pass is given a numbered slot for.

  Photon also works out the light its sky casts in a small step that runs on many threads of the graphics card at once, and those threads share more working memory than Apple's graphics allow, which leaves the step unbuilt and the sky lighting nothing. On a Mac, such a step now keeps those numbers in an ordinary buffer when it runs as one batch of threads, which is how Photon runs it, and works out the same light. A step past the allowance that runs as several batches is still refused, and the log says so. Every other card is left as it was.

• A shadow read through the hardware comparison names the level it reads. Where a pack asks the card to compare shadow depths for it, which is how most of them read the map, the engine left the level of detail to the card, and a card works that out from how the reading coordinate moves between neighbouring pixels. Inside a loop or a branch, where the pixels beside one another may not be doing the same thing, that answer is undefined, and a ceiling on the sampler is no guard: the same ceiling on the other kinds of read was measured not to hold. Those reads already named their level for exactly that reason, and these did not, though they are the reads a pack makes most, the four tap shadow filter of both Complementary packs among them. They name it now, and what they name is always the full map: a read through the comparison never reaches a smaller copy, even where a shader asks for it, which none of the packs at hand does.

• Smoke, flame and the other solid particles take the colour the pack meant them to. The game draws its quad particles in two goes, the solid ones with the world and the see-through ones after the water, and only the second lot were reaching the pack's own image. The first lot were painted into the game's picture instead and carried in from there, already finished, so a pack that lights its particles itself was handed a colour somebody else had already lit: under Photon a campfire's smoke came out a warm haze where it should be dark, and any pack asking for more than one target had everything past the first written nowhere. They are now drawn into the targets the pack asked for, as the rest of the world is.

  Packs that had this half handed back to the game altogether get it too: a pack whose particle program writes a target the world's own picture is not painted into was refused for a road it no longer travels.

• Water that reads the picture behind it draws its fog and its reflections. Some packs sample one of their own colour targets from the water, the translucent blocks or the particles while drawing into that same target, for the colour of the world behind the surface and for what it reflects; that is what OpenGL hands them, the target as it stands. This engine answered the read with one black pixel, and Sildur's Vibrant Shaders drew its lakes a flat saturated blue with nothing mirrored in them. The read is now served a copy of the target taken just ahead of the pass, which holds the world the pass wants to see behind itself, at the cost of two image copies a frame per such target.

• A pack that declares its own output where another of its branches wrote the old-style one draws those passes. Iteration keeps every one of its final passes in one file, one writing the old-style output and the others declaring their own under the same number, and only one branch is ever taken. The engine counted the branch nobody took, laid its own output on that number, and six of the pack's passes were refused for two outputs on one slot. The pack's own declaration takes the slot now.

• An effect a pack carries from one frame to the next no longer alternates between two images while the view moves. The two halves of such a target were exchanged at the end of the frame instead of one being copied over the other, which is the same thing only where the frame wrote the whole target. Where it wrote part of it, or where the pass that writes it did not run, the pack was handed one image on one frame and the previous one on the next. It is steady standing still and shows as the view moves, so it reads as lighting that slides.

• A geometry program drawn before the water sees the world's depth. The terrain, the mobs, the opaque particles and the held item are drawn before the frame takes its copy of the opaque world, and those programs were handed the far plane where a pack asked for that copy, so a shader that softens or fogs itself against the scene from one of them saw nothing in front of it. They now read the copy as it stands, which at that point of the frame is the frame before's, exactly what the reference hands them; the live depth stays out of reach there, being the very image those programs draw into. Photon reads that copy from its opaque particles and its glowing eyes, and Pegasus and E-LITE from their terrain, mobs, hand and particles.

• A greyscale picture a pack ships is read as the pack wrote it. Every grey image came out lighter than the file, its darks lifted towards white, because the decoder converted the picture out of its own colour space instead of taking the bytes as they were written. A pack that compares such a picture against a number wrote that number for the picture it made, so the comparison landed somewhere else: on MakeUp UltraFast the sky carried a solid white cover where the pack draws a few clouds. The clouds are clouds again, and every grey lookup table, mask and noise field a pack ships now holds the values it was authored with.

• A pack that sizes a compute step through one of its own settings is no longer run at full size. Those steps say how much of the screen they cover, and a pack may say it with the name of a setting rather than with a number. The name meant nothing to the engine, which then ran the step over the whole screen. On Reverie the clouds were marched at four times the width and four times the height the pack asks for, sixteen times the work for the same picture. Those names are now read at the value the settings give them, so the step covers what the pack asked for and that march is a sixteenth of what it was; what it gives back in frame rate was not measured. Where a name stands for nothing the engine can read, the step still covers the whole screen and the log says which word it could not read.

• The world is no longer painted over by the stage meant to run before it. Some packs open the frame with a "prepare" stage, whose job is to fill a table the rest of the frame reads. It ran once the world was already drawn instead of ahead of it, so on a pack whose prepare fills the very image its terrain, its sky or its hand draws into, that table replaced all of them. On MakeUp UltraFast and on E-LITE the ground vanished behind a pale field, the held item was not there and the sky stopped being the brightest thing on screen. The stage now runs at the head of the frame, where the world lands over it, and the begin stage that opens it runs ahead of the shadow map rather than behind it.

• Switching packs no longer leaves graphics memory behind on packs that use compute shaders. A pack can attach a compute program to a step of its chain, and those programs kept their pipelines and their buffers when the pack was replaced, so every switch and every press of the Reload Shaders key added to what was never given back until the game closed. Photon builds its sky lighting in such a compute, so every switch away from it left one behind.

• The off hand no longer answers for the main one on a pack that asked it not to. A pack says whether the brighter of your two hands is what the main one reports, which is how it worked before the off hand had a light of its own, and that was being done whatever the pack said. Seven of the eleven packs tested ask for it to stop: on those, a torch in the off hand was being reported in both hands at once, so the pack lit the scene from the empty one beside it as well.

• E-LITE's clouds follow the hour of the day. A pack may declare a value of its own under either of two keywords, and only one of them was reaching the shaders. E-LITE writes the hour of the day under the other one and its sky reads it, so it arrived as nought: the count of days was all the clock the cloud cover had left, and it changed in day-sized steps instead of drifting through the day. Either keyword now reaches a program that asks for the name, which is what Iris does with the same pack.

• The log stops calling a value missing from this engine when nothing supplies it anywhere. A pack often reads a name no shader engine has ever answered: one left behind by the pack it grew out of, one belonging to a mod that is not installed, or one it simply misspelt. Those were being listed as values this engine still owes, which sends whoever reads the log looking for something that was never written. They are now named for what they are, and a pack gets the same nought under Iris.

• A pack's quality profile is named instead of reading "Custom". A profile can list a setting the pack does not actually have, and one such name was enough to stop the profile from ever being recognised: the shader screen and the F3 overlay both fell back to "Custom" on a pack nobody had touched, and the profile buttons could never land on a name. Photon is the pack this showed on, where all four of its profiles now read as themselves.

• A pack reloaded while you play no longer comes back with the world drawn in one colour. On Photon with its coloured lighting on, most reloads left the world with no red and no blue in it for about half a minute, and then it put itself right. A pack of that kind keeps its light in volumes it fills a little at a time rather than writing whole, and it was handed those volumes still holding whatever had been in that memory, so its first frames spread that instead of light. They are now emptied once, when they are made, up to a fixed amount of memory for all the volumes made at the same moment; past it they are left as they come, a precaution kept since emptying at that moment once coincided with the display driver going down. Photon at its two largest settings for those volumes goes past it, and there a reload can still bring the one-colour world back.

• RedHat's shadows, and E-LITE's entities and hand. Two separate names a pack may write that this engine either had no answer for or answered twice, each of which cost the passes that read them: the picture kept the game's own shader there and the pack's effect was missing on those surfaces alone.