nuke-particle-blinkscript

nuke-particle-blinkscript

Version: 1.0.1 Last Updated: 2026-03-11 Dependencies: NukeX 16+ (for ParticleBlinkScript node) OR Nuke 13+ (for procedural BlinkScript approach)

---

Two Approaches - Choose Based on What You Have

Approach	Nuke Version	Node Used	What You Get
Procedural BlinkScript	Nuke 13+, any license	BlinkScript (ImageComputationKernel)	GPU math-only particles - no sim, no caching, real-time
ParticleBlinkScript node	NukeX 16+ only	ParticleBlinkScript	Real particle physics, Foundry gadget library, Blink API

Decision rule:

• Need real physics (gravity, collisions, inter-particle forces)? -> ParticleBlinkScript node (NukeX 16+)
• Need atmospheric effects (snow, embers, sparks, dust)? -> Procedural BlinkScript (any Nuke, faster, easier)
• Don't have NukeX 16+? -> Procedural BlinkScript is your only option

---

Approach 1: Procedural BlinkScript (Any Nuke)

No particle node required. Mathematically generates particle positions per-frame using noise, sin/cos, and pseudo-random seeds. GPU-accelerated, zero caching, compositing-friendly.

Why this approach:

• No simulation time - renders immediately
• No caching - always current frame
• Works in any Nuke license
• Easily keyframable and art-directable

Core Pattern: Procedural Particles

kernel ProceduralParticles : ImageComputationKernel<ePixelWise>
{
  Image<eRead, eAccessPoint, eEdgeClamped> src;
  Image<eWrite, eAccessPoint> dst;

  param:
    float time;           // Wire to frame/fps expression
    float count;          // Number of particles
    float size;           // Particle radius in pixels
    float4 color;         // Particle color (creates color picker)
    float speed;          // Fall/drift speed
    float spread;         // Horizontal spread

  local:
    int imgWidth;
    int imgHeight;
    float invWidth;
    float invHeight;

  void init() {
    imgWidth = dst.bounds.width();
    imgHeight = dst.bounds.height();
    invWidth = 1.0f / (float)imgWidth;
    invHeight = 1.0f / (float)imgHeight;
  }

  // Deterministic pseudo-random from seed
  float rand(float seed) {
    return fmod(sin(seed * 127.1f + 311.7f) * 43758.5453f, 1.0f);
  }

  void process(int2 pos) {
    float4 output = src();
    float px = (float)pos.x;
    float py = (float)pos.y;

    for (int i = 0; i < (int)count; i++) {
      float fi = (float)i;

      // Each particle gets a unique seed-based starting position
      float startX = rand(fi * 1.7f) * (float)imgWidth;
      float lane = rand(fi * 3.1f) * spread;  // Horizontal drift

      // Y position driven by time (wraps when off screen)
      float yOffset = fmod(rand(fi * 2.3f) + time * speed * (0.5f + rand(fi * 0.9f) * 0.5f), 1.0f);
      float particleX = startX + sin(time * 0.5f + fi) * lane;
      float particleY = yOffset * (float)imgHeight;

      // Wrap particle back to top when it exits bottom
      if (particleY > (float)imgHeight) {
        particleY = fmod(particleY, (float)imgHeight);
      }

      // Distance test (circular particle)
      float dx = px - particleX;
      float dy = py - particleY;
      float dist = sqrt(dx * dx + dy * dy);

      if (dist < size) {
        // Soft edge fade
        float alpha = (1.0f - dist / size) * color.w;
        output.x = output.x * (1.0f - alpha) + color.x * alpha;
        output.y = output.y * (1.0f - alpha) + color.y * alpha;
        output.z = output.z * (1.0f - alpha) + color.z * alpha;
      }
    }

    dst() = output;
  }
};