What Vixen offers

Guide

• Agents and actions

  One action surface for three planners, per-agent state as a byte range, and a governor that decides who thinks this frame.

• Authoring a behaviour tree

  The .vxbt document, the editor over it, and what each gesture means to the tree that runs.

• Behaviour trees

  An event-driven tree that is not walked every frame — composites, tasks, decorators and services over one flat compiled template.

• The blackboard

  An agent's data as a compiled key table — six types, byte ranges, per-key versions and observers.

• The AI debugger

  One keyed overlay over all three planners, breakpoints on nodes, a diagnosis read out of the recorded log alone, and the one channel that crosses a wire.

• Declaring agent actions

  How a project says what its agents can do so that a host which never ran the game — the editor's play mode, a headless harness, a plugin — can still build the registry an AiSystem takes.

• Environment queries

  Generators, tests with three purposes, and the utility scorer with points substituted for actions.

• GOAP

  World keys, conditions and effects, the bounded backwards search, and why only the head of a plan is ever committed.

• Perception

  The five senses, what an agent remembers about them, and the three bounds that keep a village of them inside a frame.

• Sensors

  How the world reaches a blackboard — four kinds, and the difference between one query and a thousand.

• Utility

  Considerations, the six response curves, the weighted geometric mean with its zero rule, the four selectors, and the inertia that stops an agent flapping.

• Nodes over the world

  The behaviour-tree nodes that walk, turn, patrol, animate and make noise — and what each of them needs on the entity.

• Move sets

  A movement vocabulary as a flat table, and picking from it with a scored query instead of a graph.

• Pose constraints

  Telling a pose where to be — four goal kinds, resolvable frames, proxy shapes, and one authored contact that fits any body.

• Replicating a pose

  Registering the networked-animation passes, and where the list of joints that go on the wire comes from.

• The variation harness

  Playing one interaction across a range of bodies, props and ground, measuring it five ways, and failing a build when it regresses.

• Getting content into a running game

  What a build has to know, what it ships, and the two shapes a shipped chunk comes in.

• Importing textures

  Which image formats the pipeline reads, what each decoder decides, and the two settings that are not cosmetic.

• Collections the BCL does not have

  The eight structures in Vixen.Core.Collections, the one frame-loop property each of them buys that List and Dictionary cannot, and which of the two identity types to reach for.

• Fuzzing a format that has a grammar

  How a fuzz target says that bytes are the wrong thing to mutate, what a domain replaces havoc with, and what each of the structured targets asserts beyond "it did not crash".

• Gamut mapping

  Bringing a colour into what a display can actually show, by reducing chroma at constant lightness and hue rather than clipping channels.

• Job priorities

  The job scheduler's two tiers — frame work, and work that would rather be late than make a frame late.

• Recording a CPU trace

  The profiler is compiled into every build and switched off; one flag turns it on and a second writes the run out as a file that opens in Perfetto.

• Symbols

  An interned name in four bytes, hashed rather than numbered, so two machines agree on it.

• Triangle tree

  A bounding-volume hierarchy over a triangle soup, for the two questions a bake asks it — what is nearest, and what does this ray hit.

• Component defaults

  Saying what a freshly added component holds, for the types whose zero is not a usable start.

• Components

  The data an entity has, and what makes a type one.

• Entity queries

  Iterating the entities that have a given set of components.

• Structural change during iteration

  Creating, destroying, adding and removing while a loop is walking the chunks — recorded into a command buffer and played back where nothing is iterating.

• Reading a frame's order without running it

  The order a set of systems will run in, worked out from their types alone — and the ordering attributes that turn out to do nothing.

• Booleans and handoff

  Non-destructive union, subtract and intersect whose operands stay editable — and what turns a block-out into an asset.

• Collections in the project browser

  A named set of assets kept with the project — why it holds ids rather than paths, and why it lives under ProjectSettings while a saved filter lives beside your keymap.

• The editing pipeline

  One path every edit in the editor takes, so undo, multi-object editing and mixed values are answered once rather than per panel.

• Editor scripts

  A .cs file in your project's Editor/ folder is compiled by the running editor and loaded like a plugin — drop it in, and its menu item is there.

• Element selection

  Vertex, edge and face modes over one mesh — what a click takes, what a loop walks, and what survives an edit.

• Edits made outside the editor

  What happens when a file the editor has open is changed by something else, and why the editor's own saves do not count.

• Face materials

  Per-face materials, UV projection, smoothing groups and the block-out checker the viewport draws by default.

• Foliage mode

  The mode that requires nothing — six tools, a palette, surface filters, and instance selection through the transform gizmo.

• The frame panel

  Editing a .vxcompositor as the Standard Frame's knobs, with the resolved quality waterfall and the per-camera volume stack shown beside them, and Explode as the one-way door out.

• Graph diagnostics that name a node

  How a complaint about a line of generated shader source becomes a complaint about a node the author can select, across sub-graph inlining.

• Icons

  Declaring what a type looks like with SVG path data, and the parser that made the attribute buildable.

• The editor shell

  The window the editor is made of, and the command registry every part of it is a view over.

• Inspectors in markup

  Writing a custom inspector as a .vxml file with no code-behind, bound to the editing pipeline by name after the tree is built.

• Baking a material

  How a texture graph's outputs become files the engine already understands — the nine usages and the seven files they land in, the ORM packing, PNG or KTX2, the .vxmat, the GUID dance, and the provenance block that stops a painted-over map being regenerated.

• Editable meshes in a scene

  How an entity comes to carry an editable mesh, how it is saved, and how an edit is undone.

• Mesh maps as project assets

  The bake panel a mesh-map bake is set up in, what the nine files are called, how a set is keyed on the model it came from, and how a generator finds one by usage rather than by path.

• Editor modes

  What the viewport's input means right now, and how a mode claims keys that already mean something else.

• The network panel

  Where a session's bandwidth is going, how the link is behaving over time, and what is inside one snapshot — an editor panel over the BandwidthLedger, SnapshotInspector, RoundTripEstimator and transport loss counters a game already has.

• Editing a node's ports

  The editing pipeline's second IEditProvider — a graph node's inline port values and its string-valued settings described as inspector members, so the ordinary inspector panel and a .vxml tree edit them by name instead of a hand-written panel per graph.

• What a play session runs

  How a module adds systems to the frame the editor's Play button steps — the `IPlaySystems` contribution, the `PlaySession` that owns their lifetime, and the physics world the editor now stands up on Play and takes away on Stop.

• Building to a number

  The work plane you build in, typing an exact distance mid-drag, the tape measure, and the scale references.

• Prefab overrides

  How a scene records that an entity came from a prefab and which of its members it has changed, and what happens when the prefab changes underneath it.

• Retopology and UV surfaces

  Where a quad remesh and an unwrap are actually invoked from — the model importer, three command-line verbs, and the blockout mode's own verb and UV panel.

• Saved filters in the project browser

  A named search of the project, kept beside the layouts and the keymap — and why it stores the query rather than what the query matched.

• Scene menus

  A pie menu under the cursor and a list beside it, both filled by one registration and filtered by the active mode.

• Showing what is selected

  The corner brackets a viewport draws round a selected object, and why a composed pane cannot say it with colour.

• A material that draws with a shader graph

  A graph emits a material feature rather than a whole shader, which is why the engine's existing draw can put one on a mesh.

• Shader-graph preview thumbnails

  Compiling one node's sub-expression on its own, running it over a quad, and keeping the target alive across edits.

• Procedural and UV nodes in a shader graph

  Noise, a checker and the two UV transforms — each one a call into the shader library rather than a second copy of it, which is also why they have no preview.

• The shape tool

  Making block-out geometry — live parameters, the cube grid, the poly shape, and duplicate, mirror and array.

• Snapping

  What a transform lands on, which part of it lands there, and why that is one service rather than one per tool.

• Computing a sub-graph's port values

  A published graph is inlined rather than called, so what its unfed ports are worth is decided during the walk — this is the seam that lets a front end compute one instead of only reading a number.

• Sub-object picking

  Which face, edge or vertex of one mesh the pointer is on, and why that is a different question from which entity.

• Sculpt and paint mode

  The viewport mode the terrain tools live in — two categories sharing the digits, one drag as one undo entry, and the panel as settings objects rather than dialog code.

• Collision under the sculpt brush

  The adapter that joins the sculpt tools' `ITerrainColliders` seam to `TerrainColliderSystem`, so a stroke rebuilds the Jolt height field it moved — and the one number that says the wiring is wrong.

• Compiling a texture graph

  The compiler that turns a node graph into a texture plan, and the four things it hands back besides the plan — the outputs by usage, the pictures a host still owes it, the parameters an author exposed, and the per-node images a preview draws.

• Evaluating a texture plan

  The plan of compute kernels a texture graph and a layer stack both compile to, the image pool that runs it, and the resolution rule that keeps a graph the same material at every size.

• Generators and the compound library

  How a generator asks for a baked mesh map by what it measures rather than by which file it is, where a shipped compound lives, and why a graph must not name the mesh it is for.

• The texture graph plugin

  The .vxtexgraph document, the panel that edits one, and the module that registers both through the plugin contract — plus the three things a plugin could not do when this module was written, each with the change that closed it.

• Texture-graph node previews

  The swatch under every node of a texture graph — one plan that keeps every node's image, one bake, and pixels handed to the host because a compute queue's images are not the interface's to sample.

• Utility styles

  Styling an editor panel with Tailwind-shaped class names — the build step that compiles them, the one palette they resolve against, and which families the engine actually reads.

• The VFX graph

  The node library a .vxvfx is authored against — spawners, initializers, updaters and outputs — and the compiler that turns one graph into both an effect the CPU runs and a shader a device runs.

• Water mode

  One mode and three verbs — draw a body's curve on the ground, drag its profile handles, and preview what its carve did to the terrain — plus the zone panel that turns a resolution into metres.

• Writing an editor plugin

  What a plugin can contribute to the editor, how it registers, and how everything it added is taken back out when it unloads.

• Attribute transfer

  Carrying a source mesh's normals, coordinates, colours, materials and skinning weights onto the quads a remesh produced — and mirroring them when the remesh was symmetric.

• Binding controls, and rebinding them

  What a control path names, how a composite turns four keys into a vector, and the rebinding operation that listens for a key — built, tested, and not yet wired into any screen.

• Block-out shapes

  Boxes, stairs, arches and the rest, generated from a handful of numbers that stay live afterwards.

• Booting an application

  The three calls behind VixenApp.Run, and the two seams that decide which platform and which device you get.

• Floating things on water

  Pontoons over Jolt, evaluated at the fixed step's water time — a component, a system, and the three orderings that are silent when they are wrong.

• Character movement

  Turning a player's intent into a character that walks, jumps, crouches and slides along walls.

• Declaring a project's frame

  How a project says which systems its frame is made of — the `[GameSystem]` attribute a generator collects, the constructor that names the services a system needs, and what happens to a declared system nobody can supply.

• Editable meshes

  Faces over shared positions, an edge table that reports rather than refuses, and face groups.

• Growing a forest

  The offline ecology — seeds sown, aged, spread, shaded out and displaced — regenerated wholesale from four sliders and a stated seed.

• Foliage instances

  Trees and rocks stored in a cell grid, the six rules that refuse a placement, and the activation radius that decides which of them are worth a physics body.

• Getting started

  The first ten minutes — the one SDK the build needs, where the packages come from while nothing is published to nuget.org, the six templates and which one you want, the two files a new game is, and the one edit that proves the loop is running.

• Grass

  A field scattered from a rule and never saved — the density curve, the hash both halves share, and the ring of buffers that makes it cost a fixed amount of memory.

• Handshake traces

  A span per handshake, so a connection that failed says which step it died at.

• Host logging and vixen.log.yaml

  One filter, several sinks, and a file that turns one subsystem up without a rebuild — plus the two lines in the log that say whether that file was read at all.

• Input actions

  Naming what the player is doing rather than which key they pressed — a .vxinput asset of maps and actions, the one phase it is updated in, and the frame model every polled flag depends on.

• Lag compensation

  Judging a shot against the world the shooter actually saw, and getting the ring filled without anybody remembering to fill it.

• Map baking

  Casting the output's normal at the source to fill an atlas with a normal map, a displacement map and seven more mesh maps, on the CPU, with no device anywhere.

• Measuring packet loss

  What the transport counts about datagrams that did not arrive — four cumulative totals, why the outbound pair is an upper bound and the inbound pair is an observation, how the peer's inbound counters come back over the wire to make it a measurement, and what it costs per packet.

• Mesh booleans

  Union, difference and intersection over solids, classified exactly so that coplanar faces do not open cracks.

• Mesh operations

  Extrude, inset, bevel, loop cut, knife, bridge, weld, dissolve — the modelling verbs, as functions over a mesh.

• Mesh surfaces

  Where a face's texels come from and which normals it shades with — world-space projection and smoothing groups.

• Network rules as a file

  Who may do what to a networked object, written down in a .vxnetrules and named by the prefabs it governs.

• Network sessions

  The layer between a transport, which knows about connections and bytes, and a game, which wants players and ticks — the handshake, the clock, the player list, and why a player is not a connection.

• Networked players

  Giving a connection a body, predicting its movement, and proving the two ends agree.

• Networked prefabs

  What may be spawned, on both ends of the wire — and filling that list from the content build rather than from a start-up path.

• Parent-relative transforms

  Replicating a rider on a moving vehicle, and sending only the axes an object actually uses.

• Players and possession

  A controller that outlives the body it drives, and the one component that carries a player's intent.

• Pose precision

  Spending fewer bits on the bones of a replicated pose that nobody is looking at.

• Quad remeshing

  Triangles in, quads out — a retopologiser whose hard edges are layout boundaries rather than something snapped to, and which tells you how well it did.

• Remesh debug dumps

  Every stage of the remesher as an inspectable artefact — conditioned triangles, the field as a line set, the layout as regions, the quantization as a labelled graph.

• Replicating behaviour state

  SyncVar, SyncList and the sweep that puts a behaviour's changes on the wire without anything having to remember to.

• Retopology settings and reports

  What to ask a quad remesh for, and everything it measured about what it gave back.

• Round trip and jitter

  The RFC 6298 filter every latency number in the engine comes out of — a smoothed round trip, a smoothed deviation beside it, and why the deviation is the one that sizes buffers.

• Smoothing received motion

  Drawing a networked object where it was rather than where the last packet said it is, and who owns the buffer that decides.

• Splines

  A cubic Hermite curve with an arc-length table, the authored asset over it, and its two consumers — roads that deform a terrain and camera dollies that follow a track.

• Swimming

  One number written every fixed step — how much of a character's capsule is under water — and the movement mode that whole feature is made of.

• Terrain brushes

  One brush — a shape, a falloff, a radius in metres and a spacing — answering one question for three different tools.

• Terrain collision

  One Jolt height-field shape per tile, kept in step with the ground, in its own assembly so neither the kernel nor the renderer links the other's dependency.

• The terrain heightfield

  One grid of 16-bit heights over an authored range, a stack of non-destructive edit layers, the paint channels and the hole mask.

• Painting a terrain

  The four paint tools, the layer weights that sum to one, the reusable ground a layer names, and the undo record that has to hold all of them.

• Sculpting a heightfield

  The seven sculpt kernels plus holes and paint, the stroke record that makes a drag undoable, and the ray that turns a pointer into a sample.

• Coming from Unity

  The vocabulary map, and the four places the two models genuinely differ — an entity is a row rather than an object, the frame is an asset rather than a call order, an asset is imported and built rather than loaded, and the interface is a framework rather than a canvas.

• UV charting and seams

  Where to cut a mesh — a distortion-driven recursion whose chart count is an outcome of a quality target, and seams that are walks on the mesh's own edges.

• UV flattening

  A chart in, a flat island out — a three-rung ladder that measures what it cost you four ways and refuses anything it would have to fold.

• UV packing

  Islands in, transforms out — a standalone atlas packer whose margin is counted in texels and whose output does not move between runs.

• UV stacking

  Two symmetric islands sharing one region of texture — detected and offered, never applied on your behalf.

• UV texel density

  Uniform texels per world unit, with a per-material override and a per-chart multiplier — and a measurement that says what the atlas actually got.

• Where the water surface is

  One definition of the water surface — a body from a spline and a profile, a sea state from a spectrum, a field of height, flow and ground, and the evaluator that the renderer, the buoyancy solver and a gameplay query all call.

• Saving and restoring a world

  Writing every entity in a world to bytes, and making the world again from them.

• Leashing and spawn tables

  How far a mob may be pulled before it goes home, and what lives in a camp — the two pieces of doc 28's AI section that did not already have a better home.

• Attributes and the modifier algebra

  One stat type, three modifier buckets, one fixed evaluation order, and removal by source that cannot drift.

• Chat channels, routing and moderation

  Channels authored as definitions and routed by audience, a filter pipeline applied before fan-out with the reason returned to the sender, and an audience seam so chat never learns what a party is.

• Collections, achievements and transmog

  Pets, mounts, appearances, titles and toys as one set of unlocked ids with a source — plus achievements, whose counted half rides the event bus and whose standing half is an ordinary requirement, and a wardrobe whose override falls back to the real item rather than to nothing.

• Abilities and damage

  Abilities over the kernel's effects, and a damage pipeline of six named stages a game inserts rules into rather than replaces.

• Definitions and the content walk

  Authored content addressed by a hash nobody maintains, baked into a catalog, and reloaded live when the change is additive.

• Dynamic events and world bosses

  A quest stage with the scope moved off one player and onto a realm — contribution tiers instead of tap-ownership, monotone scaling, and success and failure both leading somewhere.

• Currencies, vendors, trade, mail and the auction

  Every transaction is one balanced, idempotent intent against a ledger seam; the trade confirm-lock needs a revision doc 28 does not mention, and everything is escrowed when it is offered rather than when it is taken.

• Effects

  Buff, debuff, damage-over-time, stun, aura, shield, stance and mount are one type with a stacking policy.

• Gameplay events

  A verb, a subject and a place, posted by whoever it happened to and filtered by whoever cares — the half of "features meet through tags and events" that tags alone could not carry.

• Player housing

  Plots, furniture, a budget, a snap that the client and the realm both call, and a five-rung permission ladder that a ban beats outright — with no clock anywhere in it, which is what makes ten thousand houses ten thousand rows.

• Dungeons, raids and lockouts

  Difficulty tiers, encounters with gates and checkpoints, and lockouts whose resets are absolute boundaries rather than timers from whenever somebody entered.

• Interactables, gathering and crafting

  One channelled system for mining, looting, reading and pulling levers, with a claim that stops two players finishing the same rock — and recipes over it, whose stations are tag queries.

• Inventory and the container algebra

  One container type with policies, and every mutation a transaction that applies entirely or not at all.

• Items

  A definition and a sixteen-byte instance, with every affix and every stat recomputed from a roll seed rather than stored.

• Authoring a loot table

  An editable model over the definition, a flattened outline for a tree view, and a drop simulator that runs the shipped evaluator.

• Loot tables

  Weighted rows with conditions, pity the engine owns rather than a game's private counter, and a roll reproducible from its event id.

• Gameplay modules

  What a game composes — stats, tags, definition types and systems — declared explicitly, with nothing scanned.

• Mounts and vehicles

  One type with seats — a mount is a single-seat vehicle whose model is a creature. The seat model only; the transform half waits on parent-relative replication.

• Levels, talents and reputation

  Definitions plus one durable record, with a talent allocation validated whole because a client-built talent tree is a client-chosen power level.

• Arenas, battlegrounds and objectives

  Four composable objective types with one signed capture meter, so a contested point is frozen rather than slowly losing, and a new battleground is a map plus a .vxdef.

• The quest and event-chain editor

  An editable model over the definition, and a chain walked into a spanning tree because an event chain is cyclic by design and both of the engine's graph models refuse a cycle.

• Quests, stages and objectives

  A quest is stages, a stage is objectives, and an objective is a subscription with a tag query — so it costs nothing when nothing dies.

• Gameplay randomness

  A reproducible stream seeded per event, so "the log says you rolled a 3" is answerable a year later.

• Requirements

  "Can I do this" answered once, by code the client runs for the tooltip and the realm runs for the truth.

• Weapons and hit claims

  The weapon model and the claim's validation rules — the two things that are new, because the lag compensation underneath is already built.

• Parties, guilds, friends and presence

  Three kinds of group and one implementation, a guild whose permission matrix is a tag query per action, and a block that is one-way as a fact and two-way as a rule.

• Gameplay tags

  One hierarchical, interned tag type, numbered so that "is this under Damage.Fire" is two integer comparisons.

• Maps, discovery and travel

  A revealed-area bitmap per character per map, completion that only counts what a designer opted in, and five ways of getting somewhere that all resolve to one transfer.

• Admission, health and the control plane

  The door a ticketed player comes through, the two-second sample a fleet is watched by, and the one place a realm ever calls an orchestrator.

• Durable state and the ledger

  Accounts, characters and the append-only double-entry journal every movement of value is written to — and the fence that makes one writer one writer.

• The gameplay bridge

  Where doc 28's rules meet doc 27's storage — the third player identity, and four views that answer in the frame and write down afterwards without ever awaiting a grain.

• Matchmaking, queues and ratings

  Open Match's model without its deployment — a ticket is a party so "never split" is a property of the types, and two rating models the queue definition chooses between.

• Placing players

  The megaserver as a function — the hard filters, the score, the explanation, and the hysteresis that decides when a map grows a shard.

• Placing realms

  Starting, watching and stopping realm processes — and the backend that makes a fleet an ordinary unit test.

• Shards, keys and specs

  What a shard is, what makes two of them interchangeable, and the one string a realm process boots from.

• The cluster

  The four grains the orchestrator is made of, the lease that makes item duplication unrepresentable, and why the client cannot reach any of it.

• The live verbs, at three in the morning

  The four `vixen live` subcommands that reach a running cluster — what each one prints, why the operations sit behind an interface, and what has to exist before any of them can connect.

• The service plane

  The gate — sign in, characters, the catalog check, and the one call that turns "I want to play" into an endpoint and a signed ticket.

• Transfer tickets

  A player's signed, expiring permission to be admitted to a shard — and why the client can only carry it.

• Transferring players

  The overlap — a second session opened while the player is still playing on the first, and the lease epoch that makes the switch atomic.

• Upgrading a fleet

  Whether a content update can be applied to a running world — proven by the build rather than asserted by a human — and the rolling upgrade for when it cannot.

• Writing a realm

  A dedicated server that is a shard — the one-line entry point, the four hooks it seals, and the map it opens.

• Compiled artefacts

  The two things the compiler writes — `.rvnfx`, one shader compiled for one target and one permutation, and `.rvnlib`, a library a later compilation binds and links against — what is in each container, and why both carry a version a reader refuses rather than guesses at.

• Compiling a shader

  The four phases a `.rvn` goes through — parse, bind, lower, generate — the handful of types a host touches to drive them, where each phase's diagnostics come from, and why a permutation value or a compose binding makes a separate compilation rather than a flag.

• The target-independent IR

  The model every back end consumes and none of them may look behind — a structured body over SSA values, storage reached only through an access chain, a deliberately small type system, and a verifier that runs before a back end ever sees a module.

• The .rvnlib IR

  The lowered half of a compiled library — how a function body is written down so a later compilation can link it, why every cross-reference travels as a key or an index rather than as an object, and what a body may not contain if it is to travel at all.

• Reading a shader's reflection

  What the compiler can tell a host about a shader it produced — descriptor sets, vertex inputs, fragment outputs, push constants, specialisation constants, permutations and value parameters — plus the std140/std430 layout rules a uniform block's offsets come from.

• The Raven symbol model

  What binding produces — the entity hierarchy a tool asks questions of, why type identity is by reference for the intrinsics and structural for the seven constructed shapes, how generics are read through a substitution rather than instantiated, and why this model is deliberately richer than the IR the back ends see.

• The Raven syntax tree

  What parsing produces — a Roslyn-shaped tree generated from one grammar file, why the node classes are not written by hand, how an edit reparses only the members it touched, and the two traps that come with reuse and with a language whose newline ends a statement.

• Scheduling a frame onto two queues

  What `PassKind` means now that something reads it — how the render graph cuts a frame into per-queue segments, why a resource has to be handed between queues rather than merely barriered, why two queues that only want to read one texture need `ResourceSharing.Concurrent` to stop taking turns, how a submission waits for another queue by value rather than by draining it, and which of this engine's passes came out of the audit able to leave the graphics queue.

• Blend shapes

  Sparse quantised vertex deltas, imported off a mesh's morph targets and applied by a compute pre-pass into a per-instance vertex buffer — or, for a virtualized mesh, gathered per vertex where a page is decoded — so that every pass agrees about where a vertex is, driven by hand, by an imported clip, or by a weight curve typed into a .vxanim.

• Capturing a frame to a file

  A headless run renders on the real GPU with no window and writes its last frame as a PNG, so a sample's picture is a file two people can produce at once rather than a screenshot of whoever's display was in front.

• Choosing a frame

  The two-audience story — start with the Standard Frame's knobs, explode the document when you need surgery, and hand-author only when the frame itself is the subject.

• Refusing a GPU that lies

  The curated list of GPUs and driver versions a backend must not be selected on — why a capability query cannot replace it, how a rule is written and matched, where it is consulted during device creation, and what it deliberately refuses to do.

• Diagnostic overlays and the console

  One flag puts the frame-stats panel, the console, the log tail and every subsystem's debug lines on the screen of a running game.

• Drawing foliage

  Cells culled as objects, instances culled within them, LOD decided per instance, and one indirect command per level.

• The ambient split, and the nodes that fill it

  Why a lit frame is written to four targets with its diffuse ambient deliberately missing, what the screen probes, the surface cache and the traced reflections put into that hole, and the one node at the far end that adds it all back up.

• Drawing grass

  Cells scattered as they come into range and blades culled every frame — the CPU reference of a compute pass, and the seam test that holds the two together.

• Impostors

  A tree photographed from a hemi-octahedral grid of directions once, offline, and drawn as two triangles for ever after.

• Culling and streaming instances

  Per-instance culling and LOD binning inside a batch, per-instance parameters beside the transforms, and a grid that keeps pages resident around whoever is moving.

• Turning on dynamic global illumination

  The four compositor nodes that make a frame's indirect light a file rather than a program.

• LOD groups

  A discrete level-of-detail chain authored as a parent carrying screen-height thresholds and children carrying their level numbers, chosen per view after culling and hidden through the visibility bitset — the LOD story for meshes with no cluster hierarchy, and for the levels a cluster DAG cannot express because they change material.

• The look profile

  One .vxlook asset carrying the project's artistic base — exposure target, meter clamps, grade, fog, lens — folded under every scene's volumes, never baked into the frame.

• Meshes and materials, type by type

  Neither word names a type — each names a chain of them, one per stage, plus four subsystems that borrowed the same word.

• Multisampling

  What a document says to draw a pass at 4× and where the samples go afterwards — the resolve pair, the sample counts that all have to agree, the two textures that are deliberately not interchangeable, and why depth resolves by a named rule rather than by averaging.

• Drawing particles

  Dropping a .vxvfx onto an entity — the component, the importer that compiles the graph, the bridge that runs it, and the feature that draws it.

• Lighting a scene in lux and lumens

  Colour temperature, photometric units, an analytic daylight sky, and the one exposure that brings them back to a display.

• Making a room look different

  A region a level designer places to say how the frame looks inside it, how two of them resolve where they overlap, and the one thing a volume cannot do.

• The post-processing node kinds

  Every screen-space effect a compositor document can name, what each one reads, and the order they have to run in.

• Tracing rays against the scene's own triangles

  The two-level acceleration structure the RHI exposes, the ray query Raven compiles into one intrinsic, and why the hardware tracer is an alternative behind the distance-field interface rather than a lighting mode of its own.

• A pass that reads the frame so far

  Two ways for a pass to consume its own output — a snapshot of a target inside one frame, and a pair of targets alternating across them — and why both are resources the render graph owns rather than barriers somebody remembers.

• Render quality presets

  The quality waterfall behind the Standard Frame's tiers — engine defaults, a project's RenderQuality.vxpreset and per-document overrides, folded per parameter into the numbers the expansion consumes.

• Making everything cast a shadow

  The caster stage, the atlas a shading pass reads it from, and the two joins that make one mesh drawable by two shaders.

• SMAA

  Subpixel morphological antialiasing — three passes that find the whole edge, walk it to both ends and look the coverage up, rather than guessing a direction from one neighbourhood.

• The Standard Frame

  One engine-owned node that expands into the full frame graph — shadows, GI, reflections, the whole post chain — configured by seven semantic knobs.

• Drawing a terrain

  A quadtree with a vertex morph, one instanced grid patch, no vertex buffer, and one draw call however many patches it takes.

• Streaming texture mip tails

  The small mips are always resident and the large ones are pages that come and go under a byte budget, because KTX2 stores level data smallest first.

• Timing the frame on the GPU

  The render graph brackets every pass it runs with a named scope, so a document that adds a node gets a bar in the timeline without anybody opting in — and an optional sink is what keeps that free when nobody is measuring.

• Fog a shadow can fall through

  The froxel volume that turns the frame's fog from a function of distance into something the scene's own light shines through, what its far plane really controls, and why the composite is on the other side of TAA.

• The accessibility tree

  A role, a name, a value, a state and a set of relations on every element, computed from what a control already holds rather than mirrored into it — plus one coalesced per-frame event, so a screen-reader bridge can cache a tree and diff it instead of asking a node at a time.

• Ambient values

  A value provided on an element and found by type from anything inside it — SwiftUI's Environment with the walk written down — so a theme, a selection or a view-model stops being threaded through props by hand.

• Toolbar, status bar and segmented control

  The three application-shaped controls the editor drew out of bare elements and no application could reach — a toolbar that is one tab stop, a status bar that is a live region, and a row of joined buttons that is one question with several answers.

• Loading when a panel appears

  Context.Load is the arrival hook a panel had no way to write — a tracked request, an untracked load, a token cancelled when the region goes, and a fault that arrives as a value markup can draw instead of an exception an effect swallows.

• Background tasks

  Long work that does not freeze the window — a task model with progress, status and cancellation whose properties are signals, a queue that lands every report on one point of the frame, and a manager whose disposal is what stops a cancelled import outliving the application that started it.

• Box alignment

  What an alignment does when what it aligns does not fit — CSS Box Alignment §4.4's safe fallback, across all four of the store's algorithms — and the three legacy text-align keywords, which are the one alignment in this store that names a physical edge.

• Cascade layers

  Vixen's base / components / utilities ladder — why every theme sheet opens with the same @layer statement, what a game's or a plugin's own sheet should do, and why the whole ladder has to live inside one origin.

• Cut, copy and paste

  How a text control reaches the operating system's pasteboard — the seam a Core assembly is allowed to name, the one call a host makes for any of it to work, the four command ids both text controls answer, and why a field with nothing selected deliberately does not consume ⌘C.

• Commands and the focus route

  A menu declares what, and the focus decides who — a command id resolved by walking outwards from the focused element and on past the root to the document and the application, so two views can answer the same verb without knowing each other exists and an item nothing handles greys itself out.

• Compositing groups

  How a translucent subtree is rendered into a surface of its own and blended back once — the offscreen pass behind `opacity`, `filter: blur()`, the seven colour functions, `drop-shadow()` and `mask-image`, why a group is not the same as fading each element, why a colour matrix and a mask cost neither a surface nor a pass where a blur and a drop shadow cost both, why a mask's seam is fixed on both executors where a matrix's is free, why a drop shadow's seam is fixed by arithmetic that does not commute, how a colour matrix with zero coefficients turns a surface into a tinted silhouette, how a list of mask layers is folded into one coverage and what `mask-composite` means for each, when the pass is skipped as an exact identity, what the surfaces cost, how a backdrop filter is a replay of the draw-list prefix rather than a read-back and what that cost the compositor's walk, what gradient text would still need on top of it, how `rotate` and `scale` ride the composite quad's four vertices for the price of no shader at all, and why `mix-blend-mode` is the one group-wide effect that has to read its destination — free on the software rasteriser, and still owed on the device.

• Containment

  CSS Containment 2's `contain` over Vixen's layout store — why size containment is not "skip the children", how the inline-size half differs from the size half, why paint containment is the clip `overflow` already pushes rather than a second one, and why there is no `style` member.

• Cursors

  What `cursor: pointer` does to the pointer — the cascade's answer, the stock shape it maps to, the one call a host has to make for any of it to be visible, and why every test for it is written against the window rather than against the document.

• Running a UI application

  UiApplication.Run(options) is the whole of a Vixen interface's Main — a window, a device and the four steps of a frame — and this is what the options say, when the three events fire relative to the layout, and why the loop redraws every frame instead of when something changed.

• The diagnostics panel

  A control that shows what a running document is doing — the per-frame work counters, whether the last pass was cold, the draw-list rebuild gap, and the element under a probe point with its four boxes — and why it is a control rather than one of the engine's diagnostic overlays.

• Dialogs that answer

  A modal question an application can await — confirm, prompt, choose, or one it fills in itself — queued one at a time, completed from the document's tick rather than from the click that answered it, and answered rather than dropped when the application goes away.

• Docking panels

  DockingHost is splitters, tab groups, tear-off windows and a layout that round-trips through YAML; DockPanel is one panel in it, and the thing most worth knowing about a panel is that it scrolls itself — no ScrollView is involved, and Fills is how a view that must not scroll says so.

• Document diagnostics

  What a debug overlay may read about a running interface — the per-frame work counters, an element's four boxes under the pointer, and the regions that invalidated the last pass — with the three rules that decide the shape: it reads rather than samples, it allocates nothing, and the region recording is compiled out of a build that did not ask for it.

• Documents, dirty state and save

  A document below the editor — dirty, name and location as signals, save and revert answered through the command route by the nearest panel that hosts one, and a window title that follows both.

• Drag and drop

  A file dragged from Finder or Explorer arrives as a routed event at the element it was let go over; a drag that starts inside the application carries a payload offered in several formats, is addressed to the nearest element that allows drops, and negotiates what the drop would do before anything is let go.

• Exit animations

  A row removed from a keyed list can stay in the document long enough to animate away. Written exit="200ms" on the row, where its key already is; the runtime adds a class and holds the elements for the interval stated, the row's bindings die the moment it is let go of, and a key that comes back mid-flight ends the old row rather than standing beside it.

• Floats and clear

  CSS 2.1 §9.5 floats over Vixen's layout store — the exclusion list a formatting context carries, why a flow root moves out from under a float and a plain block does not, how clearance spends a margin instead of adding to one, and the half of the feature that is not implemented.

• Gradients

  The three gradient shapes a box can be filled with, where their stops sit, and which space the colours are interpolated in — including why an unhinted CSS gradient is sRGB, why Tailwind's are Oklab, and why the engine's own programmatic gradients stayed linear.

• Grid layout

  CSS Grid over Vixen's layout store — track sizing functions, minmax and fr, automatic repetitions, item placement and spans, and the one thing grid needed from the store that flexbox and block did not.

• Group box

  GroupBox is the titled box round a set of related controls — HTML's fieldset and legend. Card draws the same picture; what only this one does is tell a screen reader that the controls inside answer one question.

• Inline layout

  Line boxes over Vixen's layout store — inline-block and inline-flex, shrink-to-fit sizing, baseline alignment and vertical-align, and the one invariant an inline formatting context asks the store to give up.

• Key/value lists

  One control for the label-and-value rows a debugger, a memory panel and a settings pane were each drawing by hand — equal halves, alternating shades, and a value slot that takes an editor.

• Labeled content

  LabeledContent is the form row — a caption, the field it names, and the line under it. It writes the LabelledBy and DescribedBy relations for you, which is the part a stylesheet cannot do and the part every hand-built form was missing.

• Panels in markup

  Writing a control in .vxml — @inherits for a class callers can hold and add, ref and refs for the parts they read, change: for the values they edit, and the key rule — for @for and for @if alike — that decides whether a row updates at all.

• Making a project compile markup

  What turns a .vxml on disk into a class — one line outside this repository and one inside it — and the three build errors, VX4001, VX4002 and VX4003, that say which half is missing rather than blaming the markup.

• Media queries and user preferences

  What `@media` can ask about in Vixen — the size, resolution and gamut of the surface a panel is on rather than of the monitor, the colour-scheme preference, and `prefers-reduced-motion`, which is a query and a switch the animator honours because a toolkit whose default is to animate anyway ignores the preference in every application that forgot.

• Pointer devices

  How a handler finds out whether the press it is holding came from a finger, a mouse or a stylus — the field that says so, why its default is `Unknown` rather than `Mouse`, and why the pointer id cannot answer the question.

• Reactive collections

  The two collections that live in the signal graph as one node each — a list whose changes are reported one at a time for the keyed @for reconciler, and a map written in place so a counter arriving every frame costs nothing.

• Secure text input

  SecureTextBox holds what was typed and draws bullets — the field a login screen needs, which this control set did not have. The masking is one seam on TextField, the pre-edit is masked with the value, and there is deliberately no reveal button.

• Writing a shortcut down

  The modifier order, the key-name table and the one process-wide hook that changes how every shortcut in an application reads — none of which needs an element, a document or a font, and all of which used to live on a control.

• Split views

  Two panes and a bar that resizes both — the sidebar-and-detail shape, as a control an application can reach without adopting a docking model. The ratio is a fraction, a drag writes two declarations and rebuilds nothing, and flex-basis is the half that makes the number mean what it says.

• Stepper

  Stepper is a NumericInput with the two arrows on it — the buttons every other toolkit has and this control set did not. They are the field's own Nudge, so a step is proportional to the value; they are not tab stops; and they grey out at the ends of the range.

• Strings and the catalogue

  A label is an id plus the English it was written as, so a missing translation shows the sentence rather than the id — and the catalogue in use is a signal, so a language change re-labels a running interface with no code at any call site.

• Stylesheet diagnostics

  What happens to CSS Vixen cannot read — the at-rules, selectors and @apply names it drops, the build step's two refusal channels, where each refusal is now reported, and why a rule that does nothing used to be indistinguishable from a rule that was never written.

• Text decoration

  Underline, overline and line-through — where the lines come from (the font's own tables, never a constant), what the classes are, and the four places Vixen's behaviour is deliberately not CSS's.

• Text input and the input method

  How typed text reaches a control, why an input method's pre-edit is a different event from typed text and what a field does with it, why the pre-edit is shown but is not the value, where the caret goes while a composition is running, what a platform head has to do for any of it to arrive, and why a caret index alone cannot say where the caret is at a wrap or a change of direction.

• Text transform

  uppercase, lowercase and capitalize — why they are a shaping-time change rather than a keyword table, why .NET's own casing is the wrong tool, and the index map that keeps a caret in the right character.

• Text wrapping

  Where a paragraph's lines end — the three questions CSS's text-wrap shorthand asks at once, why balance is a search rather than an algorithm, and why pretty is only one clause of what the specification licenses.

• Building an interface, end to end

  One panel built in the order the pieces actually go together — the markup file and what it compiles to, a list that is a keyed @for over a reactive collection, a form that is two-way bound and submitted, a verb declared as a command so a menu can run it, and the stylesheet that says what none of it looks like.

• Undo

  A control finds an undo manager on the way up rather than owning one — what the seam is, where a manager is installed, why a run of typing is one entry and not one per keystroke, and why a text field that finds nothing deliberately lets ⌘Z go past it.

• Composed utilities

  How from-*, via-* and to-* build one gradient — utilities that set a --tw-* fragment instead of a declaration, why the cascade assembles them rather than the generator, and the initial value that stops a missing fragment erasing the whole rule.