Error

Codes that begin with TUKI (12)

Number	Meaning	Description
TUKI0001	A form this language does not support	Valid as C#, but the runtime has no corresponding mechanism. This is the most common number, and the alternative forms are in each page’s table of unsupported forms
TUKI0099	A form that doesn’t compile	Accepted as syntax, but there’s no way to turn it into Udon instructions. Often appears together with TUKI0001.
TUKI0101	A call not present in the runtime	The method being called doesn’t exist on the Udon side.
TUKI0102	A type not present in the runtime	The variable’s type doesn’t exist on the Udon side.
TUKI0103	A type that can’t be synced	The type of a variable marked [UdonSynced] isn’t eligible for sync (sync).
TUKI0106	A type that can’t interpolate	[UdonSynced(UdonSyncMode.Linear)] or similar is attached to a type that can’t produce intermediate values (sync).
TUKI0108	A form that holds a method as a value	Delegates and lambdas. Udon has no function values. Writing one as a type, creating one, or calling one all error for the same reason
TUKI0109	Two or more programs in one file	One file becomes one program (the shape of a program).
TUKI0110	A field that can’t be synced	[UdonSynced] on a const, static, or readonly field (Sync)
TUKI0112	A cycle in reactive dependencies	The dependencies loop back on themselves, so the order of updates can’t be decided (Reactive programming)
TUKI0114	A check call outside a test	Assert and Mimic can only be written inside a method with [TsukimiTest]. Mimic.Explore() must also be the first statement of the test (Testing)
TUKI0201	A null-safety violation	Only appears in a range marked #nullable enable. What C# treats as a warning, this treats as an error (null and references).

Numbers with no example in this document (17)

Number	Meaning	Description
TUKI0104	Not enough storage for variables	There’s a cap on the number of variables one program can use.
TUKI0105	Too many type argument expansions	Too many combinations were passed to a generic to expand them all
TUKI0107	A conflict between the sync mode and the variable	The [UdonBehaviourSyncMode] setting and the way [UdonSynced] is attached don’t match up.
TUKI0117	A test sits in a file that goes to the world	[TsukimiTest] is written in the world-bound file. The method is built into the program that goes to the world and is exposed as an entry point. It compiles (does not stop)
TUKI0202	A null comparison that always gives the same result	Comparing a value type against null. It compiles (it doesn’t halt)
TUKI0203	Taking a value type out of an object	Reading it costs one conversion. It compiles (it doesn’t halt)
TUKI0204	The cost of a 2D array	It turns into boxing each element on the way in and out. It compiles (it doesn’t halt)
TUKI0116	A reserved name	Names beginning with __, and the names of the slots that receive the arguments of an event you handle (onPlayerJoinedPlayer for OnPlayerJoined), are used by the compiler for its own heap variables. Renaming the field fixes it
TUKI0120	A model that cannot be compiled in	The trained model is outside the range that can be compiled in. The fix is in the settings of the tool that exported the model; rewriting the C# does not help (ONNX models (experimental))
TUKI0121	A name a shader cannot hold	A name in the part that runs on the GPU (kernels, the methods they call, and their parameters and locals) contains something other than ASCII letters, digits and underscores. Renaming it fixes it (methods and fields that stay on the Udon side can use any name)
TUKI0111	Change propagation can’t be built	The reactive attribute was read, but not one piece of change-propagating code could be placed. The effect isn’t run automatically (Reactive programming)
TUKI0113	An effect that nothing runs	The effect’s trigger doesn’t change in any entry point. It compiles (it doesn’t halt)
TUKI0115	An attribute on a synced field	A value that arrives doesn’t run the effect (propagation is inserted only in the entry point that writes the value). It compiles (it doesn’t halt)
TUKI0119	An effect that runs only once, at startup	No entry point that writes a dependency can be found, so it doesn’t run when the dependency changes later. It compiles (it doesn’t halt)
TUKI0901	An internal compiler error	Not a mistake in the code you wrote. The same code may well be correct, so rewriting it won’t necessarily fix it
TUKI0902	Analysis failed	The analysis failed partway through. An empty result doesn’t mean the risk is absent
TUKI0903	A call in the output program to a name that doesn’t exist	The compiled program calls a name that isn’t in this runtime’s Udon API. The name doesn’t appear in the code you wrote

Reason

The “Why” column in the “Not supported” tables is one of these four words. Whether it is worth waiting for is decided here.

• Runtime: the runtime side has no mechanism. It can’t be written unless the runtime changes
• By design: the mechanism exists, but this language decided not to support it. It never will
• Not yet: the intent is to support it; it isn’t implemented. This can change
• Undecided: no decision has been made

Types the runtime has

When the type is absent	This runtime exposes only part of the Unity and VRChat types, and writing a type that isn’t there into a variable is a TUKI0102 error
When the call is absent	Even when the type is there, not all of its calls are. A call that isn’t exposed is a TUKI0101 error
Where the list lives	Not in this document. Unity types are in Unity’s script reference, and VRChat types in VRChat’s creator documentation