# AI-Powered Particle Systems in Unity: The ParticleSystem Extension

Let AI agents read and modify all 24 ParticleSystem modules in Unity. Create fire, smoke, magic effects and more with natural language prompts.

_Last updated: 2026-03-24_

Unity's ParticleSystem is one of the most powerful — and most complex — components in the engine. With 24 separate modules, hundreds of parameters, and deeply nested settings, configuring a particle effect by hand means clicking through endless inspector panels. What if you could just tell an AI "make fire particles that fade from orange to transparent" and have it done in seconds? That is exactly what the Unity-AI-ParticleSystem extension enables.

[Media: Fire particles created and configured by AI using the ParticleSystem extension]

## What Is Unity-AI-ParticleSystem?

Unity-AI-ParticleSystem is an extension for AI Game Developer that adds two MCP tools — particle-system-get and particle-system-modify — giving AI agents full read and write access to every ParticleSystem module in your Unity project. It works with any MCP-compatible AI client: Claude Code, VS Code Copilot, Cursor, Windsurf, and more.

## Two Tools, Full Coverage

The extension exposes just two MCP tools, but they cover everything. The get tool reads the current state of any ParticleSystem, and the modify tool applies partial updates — only changing the properties you specify while leaving everything else untouched.

### particle-system-get

Retrieves the full state of a ParticleSystem including playback status (isPlaying, isPaused, particleCount) and any combination of its 24 modules. You can request individual modules or use the includeAll flag to get everything at once. Deep serialization mode recursively expands nested objects for complete inspection.

```json
{
  "tool": "particle-system-get",
  "input": {
    "gameObjectRef": { "path": "/Effects/Fire" },
    "includeMain": true,
    "includeEmission": true,
    "includeColorOverLifetime": true
  }
}
```

### particle-system-modify

Applies partial updates to any module. Only the properties you include in the request are changed — everything else stays as-is. The tool returns detailed modification logs so the AI knows exactly what was updated.

```json
{
  "tool": "particle-system-modify",
  "input": {
    "gameObjectRef": { "path": "/Effects/Fire" },
    "main": [
      { "memberPath": "duration", "value": 5.0 },
      { "memberPath": "startLifetime.constant", "value": 2.0 },
      { "memberPath": "loop", "value": true }
    ],
    "emission": [
      { "memberPath": "rateOverTime.constant", "value": 50 }
    ]
  }
}
```

## All 24 Modules Supported

The extension covers every single ParticleSystem module available in Unity. The AI can read and modify any of them:

- Main — duration, start lifetime, start speed, start size, start color, gravity, simulation space, loop
- Emission — rate over time, rate over distance, bursts
- Shape — shape type, radius, angle, arc, position, rotation, scale
- Velocity Over Lifetime — linear and orbital velocity curves
- Limit Velocity Over Lifetime — speed limits and damping
- Color Over Lifetime — gradient-based color animation
- Color By Speed — color mapped to particle speed
- Size Over Lifetime — size curves over particle lifetime
- Size By Speed — size mapped to particle speed
- Rotation Over Lifetime — angular velocity curves
- Noise — turbulence and Perlin noise fields
- Collision — world and plane collision settings
- Trails — particle trail rendering
- Renderer — material, mesh, render mode, sorting
- Plus: Force Over Lifetime, External Forces, Inherit Velocity, Lifetime By Emitter Speed, Rotation By Speed, Trigger, Sub Emitters, Texture Sheet Animation, Lights, Custom Data

## Real-World Usage: What You Can Ask the AI

Because the AI has full access to every ParticleSystem parameter, you can make requests in plain English and the AI figures out which modules and properties to change:

- "Create a campfire effect with orange-to-red particles that rise and fade out"
- "Make the smoke particles bigger and slower, with more turbulence"
- "Add collision so sparks bounce off the ground"
- "Enable trails on the magic projectile particles"
- "Double the emission rate and make particles loop continuously"
- "Change the shape from cone to sphere and increase the radius"

## Installation

The extension requires AI Game Developer (Unity-MCP) to be installed first. Once that is set up, add the ParticleSystem extension via OpenUPM or the .unitypackage installer.

### Option A: OpenUPM (Recommended)

```bash
openupm add com.ivanmurzak.unity.mcp.particlesystem
```

### Option B: Unity Package Installer

Download the AI-ParticleSystem-Installer.unitypackage from the GitHub Releases page at github.com/IvanMurzak/Unity-AI-ParticleSystem/releases and import it into your Unity project via Assets > Import Package > Custom Package.

## How It Works Under the Hood

Unity ParticleSystem modules are C# structs, not classes — which means they cannot be modified through simple reflection. The extension uses ReflectorNet to box each module, apply modifications via serialized member diffs, and then write the modified value back. All Unity API calls are dispatched to the main thread, and the editor windows are repainted after every modification so you see changes instantly.

```csharp
// The extension registers tools via attributes — Unity-MCP discovers them automatically
[AiToolType]
public partial class Tool_ParticleSystem
{
    [AiTool("particle-system-get", Description = "Get ParticleSystem data")]
    public async Task<string> GetParticleSystem(
        GameObjectRef gameObjectRef,
        bool includeMain = false,
        bool includeEmission = false,
        bool includeShape = false,
        // ... flags for all 24 modules
        bool includeAll = false,
        bool deepSerialization = true)
    {
        // Serializes requested modules and returns structured JSON
    }
}
```

## Compatibility

- Unity 2022.3 or newer
- Requires AI Game Developer (Unity-MCP) v0.60.0+
- Works with any MCP client: Claude Code, VS Code Copilot, Cursor, Windsurf, Continue
- Tested on Unity 2022.3, 2023.2, and Unity 6 (6000.3)

## Get Started

Install AI Game Developer, add the ParticleSystem extension, and start describing the effects you want. The AI handles the rest. Check the quickstart guide at ai-game.dev/docs/quickstart for the full setup walkthrough, or grab the plugin from the download page at ai-game.dev/download.

- Unity-AI-ParticleSystem: github.com/IvanMurzak/Unity-AI-ParticleSystem
- AI Game Developer (Unity-MCP): github.com/IvanMurzak/Unity-MCP
- AI Animation Extension: github.com/IvanMurzak/Unity-AI-Animation
- AI ProBuilder Extension: github.com/IvanMurzak/Unity-AI-ProBuilder
- Download: ai-game.dev/download
- Quickstart guide: ai-game.dev/docs/quickstart
- Setup tutorial: ai-game.dev/blog/claude-code-unity-tutorial

---

Source (HTML): https://ai-game.dev/blog/unity-ai-particle-system-extension