The VortexSystem initializer parameters are:

• tags ([String], required) should be the names of one or more views you're passing into a VortexView to render this particle system. This string array might only be some of the views you're passing in – you might have a secondary system that uses different tags, for example.
• secondarySystems ([VortexSystem], defaults to an empty array) should contain all the secondary particle systems that should be attached to this primary emitter.
• spawnOccasion (SpawnOccasion, defaults to .onBirth) determines when this secondary system should be created. Ignored if this is your primary particle system.
• position (SIMD2<Double>, defaults to [0.5, 0.5]) determines the center position of this particle system.
• shape (Shape, defaults to .point) determines the bounds of where particles are emitted.
• birthRate (Double, defaults to 100) determines how many particles are created every second.
• emissionLimit (Int?, defaults to nil) determines how many total particles this system should create before it is spent.
• emissionDuration (Double, defaults to 1) determines how long this particle system should emit for before pausing. Does nothing if idleDuration is set to 0, because there is no pause between emissions.
• idleDuration (Double, defaults to 0) determines how much time should elapsed between emission bursts.
• burstCount (Int, defaults to 100) determines how many particles should be emitted when you call burst() on the VortexProxy for this particle system.
• burstCountVariation (Int, defaults to 0) determines how much variation to allow in bursts, +/- the base burstCount value.
• lifespan (TimeInterval, defaults to 1) determines how many seconds particles should live for before being destroyed.
• lifeSpanVariation (TimeInterval, defaults to 0) determines how much variation to allow in particle lifespan, +/- the base lifespan value.
• speed (Double, defaults to 1) determines how fast particles should be launched. A speed of 1 should allow a particle to move from one of the screen to another in 1 second.
• speedVariation (Double, defaults to 0) determines how much variation to allow in particle speed, +/- the base speed value.
• angle (Angle, defaults to .zero) determines the direction particles should be launched, where 0 is directly up.
• angleRange (Angle, defaults to .zero) determines how much variation to allow in particle launch direction, +/- the base angle value.
• acceleration (SIMD2<Double>, defaults to [0, 0]) determines how much to adjust particle speed over time. Positive X values make particles move to the right as if wind were blowing, and positive Y values make particles fall downwards as if affected by gravity.
• attractionCenter (SIMD2<Double>?, defaults to nil) makes particles move towards or away from a particular location. This should be specified in screen coordinates.
• attractionStrength (Double, defaults to 0) determines how quickly to move towards or away from the point specified in attractionCenter.
• dampingFactor (Double, defaults to 0) determines how quickly particles should lose momentum over time.
• angularSpeed (SIMD3<Double>, defaults to [0, 0, 0]) determines how quickly particles should spin in X, Y, and Z axes. Note: watchOS supports only Z rotation.
• angularSpeedVariation (SIMD3<Double>, defaults to [0, 0, 0] determines how much variation to allow in particle rotation speed, +/- the base angularSpeed value.
• colors (ColorMode, defaults to .single(.white)) determines how particles should be colored over time.
• size (Double, defaults to 1) determines how big particles should be compared to their source view, where 1 is 100% the original size.
• sizeVariation (Double, defaults to 0) determines how much variation to allow in initial particle size, +/- the base size value.
• sizeMultiplierAtDeath (Double, defaults to 1) determines how much bigger or smaller particles should be by the time they are destroyed. A value of 1 means the size won't change, whereas a value of 0.5 means particles will be half whatever their initial size was.
• stretchFactor (Double, defaults to 1) determines whether particles should be stretched based on their movement speed. A value of 1 means no stretch is applied.

Most of those are built-in types, but two deserve extra explanation.

First, Shape allows you to emit particles from a range of shapes: a single point, a straight line, a circle, and more. For example, this emits particles in a horizontal line across the available space:

.box(width: 1, height: 0)

And this creates particles in an ellipse half the size of the available space:

.ellipse(radius: 0.5)

Second, ColorMode gives you fine-grained control over how colors work with Vortex. The default value for new particle system is .single(.white), which means all particles are created white. However, you can create particles in a range of static colors like this:

.random(.red, .white, .blue)

You can also create color ramps, where particles change their colors as they age. For example, this makes particles start white, then turn red, then fade out:

.ramp(.white, .red, .clear)

For maximum control, you can use random ramps, where each particle system picks a different ramp for particles to use as they age. For example, this makes some particles start red then fade out, and others start blue then fade out:

.randomRamp([.red, .clear], [.blue, .clear])

Because Vortex uses these color modes to dynamically recolor your particles, it's a good idea to specify .fill(.white) when using SwiftUI's native shapes such as Rectangle and Circle to ensure the particles can be recolored correctly.

The .confetti preset creates a confetti effect where views fly shoot out when a burst happens. This means using a VortexViewReader to gain access to the Vortex proxy, like this:

VortexViewReader { proxy in
    VortexView(.confetti) {
        Rectangle()
            .fill(.white)
            .frame(width: 16, height: 16)
            .tag("square")
        
        Circle()
            .fill(.white)
            .frame(width: 16)
            .tag("circle")
    }
    
    Button("Burst", action: proxy.burst)
}

The .fire preset creates a flame effect. This works better when your particles have a soft edge, and use a .plusLighter blend mode, like this:

VortexView(.fire) {
    Circle()
        .fill(.white)
        .frame(width: 32)
        .blur(radius: 3)
        .blendMode(.plusLighter)
        .tag("circle")
}

The .fireflies preset creates glowing yellow dots that zoom up and fade out. This works better when your particles have a soft edge, like this:

VortexView(.fireflies) {
    Circle()
        .fill(.white)
        .frame(width: 32)
        .blur(radius: 3)
        .blendMode(.plusLighter)
        .tag("circle")
}

The .fireworks preset creates a three-stage particle effect to simulate exploding fireworks. Each firework is a particle, and also launches new "spark" particles as it flies upwards. When the firework particle is destroyed, it creates an explosion effect in a range of colors.

VortexView(.fireworks) {
    Circle()
        .fill(.white)
        .frame(width: 32)
        .blur(radius: 5)
        .blendMode(.plusLighter)
        .tag("circle")
}

The .magic preset creates a simple ring of particles that fly outwards as they fade out. This works best using the "sparkle" image contained in the Assets folder of this repository, but you can use any other image or shape you prefer.

VortexView(.magic) {
    Image(.sparkle)
        .blendMode(.plusLighter)
        .tag("sparkle")
}

The .rain preset creates a rainfall system by stretching your view based on the rain speed:

VortexView(.rain) {
    Circle()
        .fill(.white)
        .frame(width: 32)
        .tag("circle")
}

The .smoke preset creates a dark gray to black smoke effect. This works best when your views are a little larger, and have soft edges:

VortexView(.smoke) {
    Circle()
        .fill(.white)
        .frame(width: 64)
        .blur(radius: 10)
        .tag("circle")
}

The .snow preset creates a falling snow effect. This works best when your views have soft edges, like this:

VortexView(.snow) {
    Circle()
        .fill(.white)
        .frame(width: 24)
        .blur(radius: 5)
        .tag("circle")
}

The .spark preset creates an intermittent spark effect, where sparks fly out for a short time, then pause, then fly out again, etc.

VortexView(.spark) {
    Circle()
        .fill(.white)
        .frame(width: 16)
        .tag("circle")
}

The .splash present contains raindrop splashes, as if rain were hitting the ground. This works best in combination with the .rain preset, like this:

ZStack {
    VortexView(.rain) {
        Circle()
            .fill(.white)
            .frame(width: 32)
            .tag("circle")
    }

    VortexView(.splash) {
        Circle()
            .fill(.white)
            .frame(width: 16, height: 16)
            .tag("circle")
    }
}