A list of built in Unity Attributes.

• Property Inspector
• Component Related
• Serialization
• Other
• Undocumented
• Editor

Note: Attributes can be placed in a single set of square brackets:

[HideInInspector][SerializeField] int score;
// can be
[HideInInspector, SerializeField] int score;

These aren't all the attributes available, and a few of them are system attributes, not Unity ones.

Added December 9, 2020:

• HelpURL

Added May 6, 2020:

• GradientUsage
• Min
• InspectorName
• Delayed
• ContextMenuItem
• ImageEffectTransformsToLDR
• ImageEffectAllowedInSceneView
• ImageEffectOpaque
• ImageEffectAfterScale
• ImageEffectUsesCommandBuffer
• AssemblyIsEditorAssembly
• ExcludeFromPreset
• ExcludeFromObjectFactory
• ExcludeFromCoverage
• SharedBetweenAnimatorsAttribute
• BeforeRenderOrderAttribute

Added July 3, 2018:

• DidReloadScripts
• PostProcessScene
• PostProcessBuild
• Preserve
• RejectDragAndDropMaterial
• CustomGridBrush
• IconName

HideInInspector: Stops the property from showing up in the inspector.

[HideInInspector] public bool reset = false;

Range: Limit the range of a float or int.

[Range(0, 100)] public float speed = 2f;

Min: Limit minimum value of float or int.

[Min(1.0f)] public float speed = 2.0;

Multiline: Show more than one lines.

[Multiline(4)] public string description = "";

TextArea: Draw a flexible scrollable text area.

[TextArea] public string description = "";

ColorUsage: Allow alpha channel to be modified, and allow HDR mode.

[ColorUsage(true, true)] public Color color = Color.white;

GradientUsage: Use on a gradient to configure the GradientField.

[GradientUsage(true)] public Gradient gradient;

Space: Add space between inspector elements.

public float item1 = 0f;
[Space(10)]
public float item2 = 0f;

Header: Shows a bold label in the inspector.

[Header("Stats")]
public int health = 100;
public float speed = 0f;
[Header("Items")]
public int ammo = 10;

Tooltip: Text shown on mouse over.

[Tooltip("The games score.")] public int score = 0;

InspectorName: Use on enum to change it's display name.

public enum ModelImporterIndexFormat
{
    Auto = 0,
    [InspectorName("16 bits")]
    UInt16 = 1,
    [InspectorName("32 bits")]
    UInt32 = 2,
}

Delayed: Use on float, int, or string to delay property being changed until user presses enter or focus changes.

[Delayed] public string health = 100;

DisallowMultipleComponent: Prevent more than 1 of this component being on a GameObject.

[DisallowMultipleComponent]
public class MyScript : MonoBehaviour
{
}

RequireComponent: Tell GameObject to add this component if it isn't already added.

[RequireComponent(typeof(RigidBody))]
[RequireComponent(typeof(Component1), typeof(Component2), typeof(Component3))]  // You can enter multiple components into attribute.
public class MyClass : MonoBehaviour
{
}

ExecuteInEditMode: Will call MonoBehaviour methods like Update and OnEnable while in EditMode.

[ExecuteInEditMode]
public class MyClass : MonoBehaviour
{
}

ContextMenu: Add a context menu to a MonoBehaviour or ScriptableObject.

[ContextMenu("Reset Score")]
public void ResetScore()
{
    score = 100;
}

ContextMenuItem: Calls a method for a field.

[ContextMenuItem("Reset Score", "ResetScore")]
var score = 10;

void ResetScore()
{
    score = 0;
}

SelectionBase: Will select this GameObject when a sub object is selected in the editor.

[SelectionBase]
public class MyClass : MonoBehaviour
{
}

HelpURL: Will set a custom documentation URL for this component accesible via the help icon from the component view in the Inspector window within the Unity Editor.

[HelpURL("https://example.com/docs/MyComponent")]
public class MyComponent : MonoBehaviour
{
}

SerializeField: Force Unity to serialize a private field.

[SerializeField] private int score;

NonSerialized: Prevent Unity from serializing a public field.

[NonSerialized] public int score;

FormerlySerializedAs: If you changed the name of a serialized property, you can set this to the old name, so save data will still work.

[FormerlySerializedAs("myValue")] private string m_MyValue;

Serializable: Make a class Serializable so it will be visible in the inspector.

[System.Serializable]
public class MyClass
{
    public int myInt = 10;
    public Color myColor = Color.white;
}

ImageEffectTransformsToLDR: Use on image effect to cause destination buffer to be LDR buffer.

ImageEffectAfterScale: "Any Image Effect with this attribute will be rendered after Dynamic Resolution stage."

ImageEffectAllowedInSceneView: Allows image effect to work on scene view camera.

[ExecuteInEditMode, ImageEffectAllowedInSceneView]
public class BloomEffect : MonoBehaviour
{
}

ImageEffectOpaque: "Any Image Effect with this attribute will be rendered after opaque geometry but before transparent geometry."

[ImageEffectOpaque]
void OnRenderImage(RenderTexture source, RenderTexture destination)
{
}

ImageEffectUsesCommandBuffer: "Use this attribute when image effects are implemented using Command Buffers."

void OnRenderImage(RenderTexture source, RenderTexture destination)
{
}

RuntimeInitializeOnLoadMethod: Calls a method once before or after the first scene has loaded. Good for initializing Singletons without having to place objects in the scene.

[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
static void OnLoad()
{
    Debug.Log("Create Singletons");
}

CreateAssetMenu: Add an option to Assets/Create for creating a ScriptableObject.

[CreateAssetMenu(menuName = "My ScriptableObject", order = 100)]
public class MyScriptableObject : ScriptableObject
{
}

Preserve: Preserves a members name when converting to bytecode. Useful if referencing members through reflection.

[Preserve]
static void Boink()
{
    Debug.Log("Boink");
}

CustomGridBrush: "define the class as a grid brush and to make it available in the palette window."

[CustomGridBrush(true, true, true, "Default Brush")]
public class MyBrush : GridBrush
{
}

BeforeRenderOrder: "Use this BeforeRenderOrderAttribute when you need to specify a custom callback order for Application.onBeforeRender."

SharedBetweenAnimators: "...an attribute that specify that this StateMachineBehaviour should be instantiate only once and shared among all Animator instance. This attribute reduce the memory footprint for each controller instance."

[SharedBetweenAnimatorsAttribute]
public class AttackBehavior : StateMachineBehaviour
{
}

AssemblyIsEditorAssembly: Can use this rather than place the script in an "Editor" folder.

[assembly:AssemblyIsEditorAssembly]

public class MyEditorClass : MonoBehaviour
{
}

ExcludeFromPreset: "Add this attribute to a class to prevent creating a Preset from the instances of the class."

[ExcludeFromPreset]
public class MyClass : MonoBehaviour
{
    public int score = 10; // Won't be used in Preset?
}

ExcludeFromObjectFactory: "Add this attribute to a class to prevent the class and its inherited classes from being created with ObjectFactory methods."

ExcludeFromCoverage: "Allows you to exclude an Assembly, Class, Constructor, Method or Struct from Coverage."

DefaultExecutionOrder: Probably sets the Script Execution order.

[DefaultExecutionOrder(100)]
public class MyScript : MonoBehaviour
{
}

RejectDragAndDropMaterial: Probably prevents materials being applied through dragging and dropping in the editor.

[RejectDragAndDropMaterial]
public class MyRenderer : MonoBehaviour
{
}

UnityEditor.IconName: Probably allows you to set a scripts icon?

These should be used in scripts that are inside an Editor folder.

MenuItem: Adds a menu to the Editor toolbar.

[MenuItem("MyMenu/Do Something")]
static void DoSomething()
{
    Debug.Log("Doing Something...");
}

InitializeOnLoadMethod: Called after scripts have been compiled.

[InitializeOnLoadMethod]
static void OnProjectLoadedInEditor()
{
    Debug.Log("Project loaded in Unity Editor");
}

DidReloadScripts: Called after scripts have reloaded. Can take an order parameter. Methods with lower orders are called earlier.

using UnityEditor.Callbacks;

[DidReloadScripts(100)]
static void OnScriptsReloaded()
{
    Debug.Log("Reloaded.");
}
#endif

OnOpenAsset: Called when double clicking an asset in the project browser.

using UnityEditor.Callbacks;

[OnOpenAssetAttribute(1)]
static bool step1(int instanceID, int line)
{
    string name = EditorUtility.InstanceIDToObject(instanceID).name;
    Debug.Log("Open Asset step: 1 (" + name + ")");
    return false; // we did not handle the open
}

PostProcessBuild: Called after game has been built.

using UnityEditor.Callbacks;

[PostProcessBuildAttribute(1)]
public static void OnPostprocessBuild(BuildTarget target, string pathToBuiltProject)
{
}

PostProcessScene: Called after scene has been built.

using UnityEditor.Callbacks;

[PostProcessSceneAttribute (2)]
public static void OnPostprocessScene()
{
}