UdonSharp notes for VRChat world creation. All 63 articles are organized as a learning path you can follow in order, from fundamentals to advanced topics.
01A learning map that starts with a 6m floor and layers on light, sound, gimmicks, sync, and publishing. Covers the stopping point of each step and three schedules: one day, one weekend, one month.
02Create a Worlds project with ALCOM or VCC and get the VRChat SDK panel open in Unity. Covers how the four tools connect, choosing a save location, waiting out the first launch, and verifying you're done.
03Separating what Hierarchy, Scene, Inspector, and Project each do, then placing a Cube, moving it, and saving. Also covers finding your way back when the view gets lost, why a Cube sinks into the floor, and which Unity features to ignore.
01Place a 6m floor, VRCWorld, a spawn point, and a Respawn Height, walk around in ClientSim, then enter real VRChat with Build & Test. Build your first walkable space while matching each number to its result.
02Raise walls on a 6m floor, cut a 1.6m doorway, and build three steps. Covers the dimensions that don't feel cramped in VR, separating visuals from collision, and stairs that don't snag.
03Turn three identical Cubes into a wall, a pass-through decoration, and a falling box. Toggle Collider, Is Trigger, and Rigidbody one at a time, and learn why 'walk into it to push it' isn't reliable in VRChat.
04Getting furniture from Booth into your world. How to import a unitypackage, fix models that come in giant or tiny, add collision, and get rid of the pink.
05Place two identical lamps and try changing only one, changing both from the original, and reverting. Covers Override versus Apply and Revert, and why sharing a material changes both.
06Comparing spawn orientation, partitions, and seating arrangements in the same room. How to place things so a first-time visitor finds a seat, and how side-by-side versus face-to-face changes conversation.
01Sorting out Shader, Material, and Texture with a wallpaper analogy, then applying a tile image to a 6m floor. Covers deciding Tiling from real-world size, what actually causes pink, and the pitfall of shared materials.
02Setting one Point Light to Baked, baking it, and getting shadows on the floor. Covers Realtime versus Baked versus Mixed, Contribute GI and Generate Lighting, and why it goes dark right after baking.
03Why only the props stay dark in a baked room, explained through the difference between burnt-in light and samples of the space. Covers placing Light Probes, and reflecting the room in metal with a Reflection Probe.
04Swapping the Skybox to change the sky, and blurring the distance with Fog. Why the sky changes the room's brightness, and why fog color follows the sky, compared side by side in the same garden.
05Separating BGM that plays at the same volume anywhere from ambient sound that grows as you approach. Covers volume targets, distance falloff settings, and picking a level that doesn't get in the way of conversation.
06Building one rising column of glowing motes with a Particle System. The five settings to touch first, and a side-by-side look at how screen area, not particle count, decides the cost.
07Installing AudioLink and building one wall panel that glows with the BGM's bass. Covers the mechanism that turns audio into four numbers, and the shortest route to glowing with a supported shader.
08Causes of heaviness come in an order. Adjust mirrors, realtime shadows, and LOD one at a time and watch the Stats numbers drop. Covers getting lighter while keeping the look.
01Contrasting what SDK components alone can build against where Udon becomes necessary. Covers how Udon and UdonSharp relate, where code runs, and three misconceptions worth clearing up first.
02Creating a U# Script, confirming the press lands with a log before changing any color. Covers how the C# file, Program Asset, and Udon Behaviour relate, and the order to check when Interact doesn't respond.
03For people with no programming background: using variables, if, for, and functions inside a single example. Build a button that counts presses and cycles three lights through three colors.
04Grasping value versus reference as 'a note' and 'a pointing finger,' then toggling a light's brightness. Covers why editing code doesn't change the Inspector value, and the classic None-reference dead end.
05Organizing a light's settings fields with SerializeField, Header, Tooltip, and Range. Covers why Range only limits input and is ignored from code, and the difference between saving and syncing.
06Experiencing when Start, Update, and Interact run, using a rotating display and a stop button. Covers why Time.deltaTime is necessary, and how to think about avoiding Update.
07Interact means 'the target was successfully used'; Input Events mean 'a button was pressed.' Confirming the difference with logs, plus interaction distance and Colliders, and how VR and desktop differ.
08Making a button at the entrance and one at the back both operate the same light. Covers keeping the logic on the light's side, and when to use a typed reference versus SendCustomEvent.
09Building 'run three seconds after the press' with SendCustomEventDelayedSeconds. Covers why it's lighter and more readable than counting seconds in Update, and what happens when people spam the button.
10Counting people with OnPlayerJoined and OnPlayerLeft and showing it on a wall board. Sorts out whose client fires for whom, and why joining fires for everyone already present.
11Gathering three lights that used to be copy-pasted logic into an array. Covers why indices start at 0, how to avoid going out of range, and the accident of unset Inspector elements.
12DataList and DataDictionary for when arrays aren't enough. Load light settings written in JSON, look values up by name, and apply them. Also covers checking types on the way out.
13When ordinary C# doesn't work, telling your own bug from an Udon limitation. Hands-on with the four limits you'll hit most and the DataList alternative.
01State is a blackboard, cues are shouts, ownership is the microphone. Build a light switch with a Manual-synced bool and take it through two-player and late-joiner testing.
02Ownership is one person per object. Confirm the difference from Master, when it transfers automatically, and what happens when the owner leaves, using a claim button and a light button.
03Building a chime that rings for everyone when pressed. Covers when to use this versus synced variables, the three targets, why late joiners hear nothing, and handling rapid presses.
04Adding VRC Object Sync to a holdable prop so its thrown position is shared with everyone. Also covers why position travels automatically while state like a light being on needs separate syncing.
05Saving a BGM volume slider to PlayerData and restoring it next visit. Hands-on with why reading before restoration wipes your save, and how to avoid it.
06Handing every visitor their own object with VRCPlayerObject. Covers the template-and-copy relationship, what VRCEnablePersistence saves, and how to find your own copy.
01Switching a light, BGM, and a sign together from a single bool. Covers separating state from reactions, why you align the initial state in Start, and how to avoid deleting the button itself.
02Showing a marker only to the person who entered a Box Collider's volume. Covers whose client the event fires on, why isLocal is necessary, and where detection slips through.
03Building a teleporter that moves you from a button. Covers using an empty Transform to define the landing point and facing, and fixing sinking into the floor and carried-over falling momentum.
04Placing an entrance to another world with VRC Portal Marker. Covers why it can't move people within the same world, and building the TeleportTo version for that case.
05From when standard respawn is enough, to a mechanism that returns players to their last checkpoint. Covers watching height, resetting velocity, and writing it so it can't loop forever.
06A VRChat chair combines a visual model with a sitting mechanism. Grasp what a Station does, place the SDK's chair, and adjust sitting, standing, and where people exit to.
07Building a holdable prop from Rigidbody, Collider, and VRC Pickup, and lighting it with the Use button. Covers the classic problems of flying off and sinking into the floor, plus adjusting the grip.
08Placing the SDK's mirror and making it toggleable with a button. Covers why mirrors are expensive, narrowing the reflected layers, and keeping it off by default.
09Putting buttons and a slider on a World Space Canvas to build a settings panel that drives Udon. Covers the components required to make it pressable in VRChat, and why it doesn't respond.
10Putting a pivot at the door's edge and switching between closed and open poses with an Animator. Covers how Animation Clips and Controllers relate, why you uncheck Has Exit Time, and Udon's SetBool.
11Lining up a button-operated door across everyone's screens. Covers why you sync a bool rather than the Animator's state, how late joiners get it, and handling ownership.
12Building a die that shows the same face to everyone. Why rolling separately on each machine disagrees, and the idea of the owner deciding once and distributing, built hands-on.
13Instead of creating objects at runtime, you check three pre-placed ones in and out. Covers asking the stock keeper, handling an empty shelf, and why you reset position on return.
14Playing video on a screen so late arrivals see the same moment. Covers syncing only the URL and start time, and why you align the position after loading finishes.
15Displaying text from the web on a world's notice board. Covers the request-then-receive flow, why you separate body from status, and building it so a failed load doesn't erase the notice.
16Displaying a web image on a world panel. Covers why the downloader lives in a field, how to handle Dispose, and building it so the previous image survives a failure.
01Chasing an unresponsive button down to its cause with the Console and Debug.Log. Covers the order of isolation from an entrance log, and when to use ClientSim, Build & Test, and the real client.
02Before optimizing, split heaviness into four kinds and measure. Covers when to use Stats, the Profiler, the Frame Debugger, and build size, plus how to keep records.
03Replacing every-frame logic with events to cut Udon's load. Also covers caching lookup results and reducing how often you send synchronization, measured as you go.
04Can't grab it, pitch black, pink, not syncing, won't upload. Ten common symptoms with candidate causes and the articles that fix them, plus three questions for narrowing it down.
05Confirming that settled props are asleep and eliminating what keeps them awake. Covers cutting collision pairs with layers, and why to avoid Mesh Colliders.
01Building the Android version from the same scene and publishing it under the same Blueprint ID. Covers what drops first on Android, per-platform texture settings, and how to verify.
02Fixing one settings panel so seated players, one-handed players, and phone users can all use it. Text size, button spacing, and turning volume into steps — three hands-on adjustments.
03Cutting the size of a world that takes forever to load. Why textures dominate the size, and how Max Size and Crunch compression take effect, compared with real numbers.
04Uploading a 6m floor as a Private world, then moving a marker and updating the same ID. Covers Build & Test versus Build & Publish, what the Blueprint ID does, and isolating updates that don't arrive.
05Ten things to check before release, walked through for real. Spawn point, falling, collision, mirrors, volume, devices, size — the things builders miss, in order.
06The loop after submitting to Community Labs. Covers placing contact info and a changelog, taking in reports, what to watch when updating, and how to relate to the numbers.