A Unity-like editor for shipping PlayStation 1 games.

Quick start

1. 1
   Download Mipsync Hub

   Install the Hub, then install the latest editor release from the Installs screen.

2. 2
   Create a project

   Use the Hub to create a project, or add an existing project folder.

3. 3
   Build a scene

   Create objects from the Hierarchy, drag assets from the Project window, and edit components in the Inspector.

4. 4
   Write Mips# scripts

   Open scripts in VS Code or Cursor. The Mips# extension provides highlighting, completion, hover, definition, and diagnostics.

5. 5
   Play, build, and test

   Use Play Mode for editor testing, then export PS1 or PC Native builds from the Build menu.

Editor workflow

Command Platform & CLI

MipsyncCLI exposes the running editor to terminals and coding agents without replacing the visual workflow. Open a project normally, then run mipsync commands from that project directory. Authoring changes execute on the editor main thread and appear immediately in the Scene View, Hierarchy, and Inspector.

mipsync help
mipsync search "create and place an object"
mipsync describe entity.create
mipsync entity create Crate --primitive cube --x 2 --y 1 --z -3
mipsync entity transform Crate --ry 45
mipsync material create assets/materials/Red.nmat 0.8 0.1 0.1
mipsync material apply Crate assets/materials/Red.nmat
mipsync scene save
mipsync runtime play

Designed for humans and agents

Asset pipeline

The Project window manages the files that become game data. Asset previews and drag-and-drop behavior are designed to feel close to Unity while still targeting PS1 constraints.

Mips# basics

Mips# is a component scripting language shaped like a practical Unity C# subset. It compiles to deterministic bytecode used by both editor play mode and PS1 export.

class Rotator : MipsBehaviour
{
    public float degreesPerSecond = 90.0;

    void Start()
    {
        Log.Info("ready");
    }

    void Update()
    {
        transform.rotation.y = transform.rotation.y
            + degreesPerSecond * Time.deltaTime;
    }
}

Common lifecycle and APIs

Arrays and coroutines

Mips# supports fixed gameplay-friendly arrays and coroutine-style waiting. Use them for simple lists, scripted timing, UI flows, and staged events.

class IntroSequence : MipsBehaviour
{
    public string[] messages = {
        "Welcome",
        "Press Space"
    };

    void Start()
    {
        StartCoroutine(ShowMessages());
    }

    IEnumerator ShowMessages()
    {
        for (int i = 0; i < messages.Length; i = i + 1) {
            Log.Info(messages[i]);
            yield return WaitForSeconds(1.0);
        }
    }
}

Animation and Animator

The Animation window edits transform keys on an infinite-style timeline: the last key is the clip end. Double-click a .nanim file to open it. When an animation clip is created for an object, the editor ensures an Animator and controller exist so the clip can be driven from the Animator graph.

class CharacterAnimation : MipsBehaviour
{
    public Animator animator;

    void Update()
    {
        float speed = 0.0;
        if (Input.GetKey("W")) speed = 1.0;

        animator.SetFloat("Speed", speed);
        if (Input.GetKeyDown("Space"))
            animator.SetTrigger("Jump");
    }
}

UI system

UI uses Canvas-based elements with RectTransform-like editing. Image and Button elements can keep source aspect ratio, and Hierarchy drag-and-drop controls canvas draw order.

Audio

AudioSource components can be created from the Hierarchy context menu, Add Component, or by dragging an audio file into the Hierarchy. Audio clips can be controlled from Mips# and exported for PS1 playback.

class MusicPlayer : MipsBehaviour
{
    public AudioSource source;

    void Start()
    {
        source.loop = true;
        source.volume = 0.8;
        source.Play();
    }

    void Update()
    {
        if (Input.GetKeyDown("M"))
            source.mute = !source.mute;
    }
}

Post Process Volume and skybox

Fog settings live on Post Process Volume objects. Volumes also expose color grading, vignette, and HDRI skybox settings.

Build for PlayStation 1

The PS1 pipeline analyzes the scene, converts assets, compiles runtime code, and emits a disc image. The output is intended to be launched from the generated .cue file in DuckStation or other compatible environments.

1. Open Build → Build Settings.
2. Add your startup scene to Scenes In Build.
3. Choose Build PS1 or Build and Run.
4. Open the output folder and launch the generated .cue.

Builds/PS1/MyGame/
├─ ps1_src/
├─ generated/
└─ out/
   ├─ PSX.EXE
   ├─ game.cue
   ├─ game.bin
   └─ SYSTEM.CNF

PC Native build

PC Native build is available from the Build menu for quick desktop testing and distribution. It packages the selected project into a Windows executable output under Builds/Windows/<Product>/.

Practical limits

Mipsync is actively evolving. The editor aims for a familiar Unity-like workflow, but the runtime still respects PS1-era limits: low memory, limited texture formats, fixed-point-ish rendering expectations, strict asset budgets, and careful draw ordering.

• Keep PS1 scenes small and test exported builds frequently.
• Prefer compact textures, simple meshes, and deterministic scripts.
• Use Mips# engine APIs instead of general-purpose C#/.NET patterns.
• For audio, launch PS1 disc output from the .cue file so streamed assets are available.