Publishing#

Publishing uploads one Visual Script class and uses its attributes to create or update a Registry listing. Start the upload from the script's context menu in Unity.

Publishing requires a free account and a Unity Access Token on the current machine. Complete the Unity Access Token setup first; otherwise, the upload dialog offers to open the sign-in window.

1. Write the node#

A publishable package contains one class in one C# file. The class must use one of these extension points:

Base	Publishes as
`Instruction`	An Instruction
`Condition`	A Condition
`Trigger`	A Trigger
`IType` implementation	A Signal

Extending covers each extension point. For publishing, the class attributes define the listing:

using System;
using UnityEngine;
using VisualScript.Icons;
using VisualScript.Runtime;

[Title("Log Text")]
[Description("Prints text in the Console")]
[Category("Debug/Log Text")]

[Parameter("Text", "The text to print")]
[Keywords("Print", "Console", "Debug")]

[Version(1, 0, 0)]
[Image(typeof(IconSpeech), ColorTheme.Type.TextLight)]

[Serializable]
public class InstructionAcmeLogText : Instruction
{
    [SerializeField] private GetString m_Text = new GetString();

    protected override string GetTitle(GameObject source) => $"Log {this.m_Text}";

    protected override Awaitable Run(Args args)
    {
        Debug.Log(this.m_Text.Get(args));
        return Done;
    }
}

InstructionAcmeLogText publishes as an Instruction. Its [Title], [Description], [Parameter], and related attributes provide the metadata that the Registry displays and searches.

2. Upload it#

Select the .cs file in Unity's Project window.
Right-click and choose Visual Script → Upload to Registry.

A progress bar appears. When the upload completes, the dialog reports New package has been successfully created or Package has been successfully updated and provides a button that opens the listing.

A successful upload moves the file

After a successful upload, Unity moves the script into Assets/Visual Script/<kind> and renames it after the package identifier. The Registry uses this location and name to track the package and compare its local and published versions.

What gets sent#

The upload includes the script and the metadata declared by its attributes:

Attribute	Becomes
`[Title]`	The package name.
`[Description]`	The summary shown in search results.
`[Category]`	Where it sits in the dropdown after installation.
`[Parameter]`	The documented parameters.
`[Keywords]`	Search terms.
`[Note]`	Caveats shown on the listing.
`[Dependency]`	What the node requires, with a link.
`[Version]`	The published version.
`[Documentation]`	The listing's Docs button.
`[MadeWithAI]`	The AI flag shown on the listing.
`[Get]` / `[Set]`	Whether a Signal reads, writes, or both.

The upload doesn't include other files, scenes, or project settings.

A package with only [Title] can publish, but its search result contains little information. Add the attributes that explain its behavior, parameters, and requirements.

Write for the person searching

Registry search matches [Description] and [Keywords]. Describe the task in the terms a developer would search for: Rotates an object toward another over time is more specific than Custom rotation helper.

What can't be uploaded#

If the upload is rejected, the dialog identifies the reason:

Situation	Why
This script is not supported for Visual Script	The class doesn't subclass `Instruction`, `Condition`, `Trigger`, or implement `IType`.
Package in this folder are protected and cannot be uploaded	The file lives under `Packages/`. If you own the code, move a copy into `Assets/` before uploading.
You are not authenticated	You're signed out on this machine. See Unity Access Token.

Modules don't use this upload flow. The Visual Script team publishes and maintains them as packages.

Before you press upload#

Published means public

Open the file and check for content that shouldn't be published:

Hard-coded paths from your machine.
References to types that only exist in your project.
API keys, private endpoints, or credentials.
Leftover debug logging.
A class name that could collide with another package's.

Prefix the class name with a short vendor tag, such as InstructionAcmeSpawnWave, because class names must be unique within a project.

Before sharing the listing, install the published node in an empty project that contains only Visual Script and the node's declared dependencies. Confirm that it compiles and performs the documented behavior.

After publishing#

Open the listing and verify its description, parameters, and dependencies.
Add it to a list when it belongs with related packages.
Share the link from the documentation, devlog, or tutorial that uses the package.
Ship improvements by incrementing [Version] and uploading again. See Updating.

Where to go next#

Updating — version and maintain the published package.
Lists — bundle related nodes, including integrations with other Asset Store tools.
Conventions — inspect the complete attribute reference.