Loading
Loading
Loading
mobile footer

Build the Interaction Layer Your Website is Missing.

Browse All EffectsBrowse All EffectsBrowse All EffectsUpgrade to ProUpgrade to ProUpgrade to Pro

70+ effects free, forever. No credit card.

© 2026 Hyperiux. All Rights Reserved.

AI Component CatalogueHey AI, Learn About Us
Platform

Vault

  • Documentation
  • Pricing
  • Blog
  • Community
  • NPM
  • MCP

Categories

  • All Effects
  • WebGL
  • Text
  • Backgrounds
  • Buttons
  • Carousels
  • Scroll
  • Components
  • Navigation
  • Cursor
  • Transitions
  • Loaders

Documents

  • Introduction
  • Installation
  • CLI
  • Dependencies
  • License

Legal

  • License Agreement
  • Terms of Service
  • Privacy Policy
  • Refund Policy
Socials
  • Twitter / X
  • LinkedIn
  • GitHub
  • Instagram
Contact Us
  • hello@hyperiux.com
New effects, in your inbox

Every new drop, plus the occasional behind-the-scenes build. No spam. Unsubscribe anytime.

All Effects
Featured ComponentsText AnimationsAnimated BackgroundsAnimated ButtonsCarousel EffectsScroll EffectsCreative ComponentsNavigationsCursor EffectsTransitionsLoadersWebGL & 3D Effects
Templates
IntroductionInstallationCLIDependenciesLicense
PricingBlogGithubNPMMCP Doc
Home/docs/dependencies

Dependencies

Bring the engine you need. Not the whole garage.

Hyperiux Vault is source-first. Effects are added into your project as editable files, not hidden behind a sealed package.

That matters for dependencies.

A scroll reveal, a magnetic cursor, and a WebGL scene should not carry the same technical weight. Some effects need only React and CSS. Some need GSAP or Motion. Some need Three.js, React Three Fiber, shaders, canvas, and a little respect for the GPU.

Vault keeps dependency requirements visible and scoped to the effect you install.

No surprise engines. No drive-by Three.js.

The Dependency Model

Vault dependencies fall into two groups.

TypeMeaning
Structural requirementsThe base framework, runtime, and styling setup your project needs before using Vault
Peer enginesAnimation, rendering, or utility libraries required by specific effects

Structural requirements are expected across Vault. Peer engines are added only when an effect needs them.

That keeps the project cleaner, the bundle easier to reason about, and the interaction layer easier to own.

Motion should earn its place in the build.

Structural Requirements

Every Vault effect assumes a modern React setup.

RequirementSupported setup
RuntimeNode.js 18.17+ (20+ recommended)
FrameworkReact 18+ or Next.js 14+
WebGL / 3D effectsReact Three Fiber 9, which needs React 19 (Next.js 15+)
Page transitionsEffects built on next-transition-router need the Next.js App Router
StylingTailwind CSS v3 or v4
LanguageTypeScript recommended, modern JavaScript supported
Package managernpm, pnpm, yarn, or bun
Project structureApp Router, Pages Router, or a Vite + React setup

Vault works best in projects that separate server and client behavior clearly.

That is especially important for effects that use:

  • scroll position
  • pointer movement
  • layout measurements
  • animation timelines
  • canvas
  • WebGL
  • browser APIs

If an effect touches the browser directly, it usually needs a client boundary.

TSX
1"use client";

Servers are many things.

They are not GPU theatres.

Peer Engines

Peer engines are libraries used by specific Vault effects.

They are not installed globally for every pattern. They are declared by the effect that needs them.

Interaction layerCommon peer enginesUsed for
Scroll effectsgsap, motionScroll triggers, reveal timing, pinned sections, timeline control
Cursor effectsgsapPointer tracking, magnetic motion, hover trails, inertia
Text animationsgsap, motionLine reveals, character motion, sequencing, masked text
Page transitionsmotionRoute transitions, entry and exit states, layout continuity
WebGL and 3D effectsthree, @react-three/fiber, @react-three/dreiCanvas scenes, 3D objects, shaders, camera movement, WebGL rendering
Backgroundsgsap, motion, three, @react-three/fiberAmbient layers, particles, gradients, canvas motion
Buttons and microinteractionsgsap, motionHover states, press states, magnetic motion, small feedback systems

Not every effect in a category uses every engine listed above.

Check the effect page before installing.

A text reveal should not need a 3D pipeline. A WebGL scene probably will.

That is not bloat. That is choosing the right machine for the trick.

How the CLI Handles Dependencies

When you add an effect with the Hyperiux CLI, the CLI reads the effect manifest.

Terminal
1npx hyperiux add phantom-image-trail

The manifest defines what the effect needs, including:

  • source files
  • utility files
  • styles
  • peer dependencies
  • setup notes
  • client-component requirements
  • browser or rendering assumptions

If a required package is missing from your project, the CLI installs it with the package manager it detects, then writes the effect files.

To see the files and missing packages before anything is installed, do a dry run:

Terminal
1npx hyperiux add phantom-image-trail --dry-run

The point is simple: dependencies should be attached to the effect that uses them.

Not sprayed across your project because one day you might animate something.

Manual Dependency Installation

If you install an effect manually, install only the dependencies listed on that effect page.

Example for a GSAP-based effect:

Terminal
1npm install gsap

Example for a Motion-based effect:

Terminal
1npm install motion

Example for a WebGL or React Three Fiber effect:

Terminal
1npm install three @react-three/fiber @react-three/drei

Use your package manager of choice.

Terminal
1npm install gsap
Terminal
1npm install gsap
Terminal
1npm install gsap

Do not install the entire creative internet just to animate a headline.

Recommended Versions

The effect page or registry manifest is the source of truth.

The example below shows the shape of a typical dependency block, not a universal version policy:

JSON
1{2  "dependencies": {3    "gsap": "^3.15.0",4    "motion": "^12.40.0",5    "three": "^0.182.0",6    "@react-three/fiber": "^9.6.0",7    "@react-three/drei": "^10.7.7"8  }9}

WebGL and 3D effects use React Three Fiber 9 and drei 10, which need React 19. On Next.js, that means Next.js 15 or later. React 18 projects can use the other effects, but not the React Three Fiber ones.

Use the versions listed by the effect you install.

Animation and rendering libraries move. Your lockfile remembers.

Make sure it remembers the right thing.

Motion and Framer Motion

Some older examples may reference framer-motion.

Newer Vault effects may use motion.

Use the package specified by the effect page.

Do not install both unless your project actually needs both.

Two animation libraries in one project can be fine.

Two animation libraries because nobody checked the docs is how bundle weight learns to reproduce.

Bundle Behavior

Vault is designed to keep effects local and modular.

Adding one effect should not make every page pay for every other effect.

Still, source ownership means you are responsible for how the effect is imported, rendered, and bundled inside your app.

To keep things clean:

  • import effects only where they are used
  • avoid global imports for page-specific effects
  • lazy-load heavy WebGL or canvas components
  • keep browser-only code inside client components
  • remove unused dependencies
  • run production builds before judging performance

The install is the beginning.

The bundle is where the truth comes out.

Tree-Shaking

Vault effect files are structured to support clean imports.

That helps bundlers remove unused code, but tree-shaking is not magic.

It depends on:

  • how you import files
  • whether modules have side effects
  • how dependencies are packaged
  • whether code is used globally
  • whether the effect runs on every page
  • your framework and bundler configuration

Prefer direct imports.

TSX
1import PhantomImageTrail from "@/components/effects/phantom-image-trail";

Avoid importing a full local index of effects into a shared layout unless you actually need it there.

Your layout is not a storage unit.

WebGL and Canvas Dependencies

WebGL and canvas effects need extra care.

They may depend on:

  • three
  • @react-three/fiber
  • @react-three/drei
  • shader files
  • texture assets
  • browser APIs
  • device pixel ratio
  • resize observers
  • animation loops

For Next.js, heavy WebGL components often work best with dynamic imports.

TSX
1import dynamic from "next/dynamic";2 3const PhantomImageTrail = dynamic(4  () => import("@/components/effects/phantom-image-trail"),5  { ssr: false }6);

Use this when server rendering does not make sense.

Especially when the component needs window, document, canvas, WebGL, or GPU-backed rendering.

CSS and Tailwind Dependencies

Vault effects may use Tailwind classes for layout, styling, spacing, responsive behavior, and visual states.

For Tailwind v3 projects, make sure Tailwind scans the folder where Vault files are installed.

Example:

TSX
1export default {2  content: [3    "./app/**/*.{ts,tsx}",4    "./pages/**/*.{ts,tsx}",5    "./components/**/*.{ts,tsx}",6    "./src/components/effects/**/*.{ts,tsx}"7  ],8  theme: {9    extend: {}10  },11  plugins: []12};

Tailwind v4 projects may handle configuration differently depending on the setup.

If your project does not use a traditional Tailwind config file, make sure the Vault directory is included through your CSS or project configuration entry point.

If an effect renders but looks broken, check Tailwind content paths first.

It is usually that.

Then check CSS variables. Then check whether you copied the whole effect.Then, briefly, blame yourself.

Performance Impact

Dependencies are not just installation details.

They affect runtime behavior.

Watch for:

  • layout shifts
  • expensive scroll listeners
  • unnecessary re-renders
  • large canvas layers
  • WebGL loops running offscreen
  • multiple heavy effects on one page
  • animation work during route transitions
  • large image and texture assets

Prefer transform-based motion where possible.

Good properties:

CSS
1transform: translate3d(0, 0, 0);2transform: scale3d(1, 1, 1);3transform: rotate3d(0, 1, 0, 15deg);4opacity: 1;

Riskier properties for frequent animation:

  • width
  • height
  • top
  • left
  • margin
  • padding

Move pixels intelligently. Do not ask the browser to rebuild the room every frame. For deeper testing guidance, see Performance Notes.

Reduced Motion

Motion should respect the person watching it.

Effects that include movement should provide a calmer path for users who prefer reduced motion.

That may mean:

  • disabling movement
  • reducing distance
  • shortening transitions
  • removing parallax
  • disabling cursor trails
  • showing content immediately
  • replacing motion with a simple state change

Use the browser preference.

A scoped fallback is safer than applying reduced-motion rules globally across the whole app.

CSS
1@media (prefers-reduced-motion: reduce) {2  .hyperiux-effect,3  .hyperiux-effect * {4    animation-duration: 0.01ms;5    animation-iteration-count: 1;6    transition-duration: 0.01ms;7    scroll-behavior: auto;8  }9}

Use a global selector only if you intentionally want a site-wide reduced-motion policy.

For component-level behavior, check reduced motion in JavaScript when needed.

TSX
1const prefersReducedMotion =2  typeof window !== "undefined" &&3  window.matchMedia("(prefers-reduced-motion: reduce)").matches;

Reduced motion is not the boring version.

It is the considerate version.

For deeper guidance, see Reduced Motion.

Accessibility Impact

Dependencies are not only a bundle concern.

They affect how the interaction behaves.

When adding motion-heavy effects, check that:

  • content remains readable without animation
  • keyboard navigation still works
  • focus states remain visible
  • semantic structure stays intact
  • animation does not block content
  • screen readers can access content in a logical order
  • hover-only behavior has a touch or keyboard fallback

The motion layer should support the page.

It should not hold the content hostage.

For deeper implementation guidance, see Accessibility.

Dependency Troubleshooting

Missing Dependency

Install the package listed by the effect page or CLI output.

Terminal
1npm install gsap

Duplicate Animation Packages

Check whether the project uses both framer-motion and motion.

Keep both only if required.

If not, standardize around the package used by your installed effects.

Tailwind Styles Do Not Apply

Make sure Tailwind scans the Vault directory.

TSX
1content: [2  "./src/components/effects/**/*.{ts,tsx}"3]

For Tailwind v4, check your CSS or project configuration entry point instead of assuming a traditional config file exists.

WebGL Effect Crashes on Load

Check:

  • client component boundary
  • dynamic import setup
  • WebGL browser support
  • texture or shader paths
  • device memory limits
  • missing Three.js dependencies

Effect Works Locally but Fails in Production

Check:

  • lockfile changes
  • dependency versions
  • dynamic imports
  • browser-only code
  • build output
  • minification issues
  • environment-specific paths

Bundle Size Jumped

Check:

  • which effect introduced the dependency
  • whether the effect is imported globally
  • whether a WebGL scene is loaded on every page
  • whether unused effects are still imported
  • whether old dependencies can be removed

Run your bundle analyzer if the project uses one. Guessing is not profiling.

Dependency Rules Worth Keeping

Use these as a final check before shipping.

  • Install only what the effect needs.
  • Use the effect page or registry manifest as the source of truth.
  • Keep heavy effects out of shared layouts unless required.
  • Lazy-load WebGL and canvas when possible.
  • Scope reduced-motion fallbacks where possible.
  • Respect accessibility requirements.
  • Test mobile behavior.
  • Remove unused dependencies.
  • Check production builds.

Small motion. Big signal. Small bundle. Better signal.

Was this page helpful?

PreviousMCPNextLicense