What works, checked against Unity.

Supported: Awake, OnEnable, Start, FixedUpdate, Update, LateUpdate, OnDisable, OnDestroy, [DefaultExecutionOrder], deferred Destroy, fake null

Supported: yield return null, WaitForSeconds, WaitForFixedUpdate, WaitUntil/While, nested coroutines

Invoke, InvokeRepeating, CancelInvoke and IsInvoking, timed and ordered as Unity runs them (after Update, a frame before an equal WaitForSeconds; private and inherited methods; disabled and inactive owners keep their calls)

Supported: Mathf, Vector2/3/4, Vector2Int/3Int, Quaternion, Matrix4x4, Color, Color32, Rect, Bounds, Random; Unity 6's named colors (Color.aliceBlue and the rest, with Unity's values); RectInt and BoundsInt (with their position enumerators); GeometryUtility (frustum planes from cameras and matrices, TestPlanesAABB, CalculateBounds, TryCreatePlaneFromPolygon)

Unity.Mathematics: every vector and matrix type over bool, int, uint, float, double (and half vectors) with their constructors, conversions, operators, swizzles, indexers, formatting and hashes (math.hash and GetHashCode give Unity's values); the math functions (trigonometry, exponentials, rounding, interpolation, geometry, bit operations, half conversion, mul, transpose, determinant, inverse); quaternion (Euler orders both ways, LookRotation, slerp, exp/log), float3x3/float4x4 constructors (TRS, LookAt, projections), RigidTransform, AffineTransform; Random (the same sequences as Unity's); noise (simplex, classic, periodic, cellular and flow noise). Results match Unity's to float precision

IJob, IJobParallelFor, IJobFor (Run, Schedule, ScheduleParallel), IJobParallelForTransform with TransformAccessArray, JobHandle (Complete, IsCompleted, CombineDependencies), on the engine's job scheduler: batches run in parallel on its worker threads, dependent jobs after their dependencies. Unity's safety system: NativeArray and NativeSlice (with the Temp, TempJob and Persistent allocators, Temp memory freed each frame), [ReadOnly], [WriteOnly], [DeallocateOnJobCompletion], [NativeDisableParallelForRestriction], [NativeSetThreadIndex]; scheduling conflicts, main-thread access before Complete, use after dispose, Temp containers in jobs and reference fields fail with Unity's messages. Transform jobs run on the main thread when scheduled. Burst (BurstCompile, FunctionPointer, SharedStatic) is accepted and compiled code runs as .NET code

NativeList, NativeHashMap, NativeHashSet, NativeParallelHashMap (and its ParallelWriter), NativeParallelHashSet, NativeParallelMultiHashMap, NativeQueue (and ParallelWriter), NativeReference, UnsafeList, NativeKeyValueArrays, sorting and binary search, FixedString32Bytes to FixedString4096Bytes (appending numbers as Unity formats them, comparing, searching, hashing, FixedString.Format). Capacities, hash map iteration orders and errors match Unity's. Not yet: NativeText, NativeStream, FixedList, AsDeferredJobArray before the list is filled, custom allocators

Supported: hierarchy, local and world space, tags, layers, Find, Instantiate (scripts' AnimationCurve, Gradient and UnityEvent fields copied whole; a hierarchy's scripts woken by execution order)

Supported: CreateInstance, Instantiate, Destroy, .asset files, Resources.Load

Legacy Input Manager (keys, mouse buttons, joystick buttons and axes, GetJoystickNames), and the Input System package: Keyboard, Mouse, Gamepad and Joystick, actions with Button/Value/PassThrough behavior, composites, processors, .inputactions assets, PlayerInput; interactions (Hold, Tap, SlowTap, MultiTap, Press with its behaviors, and custom IInputInteraction classes through RegisterInteraction) timed by event timestamps with timeouts, events older than a device's last one dropped as Unity does; projects' own binding composites (InputBindingComposite<T> registered with RegisterBindingComposite: parameters from the binding string, parts by number through InputBindingCompositeContext), the Axis composite as Unity computes it (midpoint, whichSideWins; an action reads 0 while a composite's magnitude is 0), NormalizeProcessor, InputControlAttribute and DisplayStringFormatAttribute; PlayerInputManager (joining by a button on a new device, by the join action or by script, the player limit, joined and left notifications by message, UnityEvent or C# event); DefaultInputActions (its maps, actions, IDs and control schemes as Unity's; the bindings are the engine's, Submit and Cancel by usage as Unity's), which scenes' references to the package's DefaultInputActions asset load, and InputSystemUIInputModule.AssignDefaultActions; control usages as Unity's layouts give them (Submit, Cancel, Back, Modifier, PrimaryAction, Point...; InputControl.usages), named in binding paths as */{Submit}, InputControlPath.Matches and TryFindControl; devices list their controls in Unity's order. Joystick (trigger and stick, as Unity's base layout), TrackedDevice and XRController (pose and tracking state; leftHand and rightHand by device usage), device usages (SetDeviceUsage, AddDeviceUsage, RemoveDeviceUsage, paths like <XRController>{LeftHand}/devicePosition), CommonUsages, Vector3Control and QuaternionControl. Connected controllers are read (gilrs: XInput and Windows.Gaming.Input, evdev, IOKit): one with a known layout is a Gamepad (sticks through Unity's default dead zone), others Joysticks (raw axes and buttons), added and removed as they come and go; legacy Input numbers an XInput pad's buttons and axes as Unity does on Windows, and a new project's joystick axes and buttons are in the default axes. MCP's play_step drives a virtual gamepad and reports its motors. Gamepad rumble (SetMotorSpeeds, Pause/Resume/ResetHaptics) drives XInput, Windows.Gaming.Input and evdev pads; DualSense and DualSense Edge pads are read and driven over HID (USB or Bluetooth) as Unity's DualSenseGamepadHID: PlayStation names, touchpad, PS and mute buttons, rumble, SetLightBarColor; not yet the DualShock 4, adaptive triggers or touchpad touches. Headsets, touch, interactive rebinding and split-screen cameras aren't yet

Supported: LoadScene and LoadSceneAsync (Single and Additive), build settings, sceneLoaded/sceneUnloaded, DontDestroyOnLoad

Supported: Load, LoadAll, LoadAsync (ResourceRequest: completes on a later frame, models stream on a background thread, reading asset early loads it), for models, textures, audio, fonts, text, animation clips and controllers, prefabs, materials, ScriptableObjects and project shaders (in Unity projects too; a model file loads as its prefab). Imported models and decoded images are cooked into a cache (rkyv, memory-mapped) and load from it next time

Supported (JsonUtility writes JSON byte for byte as Unity does, with serialization callbacks)

Supported: field values and references are kept, ScriptableObjects too; statics reset and coroutines stop

Time: deltaTime, time and fixed steps, timeScale, captureDeltaTime and captureFramerate (frames advance by a fixed amount), timeSinceLevelLoad, fixedUnscaledTime, smoothDeltaTime, maximumDeltaTime. Screen: width and height, SetResolution, fullScreen and fullScreenMode (exclusive, borderless, maximized, windowed; applied to the window at the end of the frame), currentResolution and resolutions from the display, orientation, autorotation, sleepTimeout and brightness as Unity reports them on the desktop. Not yet: Display, mainWindowPosition and MoveMainWindowTo, safe areas other than the whole screen

UnityEngine.LowLevel.PlayerLoop: GetDefaultPlayerLoop gives Unity 6000.3's default loop (phases and systems in Unity's order), GetCurrentPlayerLoop and SetPlayerLoop; systems scripts insert with an updateDelegate run at their place in the frame (before or after the phase's script callbacks), from the frame after SetPlayerLoop, as in Unity (UniTask's loop works this way). [RuntimeInitializeOnLoadMethod] in Unity's phase order (SubsystemRegistration to AfterSceneLoad) around the first scene load

UnityWebRequest (Get, Post, Put, Delete, Head, custom verbs and handlers) over HTTP(S) and file:// URLs, completing at the start of a frame as Unity's do: result, error, responseCode, headers, DownloadHandlerBuffer, DownloadHandlerTexture, DownloadHandlerFile, UploadHandlerRaw, WWWForm (url-encoded and multipart), EscapeURL and form serialization as Unity formats them; UnityWebRequestTexture. Not yet: certificate validation overrides, DownloadHandlerAudioClip, asset bundles, progress during a transfer

Gizmos (players draw nothing, as in Unity), Cursor.visible and lockState (locked or confined to the window), ContextMenu and the Scripting attributes (Preserve and the like), the JetBrains.Annotations attributes Unity's module exports, RuntimePlatform and SystemLanguage with all of Unity's values. Handheld as on a desktop player (Vibrate, movies and the activity indicator do nothing). Unity Analytics' legacy API (Analytics, AnalyticsSessionInfo) as a player with analytics turned off: nothing is sent and events report AnalyticsDisabled. Unity Ads (Unity 5's built-in API and com.unity.ads 3.x and 4.x) as the SDK behaves on a desktop: not supported, never ready, loads and shows fail with NOT_INITIALIZED. SystemInfo as a desktop reports itself (operating system, processor and memory from the system; no battery, gyroscope or vibration; the graphics values describe Tassix's renderer in general terms), and UnityEngine.Device's Application, Screen and SystemInfo (the device simulator's mirrors, the same values here). UnityEngine.Assertions compiled away as in a release player (scripts build without UNITY_ASSERTIONS; AssertionException's message as Unity's); the Profiler, Sampler, CustomSampler, Recorder and ProfilerMarker APIs as a player without the profiler (samples do nothing); HelpURL; Application.isBatchMode (true headless), HasProLicense (false, as players report); StaticBatchingUtility (Tassix batches on its own, so combining changes nothing); MonoBehaviour.useGUILayout; Object.DestroyObject; SerializeReference (the attribute; managed references' values aren't loaded yet); Camera.Render and ScreenCapture warn that they aren't supported.

OnGUI after LateUpdate with Unity's passes (each input event after a Layout, then Layout and Repaint), drawn over the canvases, ordered by GUI.depth: GUI's labels, boxes, buttons and repeat buttons, toggles, toolbars and selection grids, text fields, text areas and password fields, sliders and scrollbars, DrawTexture (with its scale modes) and DrawTextureWithTexCoords, groups, clips, scroll views and windows (DragWindow), named controls and focus, GUI.color, backgroundColor, contentColor, enabled, changed and matrix; GUILayout's automatic layout (areas, horizontal and vertical groups, flexible space, width and height options, scroll views, windows); GUIStyle (CalcSize, CalcHeight, Draw, states, padding, alignment, word wrap) and GUISkin; GUIUtility (control IDs, hot and keyboard control, coordinate conversion, ScaleAroundPivot, RotateAroundPivot). The built-in skin draws flat boxes rather than Unity's textured ones. Not yet: text selection and caret drawing in text fields, windows drawn above the rest of OnGUI, modal windows

Rigidbody, Box/Sphere/Capsule/Mesh colliders, triggers and collisions, raycasts, layer collision matrix with colliders' and rigidbodies' includeLayers and excludeLayers (decided as Unity does, by layerOverridePriority in conflicts), PhysicMaterialCombine for projects from before Unity 6, CharacterController, Hinge/Fixed/Spring/Configurable/Character joints; every query form: SphereCast/BoxCast/CapsuleCast and their All and NonAlloc variants (initial overlaps report distance 0 and no point, as in Unity), OverlapBox/OverlapCapsule NonAlloc, Physics.ClosestPoint and ComputePenetration at given poses, Collider and Rigidbody ClosestPointOnBounds, Rigidbody.SweepTest and SweepTestAll (a body's own colliders aren't hit), and Physics.IgnoreCollision between pairs of colliders

WheelCollider, Tassix's own wheel model (Unity's is PhysX's vehicle code, not available here), checked against a car recorded in Unity: a ray down the suspension finds the ground; the spring carries each wheel's sprung mass at its target position (Unity's sprung masses: the body's mass shared out to balance about its center of mass) and pushes by its distance from it, with damping; the tire grips by its forward and sideways slips through the friction curves (independently), times its load; the wheel spins by motor and brake torque, the tire's pull and wheelDampingRate. At rest, in the air (spin-up and damping) and in the sprung masses it matches Unity closely; accelerating within 5%, braking within 15%, turning within 25%. GetWorldPose, GetGroundHit, rpm, isGrounded, steerAngle, forceAppPointDistance; wheels have no shape and don't collide. Not yet: WheelHit.force and slips as Unity reports them (Unity's force is about two thirds of the load; its slips come from its vehicle substeps), suspensionExpansionLimited, ConfigureVehicleSubsteps (wheels always take four substeps)

TerrainData's heightmap as Unity keeps it (16-bit heights, resolution, size, scale, bounds, GetHeight(s)/SetHeights, interpolated heights, normals and steepness), Terrain.SampleHeight, activeTerrain(s) and CreateTerrainGameObject. Not yet: drawing terrains, TerrainCollider shapes, terrains in Unity scenes, splat maps, trees and details

Rigidbody2D, Box/Circle/Capsule/Polygon/Edge colliders, TilemapCollider2D (each cell's grid square or sprite rectangle), raycasts and overlaps, Hinge/Distance/Spring/Fixed/Slider/Wheel/Target joints; collider-to-collider queries: Collider2D/Rigidbody2D Distance (negative when overlapped, measured from the contact manifold as Unity does) and Physics2D.Distance, ClosestPoint, Cast (each body collider's hits, siblings ignored), Overlap and Physics2D.OverlapCollider, GetContacts in every form (contact normals and filters as in the collision callbacks), CanContact, GetRayIntersectionNonAlloc. PlatformEffector2D one-way platforms (surface arc, rotational offset, collider mask: an effector's collider ignores other layers entirely); force effectors acting on the bodies touching them after each step (recorded): AreaEffector2D (angle, global or local, magnitude, damping, rigidbody or collider target), PointEffector2D (constant, inverse linear and inverse squared forces, distance scale, sources and targets, damping), SurfaceEffector2D (speed by force scale, friction and bounce off), BuoyancyEffector2D (submerged area and centroid of boxes, circles, capsules and polygons, damping, flow). CompositeCollider2D: the colliders on its Rigidbody2D marked usedByComposite (boxes, circles, capsules, polygons, tilemaps) merge into one outline (Outlines: closed edge loops bodies slide along across tile seams; Polygons: filled, holes open), regenerated when members change or by GenerateGeometry, with GetPath, pathCount and GetCompositedColliders; contacts and queries report the composite (recorded). Composite operations (recorded): members combine in composite order, the first as it is, then Merge, Intersect, Difference and Flip. offsetDistance (recorded): the result grows by it, shrinks by twice it and grows again with square corners (negative: shrinks first), closing gaps narrower than twice it and cutting corners. Not yet: the rotation a buoyancy flow gives a partly submerged body (more than Unity's), Rigidbody2D.Slide, shapes (GetShapes, PhysicsShapeGroup2D)

Baking with Recast as Unity bakes (voxels a third of the agent radius, 256-voxel tiles anchored at the surface, erosion by the radius, step height and slope, small regions dropped, areas): the AI Navigation package's NavMeshSurface (all objects, a volume, its children or only marked ones; render meshes or physics colliders; NavMeshModifier area overrides and exclusions) and NavMeshBuilder (CollectSources, BuildNavMeshData, UpdateNavMeshData). NavMesh queries: CalculatePath (straightened corners, partial paths), SamplePosition, Raycast, FindClosestEdge, CalculateTriangulation, areas and their costs, agent type settings, Add/RemoveNavMeshData. Paths and query results match Unity's to the voxel in the conformance scenes; a few eroded corners can differ by one voxel. Unity scenes' NavMeshSurfaces import and bake again from the scene when they start (Unity's baked data is in its own tile format)

Walks the path's corners as Unity's agents do: acceleration, speed, auto-braking to a stop at the end (from twice its radius out), turning faster the faster it goes up to its angular speed, a few corners of lookahead (remainingDistance is Infinity beyond them); SetDestination (the path comes in the next update, pathPending until then); off-mesh links as Unity's agents take them (near the link's start it gets on; with autoTraverseOffMeshLink it steps onto the start and moves to the end in half the time walking would take, then carries on more slowly; otherwise it waits for CompleteOffMeshLink; isOnOffMeshLink, current/nextOffMeshLinkData; one agent per link, NavMeshLink.occupied); isStopped, ResetPath, Warp, Move, SetPath, CalculatePath, updatePosition/Rotation, nextPosition, velocity, desiredVelocity, steeringTarget, areaMask. Agents update after Update, before LateUpdate. Avoidance: agents steer around each other and NavMeshObstacles (as circles) by sampling velocities (more samples at higher obstacleAvoidanceType quality), passing on opposite sides, and overlapping agents are pushed apart; an agent ignores less important ones (higher avoidancePriority), and NoObstacleAvoidance agents neither avoid nor get pushed; idle agents step aside. Off-mesh links: NavMeshLink and NavMesh.AddLink/RemoveLink (one-way or both ways, cost modifier or the area's cost) join navmesh points; paths take them when they're shorter or the only way, with corners at both ends. Not yet: avoiding navmesh walls in the velocity choice (moves stay on the navmesh), box obstacles as boxes (they avoid the box's circle), Unity's walkers nudging idle agents aside on contact, link widths (links join their two points), auto-generated drop-down and jump links, ActivateCurrentOffMeshLink and deactivated links, NavMeshObstacle carving, NavMeshModifierVolume, height meshes, Unity's legacy (pre-package) baked navmesh

Camera (perspective, orthographic, clear flags), MeshRenderer and MeshFilter (Mesh.colors multiply the color under the sprite, UI and particle shaders that take vertex colors; lit shaders ignore them, as Unity's do), SpriteRenderer; lit by the brightest directional light (hard or soft shadows, fitted to each camera, with strength and bias; renderers' cast/receive/shadows-only settings), up to eight point and spot lights, and the active scene's RenderSettings: skybox, trilight or flat ambient, and linear, exponential or squared fog (sprite and UI shaders skip it); Standard, URP Lit and glTF materials shade physically based (metallic, smoothness, emission, a GGX highlight like URP's) with normal, metallic (Unity's R/A or glTF's B/G channels), occlusion and emission maps behind Unity's keywords, legacy diffuse ones Lambert; tangents are computed per mesh. A camera's Skybox component draws its own material's sky behind it (lighting and reflections keep the scene's). Skyboxes: Skybox/Procedural (our own sky model with Unity's parameters and sun disk), Skybox/Panoramic (latitude-longitude), Skybox/6 Sided and Skybox/Cubemap draw behind cameras that clear to the skybox, and in the skybox ambient mode give the ambient light. Reflections: PBR surfaces reflect the sky, or the reflection probe holding their center (the most important, then the smallest), from cubemaps captured at 128 pixels a face and blurred for roughness; probes have box projection, intensity, a solid-color or sky background, and realtime (on awake, every frame, via scripting), baked (captured once) and custom (a Cubemap) modes. Cubemap (script-built, half-float on the GPU) and cube-shaped texture import (2:1 panoramas, 6:1 strips, crosses; PNG, JPEG and Radiance .hdr). Opaque instances are culled on the GPU per view (frustum, and two-phase occlusion against depth pyramids) into indirect draws, on devices with compute shaders (TASSIX_GPU_CULLING=0 turns it off). On devices with texture binding arrays, materials are bindless: surfaces read their textures by slot from one array, so draws split by mesh and pipeline only (TASSIX_BINDLESS=0 turns it off). Cameras' culling masks hide layers. MaterialPropertyBlock (every value kind, colors kept linear as Unity stores them) on renderers, for all materials or one material index: the renderer draws an override of its material, which follows changes to the material, and the material itself is unchanged. LODGroup: per camera, the first level whose screen-relative height (the group's world size at its distance over the view's height, distance divided by QualitySettings.lodBias; QualitySettings.maximumLODLevel caps detail) is reached draws, the others don't, and past the last level none does; ForceLOD, a disabled group drawing every level, the default three levels, SetLODs, RecalculateBounds, and LODGroups in Unity scenes and prefabs. Unity 6 mesh LODs: MeshLodUtility.GenerateMeshLods builds levels in place (quadric simplification keeping borders and seams, about half the triangles each), Mesh.lodCount and GetLod (MeshLodRange), and each MeshRenderer draws the coarsest level whose error stays under QualitySettings.meshLodThreshold on screen (meshLodSelectionBias, forceMeshLod). Not yet: LOD cross-fading (levels switch outright), mesh LODs from model import settings, per-camera mesh LOD choice (the first camera decides), OpenEXR, Unity's baked probe data, probe blending and time slicing, culling masks in captures, lightmaps and baked GI, detail maps, height maps, point and spot light shadows, post-processing. Projects' own shaders (.shader files, found by Shader.Find and materials): their vertex and fragment programs (CGPROGRAM and HLSLPROGRAM, against Tassix's own UnityCG, UnityUI and URP core includes) compile through DXC and naga when a material first draws with them, once per keyword set (multi_compile and shader_feature, from the material's keywords), and are kept in the asset cache (until the shader or a file it includes changes), and draw meshes, sprites and UI graphics (with their second and third UV sets) with the material's properties (packed as Unity packs them, colors linear, textures' _ST and _TexelSize, Shader.SetGlobal* values for what the material doesn't set), ShaderLab's render state (Blend, ZWrite, ZTest, Cull, ColorMask, fixed or from properties, inherited through SubShaders and Category), the queue tag, Unity's built-ins (object and camera matrices, _Time, _ScreenParams, _ProjectionParams, _ZBufferParams, the main light, ambient light, fog) and their forward passes in order; lit shaders get the main light with its shadows, the point and spot lights and the ambient light, as Tassix's own shading has them, through Tassix's Lighting.cginc, UnityLightingCommon.cginc and AutoLight.cginc (the shadow and attenuation macros, ShadeSH9 is the scene's trilight ambient, Shade4PointLights and unity_4LightPos* the first four point lights) and URP's Lighting.hlsl family and SurfaceInput.hlsl (GetMainLight with shadow coordinates, GetAdditionalLight and its count, the light loop macros, SampleSH, InputData and SurfaceData, UniversalFragmentPBR with a GGX highlight, UniversalFragmentBlinnPhong; _MAIN_LIGHT_SHADOWS and _ADDITIONAL_LIGHTS are on, as the pipeline turns them on); _CameraSortingLayerTexture, _CameraOpaqueTexture and _GrabTexture are the scene behind the UI (captured before the overlay canvases draw, as small as the URP 2D renderer's downsampling says); a GrabPass's texture (named or _GrabTexture) is the scene drawn before the first transparent item that reads it; compile errors are warnings and the material draws unlit. Shader Graphs (.shadergraph, Shader Graph 10 and later) are project shaders named "Shader Graphs/<file>": translated to HLSL for their URP Unlit, Lit or Fullscreen target, with their properties, keywords, render state, sub-graphs (dropdowns, Branch On Input Connection), custom function nodes (file or string) and about eighty node types. Not yet: Shader Graphs older than 10, the Sprite and Decal targets, gradient and noise nodes, surface shaders, fixed-function passes, UsePass, lighting passes beyond the first forward one, shadow casters, project shaders on particles, the sorting layer bound of the camera sorting layer texture (it holds the whole scene), point and spot lights' shadows and cookies, the built-in pipeline's ForwardAdd passes (lights beyond the main one reach built-in shaders only through Shade4PointLights), GrabPasses of opaque items (they see the last capture), fog in project shaders, reflections in UniversalFragmentPBR, texture defaults other than white. Render textures: cameras with a targetTexture draw into it before the screen's cameras (in depth order, with the texture's aspect and the background's alpha; opaque surfaces write alpha 1 as Unity's do), Graphics.Blit into one (scale and offset, every channel; with a project shader's material, its pass or every pass draws over the texture with the source as _MainTex, as a quad from 0 to 1 through an orthographic camera or as Blit.hlsl's full-screen triangle; built-in shaders' materials copy the source and say so); image effects: OnRenderImage on screen cameras without a scriptable pipeline, in component order, its blits (and temporaries) run on the camera's image under later cameras and the overlay UI (not yet on cameras with a target texture, nor blits into the script's own render textures), Graphics.CopyTexture on the GPU with a render texture on either side, .renderTexture assets, and materials, sprites and RawImages sample them; settings and temporaries as Unity's (recorded). Not yet: post-processing and GPU culling in render texture cameras, reading render textures back (ReadPixels, AsyncGPUReadback of render textures). AsyncGPUReadback of Texture2Ds works. Immediate drawing: GL (lines, triangles, quads in pixel, ortho or camera matrices, shaded as the SetPass material's shader takes its texture, color and vertex colors), Graphics.DrawMesh, DrawMeshInstanced, DrawMeshNow and DrawTexture (upright in y-down pixel matrices, as Unity's), over the frame or into RenderTexture.active / SetRenderTarget's texture (in order with blits and copies; GL.Clear clears it); without a scriptable pipeline, Camera.onPreCull/onPreRender/onPostRender and OnPreCull, OnPreRender, OnPostRender and OnRenderObject messages. Shader globals (Shader.SetGlobal*/GetGlobal*), Mesh's eight UV channels, tangents, List and range overloads, quad, line and point index buffers (lines and points don't draw yet), Texture.graphicsFormat. Not yet: SetRenderTarget into render textures, Texture2D.ReadPixels (they warn)

AudioSource and AudioClip (WAV, Ogg Vorbis, MP3, FLAC), 3D spatial blend, AudioClip.Create; AudioMixer from .mixer assets: groups (FindMatchingGroups by path), exposed parameters (SetFloat, GetFloat, ClearFloat), snapshots and transitions, AudioSource.outputAudioMixerGroup applying the groups' volume and pitch. Not yet: mixer effects other than volume and pitch, sends, ducking

Projects with com.unity.visualscripting compile: Variables (object, scene, application and saved scopes), CustomEvent.Trigger, ScriptMachine and StateMachine components, its attributes. Graphs don't run (their machines warn once)

Grid (cell size and gap, rectangle, isometric and hexagon layouts, swizzles, cell and world conversions) and Tilemap: tiles set, read, filled (BoxFill, FloodFill, SetTilesBlock), swapped and cleared, per-cell color, transform, flags (locking color and transform) and collider type, bounds (grown, compressed), tilemapTileChanged and tilemapPositionsChanged, tiles' GameObjects, animated tiles; Tile and scripted TileBase subclasses (GetTileData, GetTileAnimationData, RefreshTile, StartUp); TilemapRenderer drawing every cell's sprite in its sort order; tilemaps saved in scenes. Not yet: chunk culling, CompositeCollider2D merging the tiles' shapes, sprite physics shapes (cells use the sprite's rectangle)

TextMesh, laid out as Unity's (checked against its bounds in the conformance suite): font size (0 for the font's own) and characterSize, the nine anchors, alignment of lines within the text's box, lineSpacing, tabs at tabSize spaces, rich text (color, size, italic), offsetZ; adding one brings a MeshRenderer with the font's material (GUI/Text Shader), and the renderer's bounds are the text's box; it imports from Unity scenes and prefabs, with fonts and their materials from .ttf/.otf assets. Renderer.localBounds on every renderer. TextMeshPro's legacy TextContainer (its size and pivot are the RectTransform's). Not yet: Unity's built-in font itself (LegacyRuntime is Liberation Sans here, so text in it measures differently), bold from an installed bold face

uGUI layout: RectTransform, Canvas (screen space sized to the screen, world space), CanvasScaler, Horizontal/Vertical/Grid layout groups, LayoutElement, ContentSizeFitter, AspectRatioFitter, CanvasGroup; Image (simple, sliced, tiled, filled) and RawImage, drawn by overlay and world-space canvases, with Shadow and Outline effects; legacy Text (rich text, wrapping, best fit, the built-in font; Font.CreateDynamicFontFromOSFont finds installed fonts by family name, localized names included, and GetOSInstalledFontNames and GetPathsToOSFonts list them) and TextMeshPro (TextMeshProUGUI and 3D TextMeshPro: rich text, wrapping, alignment, auto sizing, textInfo), drawn as bitmap glyphs; UI text whose material (or outlineWidth/outlineColor) asks for an outline, face dilation, softness or an underlay (UNDERLAY_ON: color, offset, dilate, softness) draws from a signed distance field atlas instead, with those effects (ShaderUtilities IDs, Material int-ID properties). UI events: EventSystem with StandaloneInputModule or the Input System's InputSystemUIInputModule (mouse, keyboard navigation, submit and cancel), GraphicRaycaster, PhysicsRaycaster, Physics2DRaycaster, every pointer, drag, scroll and selection handler, ExecuteEvents, EventTrigger; Selectable (color tint, sprite swap, animation transitions, navigation), Button, Toggle, ToggleGroup, Slider, ScrollRect (clamped, elastic, unrestricted, inertia, scrollbars, auto-hide), Scrollbar, RectMask2D (clipping, culling, raycast filtering), Mask (clips to its rect rather than its graphic's shape); InputField and TMP_InputField (typing, selection, word and line moves, copy/cut/paste, content types and validation, character limit, passwords, multi-line, submit/cancel, caret and selection drawing), Dropdown and TMP_Dropdown (list, blocker, picking), DefaultControls and TMP_DefaultControls; TextMesh Pro's helpers for its sample scripts: TMP_TextUtilities (the character, word, line or link under a point, hashes, hex), TMPro_EventManager (TEXT_CHANGED_EVENT on each layout), TMP_MeshInfo.SwapVertexData and SortGeometry, TMPro_ExtensionMethods, TMP_Math; text input from the keyboard (Input.inputString, Keyboard.onTextInput, IMGUI Event queue); UnityEvent persistent calls set in the inspector. Projects made with TextMeshPro before 3.2 (its package version, else Unity before 2023.2) get its first UVs as Vector2s (TMP_MeshInfo.uvs0, TMP_Vertex.uv), as their scripts expect; later ones Vector4s. Not yet: two projects of different TextMeshPro versions in one process (the editor keeps the first one's and warns), <link> tags, TMP glow, bevel and textures on faces and outlines, SDF effects on 3D TextMeshPro, sprites in text, IME composition, touch input and the on-screen keyboard, Button/Toggle/Slider

UIDocument and PanelSettings (scale modes, theme, sorting order); UXML (elements, attributes, inline style, Style, Template and Instance) and USS (type, name, class and pseudo-state selectors, combinators, specificity, variables, inheritance, shorthands, images and fonts by url() and resource()), imported from .uxml, .uss and .tss files; VisualElement's tree, classes, queries, inline and resolved styles, layout and coordinates; flexbox layout as Yoga lays it out (pixel-grid rounding, percentage padding against the parent's border box); events (pointer, mouse, wheel, click, capture, change, geometry, attach/detach, focus) with trickle-down and bubble-up; manipulators and Clickable; TextElement, Label, Button, Image, Toggle, Box, ScrollView, TabView; drawing over the canvases (backgrounds, borders, images, text, clipping) and mouse input with hover. unity-theme://default is Tassix's own theme with the control metrics of Unity's. Data binding (Unity.Properties paths and property bags, DataBinding in every mode, converter groups, hierarchical data sources, CustomBinding); ListView (selection, refresh, item templates; virtualized: a pool of the items in view bound as it scrolls, fixed and dynamic heights, ScrollToItem) and DropdownField with its menu; TextField (caret, selection, typing and editing keys, copy and paste, password masking, max length, delayed values), Slider, SliderInt and Scroller, ScrollView's scrollers; IntegerField, LongField, FloatField, DoubleField, UnsignedIntegerField and UnsignedLongField (format strings, numbers and expressions as Unity reads them, dragging deltas, label draggers); Vector2/3/4Field, Vector2/3IntField, RectField, RectIntField, BoundsField and BoundsIntField; keyboard events to the focused element, Tab focus order, navigation events (buttons and toggles submit); rounded corners and borders; transform styles (translate, rotate, scale, transform-origin) in drawing, picking, world bounds and coordinate changes; transitions (duration, delay, timing functions, their run, start, end and cancel events). TreeView (rows with indents and a foldout toggle, expanding and collapsing, ids, selection by id, adding and removing items); Foldout (content shown with its value, depth classes; the theme's arrow drawn as a triangle). ListView editing (view controllers: adding, moving, removing and clearing items with their events; the add/remove footer; the foldout header with the collection's size; reorderable items, animated with drag handles). Dragging to reorder as Unity's (recorded): canStartDrag on the press, the drag starting past 10 pixels; simple lists call setupDragAndDrop and show its title by the pointer, animated ones lift the item out (a placeholder keeps its place, the item below makes room) to follow the pointer and drop it in the slot under it. Simple lists also show a drop marker between items and drop there, asking dragAndDropUpdate (Rejected or None: no drop) and handleDrop (it takes the drop instead); the drag-and-drop arguments (CanStartDragArgs, SetupDragAndDropArgs, StartDragArgs, HandleDragAndDropArgs, DragAndDropData, DragVisualMode, DragAndDropPosition). MultiColumnListView (Columns and Column: header, cells per column, fixed and stretched widths, hiding and reordering columns; sorting by comparisons with sort descriptions and ids). TreeView's view controllers (DefaultTreeViewController: ids, parents, children, depth, moving and removing items, typed data) and MultiColumnTreeView (the tree's toggle and indents in the primary column, siblings sorted). contextual menus (DropdownMenu with statuses and separators, ContextualMenuPopulateEvent, ContextualMenuManipulator, managers; a player's panels show none, as Unity's), multi-column headers' menus (columns shown and hidden, headerContextMenuPopulateEvent) and columns resized by dragging their handles. Not yet: dragging between collection views, the animated mode's room following the pointer (Unity's stays where the item was), entity ids in drag data, transitions of discrete values (enums, images), world-space and render-texture panels

Animator with .controller state machines (parameters, conditions, exit time, cross-fades, Any State, 1D/2D/direct blend trees, override and additive layers, avatar masks on transforms, transition interruption by source or destination from a frozen pose, StateMachineBehaviours with OnStateEnter/Update/Exit in Unity's order and GetBehaviour, root motion from the root's curves with OnAnimatorMove, AnimatorOverrideController) and .anim clips (transform, component and script-field curves, sprite swaps, events). Skinned meshes deform by their bones after LateUpdate (on the CPU, as Unity weighs them: four bones a vertex, weights as written; BakeMesh with and without scale), and clips inside model files play (each .meta clip cut from its take by frame range, by the file IDs in its name table). Humanoid rigs and avatars (humanoid clips play as transform curves on the same skeleton, without retargeting), IK, sync layers and Timeline aren't yet; the legacy Animation component keeps its clips and states (Play, CrossFade, Stop change them) but doesn't move anything yet, and says so once; clips animating UI: RectTransform (anchored position, size, anchors, pivot, scale), CanvasGroup and uGUI graphics (Image color...), through their properties so layouts and graphics update

Cinemachine 3 (Unity.Cinemachine) and 2 (Cinemachine), built from the same sources; a project gets the one its manifest lists, and scenes' components (their scripts' GUIDs are shared) resolve to it. CinemachineBrain (the highest-priority camera, ties to the latest enabled; blends with Cut, EaseInOut, EaseIn/Out, HardIn/Out, Linear and custom curves, per-pair blender settings, blends interrupted mid-way; aiming at the blended look-at point and blending the field of view by its framing; lens onto the Unity camera), CinemachineCamera and Cinemachine 2's CinemachineVirtualCamera with its hidden pipeline object, standby updates, extensions (CinemachineExtension and its stages), CameraState and LensSettings. Components: CinemachineFollow and CinemachineTransposer (every binding mode; damping along the view from the offset to the target, as Unity's), CinemachineHardLookAt, CinemachineHardLockToTarget, CinemachineRotateWithFollowTarget, CinemachineRotationComposer and CinemachineComposer (screen position, dead zone, hard limits, damping), CinemachinePositionComposer and CinemachineFramingTransposer, CinemachineThirdPersonFollow and Cinemachine3rdPersonFollow (shoulder, arm, side, distance, obstacle avoidance), CinemachinePanTilt and CinemachinePOV, CinemachineBasicMultiChannelPerlin with NoiseSettings, CinemachineInputAxisController and CinemachineInputProvider. Checked in six scenarios recorded in Unity. Close to Unity but not exact: LockToTargetNoRoll and LazyFollow, third-person damping. Not yet: FreeLook and orbital follow, state-driven, clear-shot and mixing cameras, group framing, confiners, collider and deoccluder extensions, impulses, dolly tracks, Timeline

URP's Volume framework: Volume (global or local by colliders, weight, priority, blend distance), VolumeProfile assets and their override components, VolumeManager and per-camera stacks, blended as Unity blends them (interpolating numbers and colors, switching other values). Cameras with UniversalAdditionalCameraData.renderPostProcessing render in HDR and draw Bloom (threshold, intensity, scatter, tint, clamp), ColorAdjustments (exposure, contrast, color filter, hue shift, saturation), WhiteBalance, Tonemapping (Neutral, ACES) and Vignette, with overlay UI drawn after; curves and filters are our own. RenderPipelineManager's camera callbacks fire each frame. Other URP overrides (depth of field, motion blur, film grain, lens distortion, chromatic aberration, lift/gamma/gain...) are data only. Not yet: the built-in pipeline's Post Processing Stack v2, anti-aliasing, HDR output, post-processing with camera stacking

The project's render pipeline asset loads (UniversalRenderPipeline.asset, GraphicsSettings.currentRenderPipeline) with its renderers' features. ScriptableRendererFeature and ScriptableRenderPass run each frame per camera and record Unity 6 render graphs (RenderGraph, TextureHandle, TextureDesc, raster passes, UniversalResourceData, UniversalCameraData, ContextContainer); FullScreenPassRendererFeature. Their raster passes' full-screen draws run with the projects' shaders (Blit.hlsl, the camera's depth texture, the main light's shadow map), before post-processing or after it, into the graph's textures or the camera's color. Not yet: mesh draws in passes, SSAO, Shader Graph materials, the legacy Execute and CommandBuffer path

URP's 2D renderer lighting: Light2D (Global, Point with inner/outer radius and spot angles, Freeform and Parametric shapes with their falloff size) lighting sprites with Sprite-Lit-Default on its target sorting layers, through the 2D renderer's default blend styles (Multiply and Additive, and the two with a mask, whose mask reads white), adding or alpha blending in light order; URP's falloff curve (falloffIntensity) as its lookup texture bakes it; intensity and color made linear together as URP passes them; sprites on layers no light targets draw unlit. Shaded per pixel in the lights' plane (world XY), which matches URP's screen-space light textures for orthographic cameras. Sorting layers come from the project's TagManager (IDs, names, values relative to Default). Shadows: ShadowCaster2D outlines (its shape path; a sprite's bounds; or Unity's square fallback), cast on its target sorting layers, its own renderer only with self shadows (castingOption, castsShadows, selfShadows as Unity maps them), dimming each shadowed light by its shadow intensity; shadowSoftness widens a penumbra fanning out from each outline corner up to 15 degrees, shaped by shadowSoftnessFalloffIntensity, as URP's projected soft shadows. Sprite lights draw their cookie sprite's colors (and alpha) over the sprite's shape at the light's transform; a point light's cookie tints it across its outer radius (cookies are copied into a 2048x2048 atlas; 8-bit textures). Normal maps: lights with normal map quality on shade by the sprite's normal (its "_NormalMap" secondary texture, imported from the texture's settings, or its material's), lit from their normal map distance in front of the sprite. Not yet: volumetric light and shadows, the falloff offset, custom blend styles from a Renderer2DData asset, HDR emulation scale, sprite outlines as shadow shapes (bounds are used)

LineRenderer and TrailRenderer as Unity builds them (checked vertex by vertex against BakeMesh in the conformance suite): positions, loops, local or world space, width multiplier and curve, color gradient (startColor and friends store 8-bit values, colors go linear with applyActiveColorSpace), mitered joins (at most three half widths out), numCornerVertices (round outer corners) and numCapVertices (round ends), Stretch, Tile, DistributePerSegment and RepeatPerSegment texture modes with textureScale, View alignment (sides perpendicular to the line on screen, in perspective) and TransformZ, BakeMesh with or without the transform, bounds and localBounds, Simplify. Trails take their object's positions as Unity does: a point where it started, then one every minVertexDistance, each kept until the next has faded (time), read back fresh by positionCount and GetPositions; emitting off leaves a break; AddPosition(s), SetPosition(s), Clear, autodestruct; the oldest segment shrinks as it fades. Both import from Unity scenes and prefabs. Lines draw their vertex colors under sprite and particle materials (Sprites/Default, the particle shaders); lit materials ignore them, as in Unity. Not yet: the Static texture mode, normals and tangents for lit line materials, the exact sides of a moving trail's points (within about a degree) and of repeated points

ParticleSystem with its main module (duration, looping, prewarm, start delay, lifetime, speed, size and rotation (3D too), color, gravity, local or world simulation space, simulation speed, unscaled time, scaling modes, max particles, play on awake, stop actions), emission (rate over time and distance, bursts with cycles, intervals and probability), shapes (sphere, hemisphere, cone, box, circle, edge, rectangle; position, rotation, scale, arc, thickness, random direction and position), velocity, limit velocity, force, color, size and rotation over lifetime, and texture sheet animation (grid); MinMaxCurve and MinMaxGradient in every mode; Play, Pause, Stop (and stop behaviours), Clear, Simulate (in fixed steps, as Unity), Emit (with EmitParams), Get/SetParticles, Particle properties and GetCurrentSize/Color. ParticleSystemRenderer draws billboards (camera-facing, horizontal, vertical or stretched along velocity) after transparent geometry with alpha, additive, premultiplied or multiplied blending from the particle shaders (Standard Particles, URP Particles, legacy and mobile particle shaders) and sorts by distance, depth or age. Simulation timing matches Unity frame by frame in the conformance scenario. Collision with planes or the scene's colliders (World), as Unity bounces them (contact, bounce, dampen, lifetime loss, kill speeds; a particle a collision kills stays a frame), with OnParticleCollision on both sides and GetCollisionEvents; noise moving and turning particles by smooth 3D noise (strength, frequency, scroll, octaves, damping; not Unity's noise field); trails drawn with the renderer's trail material (lifetime, minimum vertex distance, width and color over the trail, ratio, dying with particles or not). Lights, sub-emitters, triggers and the other modules are settings only; mesh particles draw as billboards. Ribbon trails draw per particle. Not yet: GPU instancing of mesh particles, soft particles, custom vertex streams, ParticleSystemForceField

.unity and .prefab files, including prefab instances with overrides, added and removed components, and nested prefabs. Edited scenes save back to .unity with their prefab links kept; prefab instances in the format before Unity 2018.3 (Prefab objects with m_ParentPrefab) too. A loaded scene's scripts get Awake and OnEnable, then Start, in Unity's order: by script execution order, then by their place in the file (not the hierarchy); an instantiated or activated hierarchy's by execution order, then by their place in the hierarchy

Materials, textures, audio, ScriptableObject .asset files, FBX/OBJ/glTF models with their meshes and materials, all by GUID; Unity's built-in UI sprites (UISprite, Background, InputFieldBackground, Knob, Checkmark, DropdownArrow, UIMask) as stand-ins drawn by the engine at their sizes and slicing borders. Sprites as their importers set them up: single sprites with their pivot (the nine presets or custom) and 9-slice border, and sprite sheets (Sprite Mode Multiple) whose sprites scenes and Resources.Load/LoadAll name, in the meta formats of Unity 5 to 6. Textures larger than their importer's max size (the Standalone or default platform's) are scaled to fit, as Unity scales them, with their sprites' rects, borders and pixels per unit; ones larger than the GPU allows are drawn at a smaller size. Image files: PNG, JPEG, TGA, BMP, GIF, TIFF, Radiance HDR, and Photoshop documents (the saved composite of RGB, CMYK, grayscale or indexed documents, 8 or 16 bits, its white matte removed). Text files (.txt, .json, .bytes, .csv, .xml and others) are TextAssets

Scenes, prefabs, assets and project settings saved in Unity's binary serialization (Asset Serialization "Force Binary" or "Mixed", Unity 5 to 6) read through their type trees, as their YAML would. Unity 5's text form of maps (repeated data keys) too

A model placed in a scene imports as an instance of the model's prefab. FBX and glTF skins import (bones, bind poses, the four heaviest weights a vertex, normalized), and FBX takes as clips (posed at the first take's start, as Unity does); Resources.LoadAll lists a model's meshes, materials and clips. The model's prefab has Unity's file IDs for every object (type and path: Type:GameObject->//RootNode/root/Rig/Arm0, Type:Transform->//RootNode/root/Rig/Arm/Transform0), so scenes' and prefabs' overrides and added components reach objects below the root; skinned renderers are placed with their bones, and Generic or Humanoid models with clips get an Animator on their root, as Unity's importer gives them. glTF animations and blend shapes in models aren't yet

Compiled into Unity's assemblies: one per .asmdef (.asmref, GUID references), Assembly-CSharp-firstpass and Assembly-CSharp, with Player Settings' scripting define symbols (the desktop player's) and its input handling's defines. Editor code is left out. Precompiled managed plugin DLLs load (built against Unity's modules, they bind to Tassix's; types that need .NET Framework APIs .NET lacks are skipped); native plugins don't. BinaryFormatter works, as on Mono (System.Runtime.Serialization.Formatters, MIT, ships beside the runtime), saved data included: Assembly.Load and Type.GetType by name find the scripts' assemblies. ISerializationCallbackReceiver runs where Unity runs it (recorded): after a scene's or asset's fields are read and nested objects', on Instantiate (the original's OnBeforeSerialize, the copy's OnAfterDeserialize, before Awake) and in JsonUtility; not on AddComponent or CreateInstance. That's how Odin's SerializedMonoBehaviour fields load, through Odin's own DLLs. Base library types (TimeSpan, DateTime, Guid, decimal) aren't serialized fields, as in Unity. Compiled with Unity's defines: UNITY_X_Y_OR_NEWER for every release up to 6000.2, the exact version, ENABLE_INPUT_SYSTEM and ENABLE_LEGACY_INPUT_MANAGER from the project's active input handling, and asmdef versionDefines for the packages and modules the engine provides. Package scripts resolve by their known GUIDs without the project's Library, and pre-2019.2 scenes' references into UnityEngine.UI.dll by its class file IDs

Build scenes, tags and layers, input axes, gravity, layer collisions, fixed timestep, product name

Embedded packages with asmdefs. Packages from the registry (Library/PackageCache) aren't compiled; the engine provides glTFast, the Input System, uGUI, TextMeshPro, AI Navigation, Mathematics, Collections, Burst's API, and URP's and Core RP's runtime API (Volumes, post-processing overrides, camera data); com.unity.nuget.newtonsoft-json is Json.NET itself (13.0.3, MIT), shipped beside the runtime. com.unity.addressables is Tassix's own Addressables over the project's addressable groups (addresses, labels, GUIDs; loading, instantiating, scenes, AssetReference; no remote catalogs or bundles)

A packaged game folder (cargo xtask package): the player, the managed runtime and the .NET runtime it needs, the game's files, and its cooked assets. With --aot, the runtime and scripts are compiled ahead of time with NativeAOT into one native library (no .NET in the package); scripts then can't reload and exec isn't available. See packaging A windowed player opens its window at once with a splash screen: the Tassix logo on its dark background while the runtime starts and the game loads (at least 1.5 s), then a Unity project's splash logos (Player Settings, Unity's own left out, each on the project's background), then a fade to the game, whose frames start then. --no-splash and game.json's splash (show, background, min_duration) turn it off or change it, and a project's "Show Splash Screen" off turns it off. UnityEngine.Rendering.SplashScreen: isFinished, Begin, Draw (shows it again over the running game), Stop (at once or fading). Headless runs, screenshots and the MCP server have none, and isFinished is true there. The window's icon (title bar and taskbar) is a Unity project's own (Player Settings: the largest Standalone icon, else the default icon), else game.json's icon, else the Tassix icon

Developed and tested on Windows (x64) with Vulkan or Direct3D 12 through wgpu. The code is cross-platform Rust and .NET, but other platforms aren't built or tested yet; no consoles, mobile or web

No visual editor of its own: scenes are edited through MCP (an agent, with a person reviewing in the browser) or the headless editor CLI, or made in the Unity editor and played from the project