Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Fix the driver behind crashes, sound loss and screen glitches3Clear out junk files and repair common Windows errorsCurtainsJS makes it practical to add WebGL visuals to ordinary web pages without abandoning the DOM workflow designers and front-end developers already use. Instead of building a full 3D scene from scratch, you can map images, videos, and HTML elements onto WebGL planes, then enhance them with shaders, motion, distortion, transitions, and interaction.
This makes it especially useful for portfolio pages, editorial layouts, product showcases, immersive landing pages, and any interface where visual polish matters but a heavy 3D engine would be excessive. The core idea is simple: keep your content in HTML and CSS, then let CurtainsJS synchronize matching WebGL surfaces on top of it.
As an Amazon Associate I earn from qualifying purchases.
From there, effects are driven by small shader programs and JavaScript uniforms such as time, mouse position, scroll progress, and viewport size. Starting with a single textured plane, you can build toward responsive, performant animations that feel integrated with the page rather than layered on as an afterthought.
Recommended Free Tools
What CurtainsJS Does and When to Use It
CurtainsJS is a lightweight WebGL library designed to connect regular HTML elements with GPU-rendered planes. Instead of building an entire 3D scene from scratch, you mark up images, videos, or containers in the DOM, then let CurtainsJS create matching WebGL meshes that sit in the same visual position. This makes it especially useful for websites that want shader-driven effects while keeping a familiar HTML and CSS workflow.
#1 Best Overall
The main idea is simple: a DOM element becomes a textured WebGL plane. An image can ripple on hover, a video can be distorted by scroll velocity, or a grid item can reveal itself through a custom fragment shader. CurtainsJS handles much of the tedious setup, including creating the WebGL context, tracking element bounds, loading textures, and updating planes when the page resizes or scrolls. You still write shaders, but you do not have to manage every low-level WebGL detail manually.
Good use cases for CurtainsJS
- Interactive image effects: hover distortions, displacement maps, liquid transitions, RGB shifts, and wave effects.
- Scroll-based storytelling: planes that bend, fade, blur, or reveal content as the user moves through the page.
- Video treatments: shader effects applied to HTML video textures for hero sections or editorial layouts.
- DOM-aligned WebGL: effects that need to stay visually synchronized with existing HTML elements and responsive layouts.
- Creative portfolios and landing pages: projects where visual polish, motion, and interaction are central to the experience.
CurtainsJS is a strong fit when the effect belongs to the page interface rather than a full 3D world. If you need a product configurator, physics-based 3D environment, skeletal animation, or complex model loading, a broader 3D framework such as Three.js may be a better choice. CurtainsJS shines when the source material is already part of the page: images, canvases, and videos styled with CSS, then enhanced with WebGL.
It also works well for progressive enhancement. The HTML can remain meaningful and accessible, with real image tags, links, headings, and layout containers still present in the document. WebGL becomes an enhancement layer rather than the only way to see content. That approach is useful in production because you can plan fallbacks for unsupported browsers, reduced-motion preferences, slow devices, or failed texture loading.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →When to avoid it
- Simple CSS effects are enough: opacity fades, transforms, filters, and blend modes are often cheaper and easier to maintain.
- The design needs heavy 3D scene management: large numbers of models, lights, shadows, and cameras call for a full 3D engine.
- Performance budgets are very tight: low-end mobile devices may struggle with large textures, many planes, or expensive shaders.
- The team is not ready to maintain shaders: GLSL adds another language and debugging workflow to the project.
A practical way to think about CurtainsJS is as a bridge between layout-driven web design and shader-driven rendering. Use CSS and HTML for structure, accessibility, and responsive flow; use CurtainsJS where pixels need to move in ways CSS cannot describe. This balance keeps the project grounded in normal front-end development while opening the door to GPU-powered interactions that feel fluid, tactile, and distinctive.
Project Setup and Basic Scene Structure
A CurtainsJS project starts with two layers: ordinary HTML that provides the content and media, and a WebGL canvas managed by CurtainsJS. The library reads selected DOM elements, creates matching WebGL planes, and keeps them aligned with the page layout. For a basic scene, you need a container for the WebGL context, one or more plane elements, and at least one image or video texture inside each plane.
The HTML can remain simple. A common structure is to place a fixed WebGL container near the top of the document, then define plane elements wherever they should appear in the page flow. Each plane element should contain the media that will be used as a texture. CurtainsJS does not replace your layout system; CSS still controls size, position, spacing, and responsiveness.
<div id="canvas"></div>
<section class="hero">
<div class="curtain-plane">
<img src="image.jpg" alt="Abstract landscape" crossorigin="">
</div>
</section>
The WebGL container is usually positioned fixed so it can cover the viewport while the HTML scrolls normally underneath or above it. The plane itself should have explicit dimensions through CSS, because CurtainsJS uses the element’s bounding rectangle to build the matching WebGL geometry.
Free tools Windows power users keep installed
One-click scans. No signup required.
#canvas {
position: fixed;
inset: 0;
z-index: 1;
pointer-events: none;
}
.hero {
position: relative;
z-index: 2;
min-height: 100vh;
display: grid;
place-items: center;
}
.curtain-plane {
width: min(80vw, 900px);
height: 55vh;
}
.curtain-plane img {
display: none;
}
In JavaScript, initialize Curtains with the canvas container, then create a plane from the DOM element. The plane receives shader programs and uniforms, which are values passed from JavaScript to the GPU. Even before adding custom interaction, it is useful to define a time uniform so the scene has a predictable animation loop.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallimport { Curtains, Plane } from "curtainsjs";
const curtains = new Curtains({
container: "canvas",
watchScroll: true,
pixelRatio: Math.min(1.5, window.devicePixelRatio),
});
const planeElement = document.querySelector(".curtain-plane");
const params = {
vertexShader,
fragmentShader,
uniforms: {
time: {
name: "uTime",
type: "1f",
value: 0,
},
},
};
const plane = new Plane(curtains, planeElement, params);
plane.onRender(() => {
plane.uniforms.time.value += 0.016;
});
The basic scene structure has a few moving parts, but each has a clear responsibility. The Curtains instance owns the renderer and global state. The plane connects one DOM element to one WebGL mesh. The shaders decide how vertices and pixels are drawn. Uniforms carry changing values such as time, mouse position, scroll progress, or viewport size into the shader code.
- Renderer container: the element where CurtainsJS injects and manages the WebGL canvas.
- Plane element: the HTML element whose size and position are mirrored in WebGL.
- Texture source: an image, video, or canvas element used by the fragment shader.
- Shaders: small GPU programs that transform geometry and color pixels.
- Uniforms: JavaScript-controlled values used to animate or customize the effect.
For production work, handle creation errors gracefully. WebGL can be unavailable because of browser settings, hardware limits, or privacy restrictions. CurtainsJS exposes error callbacks that let you fall back to the original HTML image rather than showing a broken effect. This is one of the advantages of keeping the DOM content meaningful: the page can still render usable content without the WebGL layer.
curtains.onError(() => {
document.body.classList.add("no-webgl");
});
plane.onReady(() => {
document.body.classList.add("webgl-ready");
});
Once this foundation is working, the project is ready for custom shaders. The first goal should be a stable textured plane that tracks its HTML element during resize and scroll. After that, effects such as distortion, hover ripples, color grading, and scroll-driven transitions can be added incrementally without changing the overall structure.
The Tool Desk
Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Mapping HTML Elements to WebGL Planes
CurtainsJS becomes especially useful when you want WebGL effects to follow the layout of real HTML. Instead of manually calculating plane positions in a 3D scene, you attach a WebGL plane to a DOM element, and CurtainsJS keeps the rendered plane aligned with that element’s size and position. This makes it practical to enhance images, cards, banners, and hero sections without abandoning normal HTML and CSS layout workflows.
A common pattern is to create a container element in your markup and place an image inside it. CurtainsJS reads that element, creates a corresponding WebGL plane, and uses the image as a texture. The DOM element still defines the layout, while the WebGL plane handles the visual rendering. For example, a product image can remain inside a responsive grid, but its pixels can be displaced, distorted, blended, or animated through shaders.
Basic HTML structure
The mapped element needs a selector that CurtainsJS can target. Inside it, image elements marked with a texture-related attribute can be used as plane textures. A typical structure looks like a regular responsive image block, with the difference that CurtainsJS will later bind it to a plane.
- Wrapper element: defines the position and size of the WebGL plane.
- Image element: provides the texture used by the shader.
- CSS sizing: controls how the plane appears in the page layout.
- Plane parameters: connect shaders, uniforms, textures, and rendering options.
In practice, the wrapper may use a class such as js-plane, while the image inside it can be styled with normal CSS. Many projects hide the original image once CurtainsJS has loaded the texture, because the WebGL canvas will render the visual result. Keeping the image in the markup is still valuable for layout, loading behavior, accessibility, and graceful fallback if WebGL is unavailable.
Creating a plane from a DOM element
After initializing CurtainsJS with a canvas container, select each target element and pass it to a plane constructor along with shader references and options. CurtainsJS measures the element’s bounding rectangle and creates a plane that matches it. When the page scrolls, the WebGL plane tracks the DOM element, so an image halfway down the page can animate only when it enters the viewport.
The plane can expose lifecycle callbacks that are useful for real interfaces. For example, you can wait until textures are loaded before adding an active class, update uniforms before every render, or respond to resize events when the element changes dimensions. This is where the bridge between DOM and WebGL becomes powerful: CSS handles the structure, JavaScript manages state, and shaders render the final pixels.
| DOM concept | CurtainsJS concept | Typical use |
|---|---|---|
| Image card | Plane | Apply hover distortion or reveal animation |
| Image source | Texture | Sample pixels in a fragment shader |
| Element width and height | Plane scale | Keep WebGL aligned with responsive layout |
| Scroll position | Plane visibility and transform updates | Animate only visible content |
Pay close attention to CSS when mapping elements. The WebGL plane follows the wrapper, so inconsistent aspect ratios, unexpected padding, or layout shifts can make effects feel imprecise. Set predictable dimensions, use responsive image rules, and avoid moving the original DOM element with transforms unless you account for how that affects measurement. For most projects, a stable wrapper with an absolutely positioned or hidden image gives the cleanest results.
Once the mapping is in place, each plane becomes a programmable version of its corresponding HTML element. You can start with a simple textured plane that looks identical to the original image, then gradually introduce shader uniforms for hover strength, scroll progress, time, or transition state. This incremental workflow keeps the page maintainable while giving you access to WebGL-level rendering for the elements that need it most.
Writing Vertex and Fragment Shaders
Once a DOM element is mapped to a CurtainsJS plane, its final appearance is controlled by two small GPU programs: a vertex shader and a fragment shader. The vertex shader decides where each point of the plane sits in 3D space, while the fragment shader decides the color of each rendered pixel. In a typical CurtainsJS effect, the vertex shader is used for motion and distortion, and the fragment shader is used for texture sampling, color shifts, gradients, masks, and blend effects.
A minimal vertex shader for a textured plane usually receives attributes such as the vertex position and UV coordinates, then passes the UVs to the fragment shader. CurtainsJS provides common matrices for projection and plane positioning, so the shader can place the plane correctly in the WebGL scene while still letting you modify its geometry. A simple pattern is to copy the incoming position, adjust it, then mully it by the provided matrices. For example, you might offset the z position with a sine wave to create a soft ripple across an image.
Common shader inputs in CurtainsJS
- Attributes: per-vertex data such as position and texture coordinates.
- Uniforms: values sent from JavaScript, such as time, mouse position, scroll progress, or effect strength.
- Varyings: values passed from the vertex shader to the fragment shader, often UV coordinates or distortion data.
- Samplers: texture references used in the fragment shader, commonly linked to an image or video inside the mapped HTML element.
The fragment shader is where the plane becomes an image, video, or stylized surface. Most CurtainsJS examples start by sampling the plane texture with UV coordinates: the shader reads a color from the texture and writes it to the screen. From there, small changes can produce strong visual results. Shifting the red, green, and blue channels by slightly different UV offsets creates a chromatic aberration effect. Mullying the sampled color by a gradient creates a lighting pass. Mixing the texture with a solid color based on mouse distance creates an interactive hover reveal.
Uniforms are the bridge between JavaScript and GLSL. In CurtainsJS, you define uniforms on the plane and update their values during render callbacks or event handlers. A time uniform can drive looping waves, noise movement, or pulsing opacity. A mouse uniform can push pixels away from the cursor, bend the plane, or reveal a second texture. A scroll uniform can transition between calm and distorted states as the user moves down the page. Keep uniform values normalized where possible; passing mouse coordinates as values from 0 to 1 makes the shader easier to reuse across different element sizes.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Rank #4
A practical shader workflow
- Start with a clean texture pass: render the DOM image or video without distortion to confirm the plane, UVs, and texture are working.
- Add one uniform at a time: introduce time, then mouse, then scroll, testing each input separately.
- Distort UVs before sampling: many effects are easier when you modify texture coordinates instead of moving geometry.
- Use vertex movement for silhouette changes: waves, bends, and depth motion should happen in the vertex shader when the plane shape itself needs to change.
- Keep fragment work compact: complex loops, many texture reads, and heavy noise functions can reduce frame rate on mobile devices.
For real projects, shader code should stay predictable and parameterized. Instead of hard-coding distortion strength, transition speed, or color intensity, expose them as uniforms so they can be tuned from JavaScript or connected to UI state. This makes the same shader useful for subtle product-image motion, bold editorial transitions, hover effects, and scroll-driven hero sections without rewriting the GLSL each time.
Adding Mouse, Scroll, and Time-Based Effects
Once a CurtainsJS plane is rendering a texture correctly, interaction usually comes down to updating uniforms. A uniform is a value sent from JavaScript into the shader program, such as elapsed time, mouse position, scroll amount, or transition progress. In CurtainsJS, you define these uniforms when creating the plane, then update their value during render callbacks or browser events. This keeps the DOM as the source of layout while WebGL handles the visual distortion, blending, or motion.
A common starting point is a time uniform used for continuous animation. For example, uTime can drive a subtle wave in the vertex shader, making an image feel fluid without changing the underlying HTML element. CurtainsJS planes expose an onRender callback, which runs on every frame while the renderer is active. Inside it, increment the time value and let the shader decide how that value affects vertices or pixels. Small values usually work best: a displacement of a few pixels often feels polished, while large offsets can make images hard to read or cause visible stretching.
- Time: use for ambient movement, looping distortion, shimmer, noise, and transitions.
- Mouse position: use for hover ripples, image bending, spotlight reveals, and cursor-following highlights.
- Scroll: use for parallax, velocity-based blur, reveal effects, and progressive shader transitions.
Mouse interaction works best when coordinates are normalized before being sent to the shader. Browser events provide positions in pixels, while shaders usually expect values between 0.0 and 1.0, or between -1.0 and 1.0. CurtainsJS provides helpers for converting mouse coordinates into plane space, which is especially useful when planes move, scale, or sit inside responsive layouts. For hover effects, it is also useful to smooth the mouse value rather than applying it directly. Store both a target mouse position and a current mouse position, then interpolate the current value toward the target on each frame. This creates a softer, more physical response.
Scroll effects can be handled in two complementary ways. First, CurtainsJS automatically tracks DOM elements and updates plane positions as the page scrolls, keeping WebGL content aligned with its matching HTML. Second, you can read scroll progress or scroll velocity in JavaScript and pass it to a uniform such as uScrollEffect. A slow-changing scroll progress value is suited to reveal animations, while velocity is better for temporary effects like stretching, blur, or chromatic separation that intensify during fast scrolling and settle back to zero afterward.
Practical animation pattern
A production-friendly pattern is to keep all event listeners lightweight and do the visual updates inside the render loop. Mousemove and scroll handlers should only update target values. The plane’s render callback can then smooth those targets, clamp extreme values, and assign the final numbers to uniforms. This avoids pushing too much work into high-frequency DOM events and produces more consistent animation across devices.
| Input | JavaScript value | Shader use |
|---|---|---|
| Elapsed time | uTime |
Waves, noise movement, looping distortion |
| Pointer position | uMouse |
Localized ripples, hover deformation, reveal masks |
| Scroll velocity | uScrollVelocity |
Stretching, blur intensity, temporary displacement |
| Scroll progress | uProgress |
Section reveals, transitions, controlled blending |
For a simple interactive image, combine these inputs carefully: use uTime for a low-amplitude background wave, uMouse to create a localized distortion near the cursor, and uScrollVelocity to add brief vertical stretching while the user scrolls. In the fragment shader, the same values can offset texture coordinates before sampling the image. In the vertex shader, they can move the plane’s geometry for a more dimensional effect. The best results usually come from restraint: one primary interaction, one subtle secondary motion, and a quick return to stillness when the user stops interacting.
Handling Responsiveness and Performance
Responsive CurtainsJS effects need to track both layout changes and rendering cost. A plane that looks correct on a desktop hero image can stretch, crop, or drift away from its HTML element when the viewport changes unless the DOM, texture, uniforms, and camera calculations stay in sync. CurtainsJS already observes many DOM changes through its plane system, but production effects still benefit from explicitly planning how images scale, how uniforms update, and when rendering should pause or simplify.
Start by sizing the HTML source element with normal CSS, then let CurtainsJS map the WebGL plane to that element. For images and videos, define a predictable layout using properties such as aspect-ratio, object-fit, and stable container dimensions. If your shader depends on resolution, pass both the plane size and viewport size as uniforms, then update them when the renderer or plane resizes. This prevents effects such as ripples, pixelation, gradients, and displacement maps from changing intensity just because the screen became narrower.
Responsive values to keep updated
- Viewport resolution: useful for normalizing mouse coordinates and screen-space effects.
- Plane bounds: needed when an effect should follow the actual DOM element dimensions.
- Texture ratio: used to avoid unwanted stretching when image and plane proportions differ.
- Scroll position: helpful for effects that react to visibility, parallax, or page progress.
- Device pixel ratio: useful for balancing sharpness against GPU workload.
Performance depends heavily on how often you render and how much work each frame performs. Animated shaders are usually cheap when they use a small number of uniforms and texture reads, but expensive fragment shaders can become costly because they run for every visible pixel of every plane. Avoid stacking many full-screen planes with blur, noise, mulle displacement textures, or nested loops. If an effect covers a large area, keep the shader simple; if an effect is complex, consider limiting it to a smaller element.
Best Value
A practical approach is to cap pixel density on high-DPI screens. Rendering at the full pixel ratio of modern phones and laptops can mully fragment shader work with little visible benefit. Many real projects clamp the pixel ratio to a maximum such as 1.5 or 2. You can also reduce work by disabling drawing when no animated uniforms are changing. CurtainsJS supports render control patterns where you update the scene only when needed, which is especially useful for hover effects, static image distortions, and pages with several WebGL sections.
Common optimization choices
| Situation | Practical adjustment |
|---|---|
| High-DPI mobile screens | Clamp device pixel ratio to reduce fragment shader load. |
| Many planes on one page | Animate only visible planes and simplify offscreen sections. |
| Scroll-driven visuals | Smooth values in JavaScript, then send one uniform per frame. |
| Heavy image distortion | Use fewer texture samples and lower-resolution displacement maps. |
| Static idle state | Pause continuous rendering until interaction resumes. |
Visibility handling is another useful safeguard. Use an intersection observer or equivalent page-state to reduce animation updates when planes are outside the viewport. For long pages, this can make the difference between a smooth editorial layout and a page that drains battery while the user is reading unrelated content. Similarly, listen for tab visibility changes so time-based animations do not accumulate unnecessary updates in the background.
Finally, design fallbacks from the start. The original DOM element should remain meaningful and styled even before CurtainsJS initializes, after a WebGL context loss, or on browsers where the effect is disabled. Treat the WebGL layer as an enhancement over accessible HTML and CSS rather than a replacement. With stable sizing, carefully updated uniforms, controlled render loops, and sensible fallbacks, CurtainsJS effects can remain sharp, responsive, and performant across real devices.
Frequently Asked Questions
Do I need to know raw WebGL before using CurtainsJS?
You do not need to write raw WebGL setup code, but you should understand the basics of shaders, uniforms, textures, and geometry. CurtainsJS handles the renderer, camera, planes, and DOM syncing, while you still write GLSL for the visual effect itself. If you are new, start with a single image plane and a simple fragment shader that changes color or distortion over time.
How does CurtainsJS connect an HTML image or section to a WebGL plane?
CurtainsJS reads a DOM element’s size and position, then creates a matching WebGL plane in the canvas. Images, videos, or canvases inside that element can be used as textures in your shader. This lets you keep normal HTML layout and styling while rendering the visual content through WebGL.
Can I use CurtainsJS effects in responsive layouts?
Yes, CurtainsJS can resize and reposition planes when the viewport or DOM layout changes. You should listen for resize events, update uniforms related to resolution or aspect ratio, and make sure image textures are cropped or scaled consistently in the shader. For complex layouts, test at mulle breakpoints because shader distortion can look different when the plane aspect ratio changes.
Free tools Windows power users keep installed
One-click scans. No signup required.
How can I add mouse or scroll interaction to a CurtainsJS shader?
Mouse and scroll values are usually passed into the shader as uniforms. For example, you can normalize the mouse position from 0 to 1 and use it to push vertices, create ripples, or blend textures. Scroll progress can drive transitions, displacement strength, opacity, or timeline-based animation.
Is CurtainsJS suitable for production websites?
CurtainsJS can work well in production if effects are used carefully and fallbacks are planned. Keep shader calculations lightweight, avoid too many high-resolution textures, and reduce animation work when elements are off screen. You should also provide a non-WebGL fallback for browsers or devices where WebGL is disabled or performs poorly.
Bottom Line
CurtainsJS gives you a practical path to add WebGL effects without abandoning the DOM workflow designers and front-end developers already use. By pairing HTML elements with textured planes, writing small vertex and fragment shaders, and driving uniforms with scroll, mouse, or time-based animation, you can create polished interactive visuals that still fit naturally into a modern web page.
Start with one simple plane, keep your shaders focused, and test early across screen sizes and devices. Once the basics are solid, you can layer in distortion, parallax, hover transitions, and responsive performance optimizations to turn ordinary page elements into production-ready WebGL experiences.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
