threejs
/threejs
Use when building or debugging interactive 3D scenes on the web with Three.js (scene/camera/renderer, lights/materials, GLTF loading, controls, performance). Helpful for designers shipping 3D UI moments.
Assessment and security
- Files in this package
- 5
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 26.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Use when building or debugging interactive 3D scenes on the web with Three.js (scene/camera/renderer, lights/materials, GLTF loading, controls, performance). Helpful for designers shipping 3D UI moments.
Original author description
Use when building or debugging interactive 3D scenes on the web with Three.js (scene/camera/renderer, lights/materials, GLTF loading, controls, performance). Helpful for designers shipping 3D UI moments.
How it works
- When to use
- Core mental model
- Key APIs/patterns
- Common pitfalls
- Quick recipes
- What to ask the user
SKILL.md preview
---
name: threejs
description: Use when building or debugging interactive 3D scenes on the web with Three.js (scene/camera/renderer, lights/materials, GLTF loading, controls, performance). Helpful for designers shipping 3D UI moments.
---
# Three.js — WebGL 3D Scenes Skill
## When to use
- Real 3D: product spins, interactive hero scenes, shaders/material effects, 3D data viz
- You need full control beyond “background effects”
- You can budget time for asset pipeline + performance tuning
## Core mental model
- Create:
- `Scene` (root graph)
- `Camera` (Perspective/Orthographic)
- `Renderer` (`WebGLRenderer`)
- `Mesh` = `Geometry` + `Material`
- Lights (if using non-unlit materials)
- Render loop:
- `requestAnimationFrame(animate)`
- Update time-based animations, controls, mixers, then `renderer.render(scene, camera)`
## Key APIs/patterns
- Setup:
- `const renderer = new THREE.WebGLRenderer({ canvas, antialias, alpha })`
- `renderer.setSize(width, height, false)`
- `renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2))`
- Camera:
- `camera.aspect = width / height; camera.updateProjectionMatrix()`
- Scene graph:
- `scene.add(object)` / `object.position/rotation/scale`
- Loading assets:
- `GLTFLoader` (models), `TextureLoader` (images), `DRACOLoader` (compressed glTF)
- Controls (common):
- `OrbitControls` (debug/product), `PointerLockControls` (FPS), custom pointer handlers
- Cleanup (important in SPAs):
- `geometry.dispose()`, `material.dispose()`, `texture.dispose()`, `renderer.dispose()`
- Remove event listeners; cancel RAF.
## Common pitfalls
- Not handling resize → stretched/cropped rendering
- Too high devicePixelRatio → mobile GPU meltdown
- Leaking WebGL resources (not disposing) → crashes after route changes
- Loading huge textures/models → slow start; use compressed textures, Draco/KTX2, smaller maps
- Using too many lights/shadows → expensive; fake lighting with baked textures when possible
## Quick recipes
### 1) Minimal spinning cube
```js
import * as THREE from "three";
const canvas = document.querySelector("#c");
const renderer = new THREE.WebGLRenderer({ canvas, antialias: true, alpha: true });
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(45, 1, 0.1, 100);
camera.position.set(0, 0, 4);
const geom = new THREE.BoxGeometry(1, 1, 1);
const mat = new THREE.MeshStandardMaterial({ color: 0x7c3aed });
const mesh = new THREE.Mesh(geom, mat);
scene.add(mesh);
scene.add(new THREE.AmbientLight(0xffffff, 0.8));
const dir = new THREE.DirectionalLight(0xffffff, 0.8);
dir.position.set(2, 2, 2);
scene.add(dir);
function resize() {
const w = canvas.clientWidth;
const h = canvas.clientHeight;
renderer.setSize(w, h, false);
renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
camera.aspect = w / h;
camera.updateProjectionMatrix();
}
window.addEventListener("resize", resize);
resize();
function animate(t) {
mesh.rotation.y = t * 0.0006;
renderer.render(scene, camera);
requestAnimationFrame(animate);
}
requestAnimationFrame(animate);
```
### 2) Respect reduced motion
- If `prefers-reduced-motion: reduce`, render a still frame (no RAF) or slow updates.
## What to ask the user
- Is this decorative (hero) or functional 3D (product viewer)?
- Target devices: mobile? older iPhones?
- Asset format availability (glTF, HDRI, textures) and file size constraints
- Accessibility/reduced motion requirements
Files in this package (5)
- REFERENCES.md 1 KB
- SKILL.md 3 KB
- demo/PROMPT.md 2 KB
- demo/index.html 16 KB
- demo/preview.jpg 39 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · MengTo/Skills | 100 | MIT |
| TerminalSkills/skills | 100 | Apache-2.0 |
| whoamnesia/astudio-motion | 100 | MIT |
| emiliodominguez/threejs-skills | 100 | MIT |
| Funnyhust/POC_Kaenx_Creator | 100 | GPL-3.0 |
| secondsky/claude-skills | 95 | MIT |
Identical content appears in 2 other GitHub folders. We show one copy with the highest score.
Database snapshot: 13.11.2026 · package version 8fb03a3d553f (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100threejs-fundamentals
Three.js core knowledge base — scene, camera, renderer, geometries, materials, lights, GLTF loader, OrbitControls, raycaster, render loop, resize handling. Use when starting a vanilla Three.js scene, debugging WebGL context, integrating Three.js without React, or learning the… - 90threejs-3d
Build and optimize browser 3D scenes with Three.js, React Three Fiber, WebGPU or WebGL, TSL and glTF assets. Use when implementing cameras, materials, 3D interaction, model loading or renderer performance; preserve renderer compatibility and resource ownership. - 90threejs-guide
Use when building or editing 3D scenes in vanilla Three.js for WebGL/WebGPU. Triggers on `.js`/`.ts` files with `three` or `three/*` imports, and on prompts about Scene, Renderer, Mesh, BufferGeometry, materials, lighting, GLTF loaders, raycasting, shaders, post-processing,… - 100threejs-gltf-loading
Load glTF/GLB models in three.js with GLTFLoader and play their skinned animations with AnimationMixer, including DRACO/Meshopt-compressed meshes and KTX2 textures. Use when importing 3D models into three.js — when the user mentions glTF, GLB, GLTFLoader, AnimationMixer,… - 100threejs-materials-lighting
Light and shade a three.js scene: choose materials (MeshStandardMaterial PBR vs unlit MeshBasicMaterial), add ambient/hemisphere/directional/point/spot lights, turn on shadow maps, and use an environment map (IBL) for realistic reflections. Use when a three.js model looks black,… - 100od-threejs
Three.js skills for creating 3D elements and interactive experiences in the browser — scenes, materials, controls, and post-processing. Use when the user asks for threejs work, or mentions od, threejs.