darkroomengineering/lenis

Lenis ("smooth" in latin) is a lightweight, robust, and performant smooth scroll library. It's designed by @darkroom.engineering to be simple to use and easy to integrate into your projects. It's built with performance in mind and is optimized for modern browsers. It's perfect for creating smooth scrolling experiences on your website such as WebGL scroll syncing, parallax effects, and much more, see Demo and Showcase.

Read our Manifesto to learn more about the inspiration behind Lenis.

• Features
• Sponsors
• Packages
• Showcase
• Installation
• Setup
• No-code usage
• Settings
• Properties
• Methods
• Events
• Considerations
• Limitations
• Troubleshooting
• Tutorials
• Plugins
• License

• Lightweight & dependency-free — the whole library is a few KB with zero runtime dependencies
• Runs on native scroll — wraps the browser's own scroll, so position: sticky, anchor links, and accessibility keep working
• Any axis — smooth vertical, horizontal, and nested scrolling from a single instance
• Built for sync — drives WebGL scroll scenes, GSAP ScrollTrigger, and parallax off one loop
• Framework adapters — first-class packages for React, Vue, and Framer
• Scroll snapping — the snap plugin aligns sections without fighting the smooth scroll

If you’ve used Lenis and it made your site feel just a little more alive, consider sponsoring.

Your support helps us smooth out the internet one library at a time—and lets us keep building tools that care about the details most folks overlook.

• lenis
• lenis/react
• lenis/vue
• lenis/framer
• lenis/snap

Using a package manager:

npm i lenis
# or
yarn add lenis
# or
pnpm add lenis

import Lenis from 'lenis'

Using scripts:

<script src="https://unpkg.com/lenis@1.3.26/dist/lenis.min.js"></script> 

// Initialize Lenis
const lenis = new Lenis({
  autoRaf: true,
});

// Listen for the scroll event and log the event data
lenis.on('scroll', (e) => {
  console.log(e);
});

// Initialize Lenis
const lenis = new Lenis();

// Use requestAnimationFrame to continuously update the scroll
function raf(time) {
  lenis.raf(time);
  requestAnimationFrame(raf);
}

requestAnimationFrame(raf);

Import stylesheet:

import 'lenis/dist/lenis.css'

Or link the CSS file:

<link rel="stylesheet" href="https://unpkg.com/lenis@1.3.26/dist/lenis.css">

Or add it manually:

See lenis.css stylesheet

// Initialize a new Lenis instance for smooth scrolling
const lenis = new Lenis();

// Synchronize Lenis scrolling with GSAP's ScrollTrigger plugin
lenis.on('scroll', ScrollTrigger.update);

// Add Lenis's requestAnimationFrame (raf) method to GSAP's ticker
// This ensures Lenis's smooth scroll animation updates on each GSAP tick
gsap.ticker.add((time) => {
  lenis.raf(time * 1000); // Convert time from seconds to milliseconds
});

// Disable lag smoothing in GSAP to prevent any delay in scroll animations
gsap.ticker.lagSmoothing(0);

One line, no build step — just drop this into your HTML:

<link rel="stylesheet" href="https://unpkg.com/lenis@1.3.26/dist/lenis.css">
<script src="https://unpkg.com/lenis@1.3.26/dist/lenis.min.js"></script> 
<script>new Lenis({ autoRaf: true, autoToggle: true, anchors: true, allowNestedScroll: true, naiveDimensions: true, stopInertiaOnNavigate: true })</script>

That's it, your page now has smooth scrolling and should handle most of the usual issues such as:

• compatibility with other packages
• modals
• smooth anchors
• scroll reset on page change

The simplest and most reliable way to handle nested scrollable elements is to use the allowNestedScroll option:

const lenis = new Lenis({
  allowNestedScroll: true,
})

This automatically detects nested scrollable elements and lets them scroll natively. However, this can create performance issues since Lenis needs to check the DOM tree on every scroll event. If you experience performance problems, use data-lenis-prevent instead.

<div data-lenis-prevent>scrollable content</div>

See example

<div id="modal">scrollable content</div>

const lenis = new Lenis({
  prevent: (node) => node.id === 'modal',
})

See example

By default, Lenis will prevent anchor links from working while scrolling. To enable them, you must set anchors: true.

new Lenis({
  anchors: true
})

You can also use scrollTo options:

new Lenis({
  anchors: {
    offset: 100,
    onComplete: ()=>{
      console.log('scrolled to anchor')
    }
  }
})

By default, Lenis honors the user's prefers-reduced-motion setting: when it is set to reduce, smoothing is disabled (lerp is forced to 1 so the scroll tracks the input device 1:1, ignoring duration/easing) and programmatic scrolls (scrollTo, anchor links) jump instantly to their target. Lenis keeps running so WebGL/DOM synchronization stays intact, and the preference is picked up live without a reload. You can check lenis.prefersReducedMotion to adapt your own animations.

You can opt out (not recommended) with:

const lenis = new Lenis({
  respectReducedMotion: false,
})

• no support for CSS scroll-snap, you must use (lenis/snap)
• capped to 60fps on Safari (source) and 30fps on low power mode
• smooth scroll will stop working over iframe since they don't forward wheel events
• position fixed seems to lag on MacOS Safari pre-M1 (source)
• touch events may behave unexpectedly when syncTouch is enabled on iOS < 16
• nested scroll containers require proper configuration to work correctly

• Make sure you use the latest version of Lenis
• Include the recommended CSS
• If using GSAP ScrollTrigger, ensure proper integration (see GSAP ScrollTrigger setup section)
• Test without Lenis to ensure your element/page is scrollable
• Be sure to use autoRaf: true or manually call lenis.raf(time) in your animation loop

• Infinite Scrolling with Lenis by Matt Rothenberg
• Building Smooth Scroll in 2025 with Lenis by Edoardo Lunardi

• r3f-scroll-rig by 14islands
• locomotive-scroll by Locomotive

MIT © darkroom.engineering