react-confetti vs canvas-confetti vs vue-confetti
JavaScript Confetti Libraries Comparison
1 Year
react-confetticanvas-confettivue-confettiSimilar Packages:
What's JavaScript Confetti Libraries?

These libraries are designed to create confetti effects in web applications, enhancing user interaction and engagement. They provide developers with tools to easily implement celebratory animations that can be triggered by various events, such as form submissions or achievements. Each library is tailored for different frameworks, ensuring seamless integration and optimal performance within their respective ecosystems.

Package Weekly Downloads Trend
Github Stars Ranking
Stat Detail
Package
Downloads
Stars
Size
Issues
Publish
License
react-confetti2,312,6141,568216 kB82 months agoMIT
canvas-confetti665,14110,93092.3 kB3410 months agoISC
vue-confetti13,38923649.5 kB19-MIT
Feature Comparison: react-confetti vs canvas-confetti vs vue-confetti

Integration

  • react-confetti:

    react-confetti is built specifically for React applications, leveraging React's component-based architecture. It offers a declarative approach to rendering confetti, making it easy to integrate into existing React components and manage state changes effectively.

  • canvas-confetti:

    canvas-confetti is a standalone library that can be used in any JavaScript project without dependencies on frameworks. It allows for easy integration into any HTML page or JavaScript application, making it versatile for various use cases.

  • vue-confetti:

    vue-confetti is designed for Vue.js applications, utilizing Vue's reactivity system. It allows developers to trigger confetti effects directly from Vue methods and lifecycle hooks, ensuring a smooth integration with Vue's data-driven approach.

Performance

  • react-confetti:

    react-confetti is efficient in rendering by using React's virtual DOM. It minimizes unnecessary re-renders, ensuring that the confetti effect performs well even in complex React applications with multiple components.

  • canvas-confetti:

    canvas-confetti is optimized for performance, using the HTML5 canvas for rendering. This allows for smooth animations even with a large number of particles, making it suitable for high-impact visual effects without significant performance overhead.

  • vue-confetti:

    vue-confetti takes advantage of Vue's optimized rendering system, ensuring that confetti animations are rendered efficiently. It minimizes DOM manipulations and leverages Vue's reactivity to trigger animations only when necessary.

Customization

  • react-confetti:

    react-confetti provides props for customization, allowing developers to easily adjust the number of particles, colors, and animation duration. This makes it simple to create a personalized confetti effect that fits the application's design.

  • canvas-confetti:

    canvas-confetti offers extensive customization options, allowing developers to specify colors, shapes, and sizes of confetti particles. This flexibility enables the creation of unique visual effects tailored to the application's theme or branding.

  • vue-confetti:

    vue-confetti allows for customization through props, enabling developers to control the appearance and behavior of the confetti. This includes options for particle colors, sizes, and animation settings, making it easy to adapt to different use cases.

Ease of Use

  • react-confetti:

    react-confetti is designed with React developers in mind, providing a simple API that integrates seamlessly with React's component structure. This makes it easy to use for those familiar with React, as it follows common React patterns.

  • canvas-confetti:

    canvas-confetti is straightforward to implement with minimal setup required. Developers can quickly add confetti effects to their projects with just a few lines of code, making it accessible for beginners and experienced developers alike.

  • vue-confetti:

    vue-confetti is user-friendly for Vue developers, offering a clear and concise API that fits well within Vue's ecosystem. Its integration with Vue's reactive data model makes it intuitive to use for triggering animations based on state changes.

Event Handling

  • react-confetti:

    react-confetti can be easily triggered in response to React events, such as button clicks or state changes, allowing developers to create dynamic and engaging user experiences that celebrate user actions within the application.

  • canvas-confetti:

    canvas-confetti allows developers to trigger confetti effects on any event, such as clicks or form submissions, providing flexibility in how and when animations are displayed. This makes it suitable for a wide range of interactive scenarios.

  • vue-confetti:

    vue-confetti enables developers to trigger confetti effects based on Vue events, such as method calls or lifecycle hooks. This integration ensures that confetti animations can be seamlessly incorporated into the user flow of Vue applications.

How to Choose: react-confetti vs canvas-confetti vs vue-confetti
  • react-confetti:

    Opt for react-confetti if you are developing a React application and want a library that integrates smoothly with React's component lifecycle. It allows you to easily trigger confetti effects based on React state changes, making it a great choice for interactive UIs where you want to celebrate user actions.

  • canvas-confetti:

    Choose canvas-confetti if you need a lightweight, framework-agnostic solution that utilizes the HTML5 canvas element for high-performance animations. It is ideal for projects where you want full control over the animation and rendering process without being tied to a specific framework.

  • vue-confetti:

    Select vue-confetti if you are building a Vue.js application and prefer a library that is designed specifically for Vue's reactive data model. It provides a simple API to trigger confetti effects in response to Vue events, ensuring a seamless experience for Vue developers.

README for react-confetti

react-confetti

Confetti without the cleanup. Demo

Build Status npm npm bundle size npm type definitions

Based on a pen by @Gthibaud: https://codepen.io/Gthibaud/pen/ENzXbp

demogif

Install

npm install react-confetti

Use

width and height props are recommended. They will default to the initial window dimensions, but will not respond to resize events. It is recommended to provide the dimensions yourself. Here is an example using a hook:

import React from 'react'
import { useWindowSize } from 'react-use'
import Confetti from 'react-confetti'

export default () => {
  const { width, height } = useWindowSize()
  return (
    <Confetti
      width={width}
      height={height}
    />
  )
}

Props

| Property | Type | Default | Description | | ---------------- | --------------------- | --- | --- | | width | Number | window.innerWidth \|\| 300 | Width of the <canvas> element. | | height | Number | window.innerHeight \|\| 200 | Height of the <canvas> element. | | numberOfPieces | Number | 200 | Number of confetti pieces at one time. | | confettiSource | { x: Number, y: Number, w: Number, h: Number } | {x: 0, y: 0, w: canvas.width, h:0} | Rectangle where the confetti should spawn. Default is across the top. | | friction | Number | 0.99 | | | wind | Number | 0 | | | gravity | Number | 0.1 | | | initialVelocityX | Number \| { min: Number, max: Number } | 4 | Range of values between which confetti is emitted horizontally, positive numbers being rightward, and negative numbers being leftward. Giving a number x is equivalent to giving a range { min: -x, max: x }. | | initialVelocityY | Number \| { min: Number, max: Number } | 10 | Range of values between which confetti is emitted vertically, positive numbers being downward, and negative numbers being upward. Giving a number y is equivalent to giving a range { min: -y, max: 0 }.| | colors | String[] | ['#f44336'
'#e91e63'
'#9c27b0'
'#673ab7'
'#3f51b5'
'#2196f3'
'#03a9f4'
'#00bcd4'
'#009688'
'#4CAF50'
'#8BC34A'
'#CDDC39'
'#FFEB3B'
'#FFC107'
'#FF9800'
'#FF5722'
'#795548']
| All available Colors for the confetti pieces. | | opacity | Number | 1.0 | | | recycle | Bool | true | Keep spawning confetti after numberOfPieces pieces have been shown. | | run | Bool | true | Run the animation loop | | frameRate | Number \| undefined | undefined | The capped frame rate of the animation. | | tweenDuration | Number | 5000 | How fast the confetti is added | | tweenFunction | (currentTime: number, currentValue: number, targetValue: number, duration: number, s?: number) => number | easeInOutQuad | See tween-functions | | drawShape | (context: CanvasRenderingContext2D) => void | undefined | See below | | onConfettiComplete | (confetti: Confetti) => void | undefined | Called when all confetti has fallen off-canvas. |

drawShape()

Draw a custom shape for a particle. If not provided, defaults to a random selection of a square, circle or strip confetto. The function is called with the canvas context as a parameter and the Particle as the this context.

For example, to draw all spirals:

<Confetti
  drawShape={ctx => {
    ctx.beginPath()
    for(let i = 0; i < 22; i++) {
      const angle = 0.35 * i
      const x = (0.2 + (1.5 * angle)) * Math.cos(angle)
      const y = (0.2 + (1.5 * angle)) * Math.sin(angle)
      ctx.lineTo(x, y)
    }
    ctx.stroke()
    ctx.closePath()
  }}
/>