Integrations

Getting Started

NeutrinoParticles Editor lets you create real-time particle effects and export them as source code. A runtime library then loads and renders the exported effects in your project. Below is the list of available integrations for different engines and frameworks.

Choose Your Integration

GPU version requires WebGL2 and uses a separate export pipeline (GPU33 exporter). Currently available for PIXI.js v7.

Notes:

• The JavaScript v1.1 renderer (PIXI.js and Phaser) reconstructs particle geometry on the GPU. PIXI v8/v7 use WebGL2 by default. Phaser 3 defaults to WebGL1 and needs a WebGL2 context — its integration guide shows how to hand it one. Phaser 4 works out of the box on both: it also defaults to WebGL1, but the integration detects the context and renders on WebGL1 too wherever float vertex textures are available.
• The C# v1.2 MonoGame integration requires GraphicsProfile.HiDef — set it on your GraphicsDeviceManager before the first frame (the default template uses Reach). See the MonoGame guide.
• npm integration packages automatically install the core runtime as a dependency. NuGet packages do the same.
• MonoGame: DirectX for Windows/Xbox desktop, OpenGL for cross-platform (Linux, macOS, mobile).
• GPU integrations require WebGL2. GPU effects use a separate export pipeline (GPU33 exporter) in the same editor.

HDR Bloom Add-on (PIXI & MonoGame)

An optional scene-preserving HDR glow that matches the editor preview — only particle colour above 1.0 glows, the rest of the scene is untouched. It is a rendering add-on on top of an existing integration (no separate export target); render the effect into an HDR scene target, then let the add-on composite the glow.

Bloom is WebGL2-only on PIXI and requires GraphicsProfile.HiDef on MonoGame. Match the bloom backend to your runtime integration (PIXI v7/v8, MonoGame DX/GL).

What You Get After Export

When you export an effect from the editor, you get source files to include in your project. Each export target produces a different output:

JavaScript export:

MyEffect.js        ← JS module with the effect model

Import as an ES6 module or load dynamically via XHR/fetch. The loading method affects initialization code — see each integration's README for details.

C# export:

MyEffect.cs        ← C# class with the effect model

Add the file to your project.

GPU33 export:

my_effect.shader   ← GPU shader with the effect model
textures/
    spark.png      ← effect textures

Loaded at runtime via fetch/XHR.

CPU or GPU?

• CPU — works everywhere (any browser, any platform). Available for all supported engines and frameworks.
• GPU — Total GPU Acceleration. Both simulation and rendering run entirely on the GPU. Requires WebGL2. Currently available for PIXI.js v7 and pure WebGL2.
• CPU and GPU are completely separate pipelines. Same editor, but a separate exporter (GPU33), separate packages. CPU effects do not work in GPU runtime and vice versa.
• Which one to choose? If your engine has a GPU integration — try GPU first for best performance. Otherwise, use CPU.
• More about GPU technology: Total GPU Acceleration.

What Is an Effect Format?

The effect format is the version of exported data. The runtime package must match the format in which the effect was exported.

• The format is set in the editor's Export Settings (e.g. “JavaScript v1.1”, “C# v1.2”, “GPU33 v1.0”). See the “Export target in Editor” column in the table above.
• For new projects — always use the latest: JS v1.1, CS v1.2, GPU33 v1.0.
• For existing projects with already exported effects — use the package that matches the format of those effects. You can re-export effects to a different format by changing Export Settings.

Migrating From Old Packages

If you were using old package names or repositories, here is the migration table:

Older Formats / Legacy

These packages are for existing projects whose effects were exported in an older format. New projects should use the latest packages in the table above.

JavaScript v1.0 packages

C# MonoGame packages (older formats)

Advanced / Custom Integrations

• Pure WebGL2 (GPU) — render GPU effects without a game framework: npm i @neutrinoparticles/gpu33-v1.0-reference @neutrinoparticles/gpu33-v1.0-wasm. See npm package for details.
• Custom engine integration — NeutrinoParticles can be integrated into any engine. Request an integration.

Upcoming Integrations

• Unity (in development)
• Cocos Creator GPU (planned)
• GDevelop GPU (planned)
• PIXI.js v8 GPU (planned)