Archives

A beginner's explainer clipped after hearing tessellation come up in an interview and going to look up what it was. Pairing tessellation with displacement is exactly what Microsoft's docs do. But the field that looks like that pairing in Unity, the Standard Shader's Height Map, isn't displacement — the docs call it parallax mapping.

A landing page clipped while studying optimization, after it occurred to me that using high-quality models might make the game unplayable on a low-spec PC. The page is dated October 19, 2023, but the cover of the PDF behind Read now says '2020 LTS edition'. I picked four sections to see where that gap shows in the body.

Lecture notes on vertex processing, clipped while studying shaders by applying them. I checked three of its rules against the specs — the matrix a normal gets multiplied by, the cross-product order for the three camera axes, and what to change going from right-handed to left-handed. On the normal, the inverse isn't the wrong answer; what's missing is which side the vector sits on.

A 2022 video, clipped while using the Unity-chan model as the example to put a toon shader on and looking for how to do it. Open the repository now and it says the package is provided without any maintenance or release plan, and the successor package's docs list three reasons for the replacement — install method, pipeline, license. Those three line up with the video's chapter numbers.

Unity's own getting-started doc, clipped while studying shaders. Except the URL says 10.8 and what ships with the current Editor is 17.6. The property options table rotted the most in between — Exposed kept its name and changed its meaning, and Show In Inspector took over exposing the property.

Code I clipped while trying to hide the cursor at the center of the screen in an FPS and raycast from that point to find where a shot lands. The original calls z a 'fix that puts the axis in camera terms'; the docs call it 'the distance of the resulting plane from the camera'. It's not a fix, it's a choice — and locking the cursor removes the need to read the value at all.

Short code for facing the mouse, clipped while looking for how to do top-down controls. The method is right, but the plane sits at the origin and the height gets patched in separately. Put the plane at the object's position and that patch disappears.

Clipped while looking for how to play a video's separately extracted audio just once, then pulled back out while working on in-game dialogue and SFX output for the TTS project. It lays out the difference between Play() and PlayOneShot() in two paragraphs.

A learning diary I landed on while trying to find out what the Tag and Layer fields at the top of the Inspector actually do. It explains 2D draw order with Sorting Layer and Order in Layer. Both are right, but the docs call those two the higher-priority criteria and put one more underneath. And getting a layer name wrong quietly lands you in Default.

Clipped to pin down the exact path, since I'd been writing JSON saves to dataPath. It lays out where dynamically created files go. But the descriptions of dataPath and persistentDataPath are swapped. There are five path members, not three, and a relative path is relative to neither of them.

Clipped while looking for how to combine IK with an Avatar Mask so animation lands on the upper body only. It walks through making an Avatar Mask and plugging it into a layer. The procedure is right, but how far the mask's reach goes is missing. The body-part list differs between two pages, and the rule that holds the whole thing up lives in a tooltip, not the prose.

Clipped while working through the annoyances of a Scroll View: a record of a popup's scroll view opening at the bottom every time. The author traced it to the parent's open animation but wrote that he wasn't sure what the interaction was. The docs don't write the within-frame order down either. What they do give is a way to find out and a way to defer.

I was planning cutscenes as video playback when I clipped a post on putting video in the UI. The procedure is right, but it blames Color Format for the quality and never once says how to know the video ended. What the docs list as the knobs are resolution and Aspect Ratio, and there's a mode that skips the Render Texture entirely.

A tutorial on filling a Scroll View with Layout components. Follow it and you get a working one. But the axis it tells you to anchor is the axis the Content Size Fitter takes over, and the Pivot that decides the direction is never mentioned.

A 2022 post implementing TTS in Unity. It calls an internal address belonging to the Google Translate web UI. Whenever that address stops answering, this code can't tell. It checks one of five failure results, and the rest fall into the success branch.

I clipped this while looking for a way to modify an Asset Store animation that showed up as ReadOnly. The post says duplicate it. But what's read-only is one window, not the clip, and a good deal of what counts as modifying needs no duplicate.

A ragdoll walkthrough blames bodies stretching like taffy on a low Strength value. But Strength is documented nowhere in the Unity manual, and stretching has a page of its own. That page points at something else.

The author of an Input System walkthrough left a question unanswered: why do started and performed behave identically? The answer isn't a frame, it's two thresholds — and the page that documents them contradicts itself in the same entry.

A 2023 write-up of the Audio Mixer setup procedure. It lists snapshots as a reason to use the mixer, and the code right after permanently takes those three parameters out of snapshot control. The docs say so in one line.

A 2025 introduction to Awaitable. The constraints it points out still hold, but the two lines demonstrating them don't compile. And two of the features it wishes for are documented members.

A 2022 post on scanning the surroundings with OverlapSphere. Fetching the layer by name is the right move, but the value then gets shifted by hand. When NameToLayer returns -1, that expression points at layer 31 instead of throwing.

A 2022 post on registering events with Action. The behavior descriptions are accurate, but the comment 'anonymous functions can't be removed' hides the reason. What blocks removal isn't anonymity — it's not holding the same instance.

A write-up on Obsidian code blocks. The explanations mostly hold, but where it pins backticks at 'three', the post's own first example trips. It escaped the backticks to nest a code block inside a code block — and the docs say that isn't necessary.

Notes from the Unite Seoul 2025 optimization session. I cross-checked some twenty items against the docs one by one. Most hold up; five don't. The most dangerous is AssetBundle.Unload, whose two parameter cases are swapped.

I clipped the Outline component doc and it's the Unity 5.3 edition. Yet the wording is nearly identical to the current page. It wasn't updated — which is why Use Graphic Alpha's description still contradicts the property's own name.

I clipped the assembly definition files doc and it's the 2017.4 edition. Its account of one-directional dependency is right, but it never says the reverse direction is forbidden. That's the actual reason behind the 'all scripts or none' recommendation.

The introduction page of lilToon's official docs. It recommends converting a material rather than assigning the Lite version directly, and gives 'more intuitive' as the reason. The actual reason is that the shader's name starts with Hidden/, so it never appears in the material dropdown at all.

A 2024 write-up on what a shader is. The transcription argument is accurate and even brings sources, but one sentence of the definition conflicts with the structure section two sections later. What's written there is a pixel shader, not a shader.

A guide that lays out serving Ollama locally as an API across eleven sections. Install and CLI are usable as written, but the three sections actually about hosting are each wrong. And the setting you hit first when several clients connect isn't in the guide.

A 2016 write-up following Head First through the factory patterns. The concepts are textbook-correct, but all three code sections are broken — and they break the same way. Take the type as a string and there's nothing for the compiler to see.

A 2017 write-up that tabulates the container resource-limit options. It works as a map, but three spots snag if you copy from it. Two swap rules are written as opposites, the example's swap size is doubled, and the period default is off by ten.

A 2020 learning log that turns Rigidbody and Physics Material dials and films the result. The observations are good, but two puzzles are left open. Both resolve in the same place: bounciness and friction aren't one object's values, they're made by the two colliders in contact together.

Discord's Go-to-Rust post diagnoses the problem accurately, and the diagnosis still holds. But only two knobs got turned. GOGC sets frequency and cache size cuts the hit rate. The variable that sets scan cost is the pointer count, and Go doesn't scan pointer-free objects at all.

A tutorial that shows the whole thing, from a signaling server to sending a camera feed. But IsConnected compares against Connecting, so the Disconnect button dies the moment the connection is actually established. RemoveTrack and OnNegotiationNeeded each have a hole too.

A walkthrough of the TextMeshPro Inspector where four fields point at the wrong thing. Override Tags only ignores color tags, Text Wrapping Mode has no Overflow value, Extra Settings holds neither outline nor shadow, and Text Style isn't Font Style.

The clipping's ObjectPool implementation uses the official API correctly. But OnGet and OnRelease are one line each. It does none of the six things the manual says to reset on release, and the coroutine SetActive(false) ended doesn't come back when you re-enable.

The Inspector walkthrough of Layout Group is accurate. What's missing is why children collapse to 0 when you tick Control Child Size. That checkbox makes the group read sizes from layout element properties instead of the Rect Transform, and a bare RectTransform answers 0.

The reason for using an AudioMixer and the explanation of the log conversion are both accurate. But the unmute code feeds a dB value into a linear slot, so instead of restoring the volume it writes NaN or -Infinity.

The advice to split with #if UNITY_EDITOR because play mode doesn't stop is correct. But ship this script to Android and the back button becomes a quit button — and the docs don't recommend this function on Android in the first place.

Finding PlatformEffector2D is the right answer. But what the component actually evaluates isn't 'did you come from above or below' — it's whether the contact normal falls inside an arc. Not knowing that angle is what snags you at the edges.

The steps for wiring up MCP for Unity are worth following. But the premise the post starts from — that Claude Code charges for MCP connectivity — isn't what the docs say, and two product names are mixed together.

The explanation of how fake null works is accurate. But the 'reduce the cost' list that follows it is almost entirely off — it calls something cheaper that runs the exact same function, and two of its snippets don't compile.

The steps for wiring up a multiplayer room with NetworkRoomManager are worth following. But the scale claim in the intro is off by an order of magnitude from Mirror's own guide, and the way it pairs the four scene fields is the reverse of the source comments.

A 2022 walkthrough of the PeerConnection sample. But the place where SDP and ICE are exchanged isn't a network — it's a call to GetOtherPc() — and the WebRTC.Initialize() the post opens with no longer exists.

Code written so a name can be entered by keyboard or by mouse — except the keyboard path does nothing until the mouse button has been clicked once. The condition reads a string cached in Awake, not the input field.

A short post listing the storage paths — but the real point is that the path is assembled from two Player Settings fields. Change either one and PlayerPrefs can no longer read what you saved.

The docs call point0 'the center of the sphere at the start of the capsule.' That's the center of the end cap, not the tip. Read it as the tip and your capsule grows by twice the radius.

Following an install guide for com.unity.nuget.newtonsoft-json, the version field stopped me. Typing 3.0.1 and then hitting Update is two steps you don't need — and 3.0.1 happens to predate the IL2CPP fixes.

A 2024 walkthrough of the Input System — from installation to three ways of driving it — checked against the current docs. All three of its samples carry the same dead conditional, and the generated class never uses the one feature that justifies generating it.

I clipped a current-time utility while trying to put a time-attack run timer on screen, but the type I needed wasn't that one. The type for elapsed time, the clock to read, and the format string rules are all different.

I checked a post about replacing a misbehaving isGrounded with a raycast against the current docs. The symptom and the fix are both real, but the docs put the cause somewhere else — and one number in the fix is far more generous than intended.

I checked a 2021 set of study notes on Animator's properties and functions against the current docs. The descriptions are accurate; what's missing is the conditions that make those switches do nothing. Three places had that shape.

I checked a 2021 round-up of eighteen attributes against the current docs. Most of it holds, but one example asks for two incompatible things, one is something the docs tell you not to use, and one guards less than it looks like it does.

I checked a 2023 write-up of Addressables against the current docs. The example's release ordering is wrong, and the duplicate-key problem the author spent hours on is one line in the manual. Lining it up with Unreal's soft references — where I started — makes that release problem clearer.

Same Physics class, different default layer masks for Raycast and OverlapSphere. An object you parked on Ignore Raycast to keep it out of queries still shows up in OverlapSphere.

I checked a CrossFade explanation written in 2014. It's correct. But the component you'd actually use today has a method by the same name, and the second argument is in a different unit.

Mathf.Clamp takes four lines to explain. The trouble is everything outside those four lines: what happens when you swap the bounds, when NaN arrives, and when you clamp an angle.

I read Unity's introduction to render pipelines. I had it filed as picking one of three, but following the docs it turns out Built-In isn't something you pick — it's what remains when you've assigned nothing.

Unity's thirteen official HLSL shader examples are all Built-In only. The first few port to URP by renaming things; from lighting onward it's a rewrite. I mapped them one by one — and found a line I got wrong in the previous post.

Unity's Custom shaders page has a separate row for URP and for the Built-In pipeline. That split is usually why shader code you find online won't even compile. Here's what actually differs on each branch, plus what's under the Troubleshooting row nobody clicks.

Unity's Code optimization manual page is five links and nothing else. Four of those five are tables of contents too. Here is what's left after descending to the leaves — only the parts that actually change code.

Unity's official Sentis workflow page is a six-step skeleton. Here is what it omits — the Resources folder, tensor ownership, and the GPU stall hiding in the line that reads your result — filled in against the rest of the same manual.

I checked Wikipedia's TCP/UDP port list against the IANA registry. UDP is missing from 443, the dynamic port range doesn't match what Linux actually uses, and the 1024 boundary isn't fixed.

I saved the TcpListener.AcceptTcpClient documentation. Its example treats TCP as a stream of messages, and another page in the same doc set carries a fixed version of it.

I saved the README of a URP glitch effect package. Open that repository now and it carries a notice that the author has stopped updating it, pointing at keijiro's official URP version.

I checked a write-up on RigidbodyConstraints against the manual. Four enum members are missing, there's nothing about which axis it freezes relative to, and the bitwise explanation is wrong in two places.

I checked a write-up on three ways to download a whole Hugging Face model. Two of them use a command removed in v1.0, and recommending git for SSL errors works — for a reason the article doesn't give.

I checked a 2021 guide to installing PostgreSQL on Ubuntu. The version it gets you went end-of-life in 2024, and its explanation of authentication had one word wrong from the start.

I checked the Korean machine translation of Unity's GPU optimization how-to against the English original. Terms split within a single document, and the Frame Debugger note isn't a translation problem — the original says it too.

I checked an OpenCode usage review and install guide against how things stand now. What the article said works today is now called prohibited by the official docs, and its JSON examples carry a paste artifact that breaks on copy.

I checked a January 2026 oh-my-opencode install guide against how things stand now. The project has been renamed, and the Anthropic subscription cutoff it warned about actually took effect in April.

I checked a set of notes on the Ollama API against the official docs. The cause of the too-long response was one parameter, but the notes changed three at once, so the credit got split three ways.

This clipping is Mirror's own Network Manager documentation. With no source to check it against, I checked it against the code — and found a method name that doesn't exist and a sentence that reads backwards.

I checked a write-up on MySQL/MariaDB index creation and EXPLAIN against the manuals. The hash index recipe doesn't work on InnoDB, and four of the EXPLAIN column descriptions are wrong.

I checked a write-up on Mirror's correct design patterns. The big picture holds up, but its last example calls SceneManager.LoadScene — and a client that joins later ends up in the wrong scene.

I revisited a write-up covering what to know before adding Mirror. The concepts still hold up, but the first item doesn't: the Asset Store build stopped in February 2025 while GitHub releases kept coming.

I checked a field-by-field table of the NetworkManager inspector against the tooltips in Mirror's source. Some groupings are off, and the Headless Start Mode options and the unit on Evaluation Interval are wrong.

I revisited a write-up on Mirror's Command, ClientRpc, and TargetRpc. The prefix rule and argument types differ from today's docs, and more importantly, the example code carries a pattern that defeats server authority.

Rather than memorising JsonUtility's list of limitations, one rule predicts them: if it isn't visible in the Inspector, it isn't in the JSON. Plus the most dangerous item, which the manual never mentions — polymorphism.

Revisiting a write-up covering ISO 8859-1 through EUC-KR, CP949 and UTF-8. Three widespread misconceptions corrected against the official specs and bytes I measured myself, plus how to trace mojibake back to its cause.

Why ML-Agents installation is so particular, traced back to the toolkit being split in two. What Conda and the exact 3.10.12 are for, how the Unity and Python package versions pair up, and the two names for the inference layer.

Handling input by subscribing to InputAction in code instead of using PlayerInput's Behavior. Why subscribe and unsubscribe belong in a pair, who actually enables the action, and what looking actions up by string costs you.

Revisiting Unity's 2021.3 manual page on adding GPU instancing to custom shaders. The Korean localisation has three macro typos, and the render pipeline compatibility table has changed since.

Revisiting a 2021 write-up on untracking LFS and reclaiming GitHub storage. Three of its commands are described differently from what they actually do, and GitHub's LFS policy has moved since.

A post I clipped while trying to isolate a database in a container. What the dot in `docker build .` actually is, why the example Dockerfile won't run as written, and what you actually need when the thing you're containerising is a database.

A review I clipped while looking for a TTS asset that runs locally — except its conclusion that the asset 'works completely standalone' isn't true, and four pieces of evidence against it were already in the review. Plus what actually does run locally.

Why prediction is needed and how it works, and what Mirror gave up by not resimulating the whole physics scene. Also: the docs stopped in March 2024 while the code kept moving.

PlayerInput's API reference is a list of properties, which is not what you need when you first attach it. Why the four Behavior options demand different code, why callbacks fire more than once, and whether a single-player project needs this component at all.

The Follow Camera used for racing and runner chase cameras, written up against Cinemachine 3. What Binding Mode actually decides, and two widely repeated misreadings — mouse input and Target Offset — corrected against the official docs.

The steps for subscribing to BACKND through AWS Marketplace, and why the two warnings in the announcement exist — explained through the AWS SaaS onboarding flow. Plus what cancellation actually suspends and where the real price list lives.

Revisiting a 2021 write-up of AWS data transfer pricing against today's rates. The numbers have changed several times over; the structure hasn't. Which boundaries cost money, and which parts of the original are now wrong.

asus4/google-gemini-unity is an unofficial client for calling the Gemini API from Unity. The install steps and the dependency chain, why the .env approach the README describes doesn't hold up in a shipped build, and what to use instead.

Notes from trying to build an open-source app myself. The Generate Signed Bundle/APK flow in Android Studio, where the keystore it creates should actually live, and what Play's AAB requirement and Play App Signing changed.

What mediation is, how waterfall differs from in-app bidding, and what this SDK actually drags into your build as a client developer.

The bottleneck in on-device inference is usually not inference itself but data movement between GPU and CPU. Here are the Sentis APIs that reduce it.

lilToon's inspector is localized, but its official docs are Japanese only — the source of the mistranslations, so I cross-checked every entry.

Looking up Ext4 after it showed up as the default in an Ubuntu install: its structure, formats for drives shared with Windows, and case sensitivity.

Every stage 3D geometry passes through on its way to becoming pixels, including vertex post-processing, output merger, and the newer mesh shader path.

Notes on adb for debugging Android builds, from architecture to commands, based on SDK Platform Tools 37.0.1, plus where decade-old guides go wrong.