deveshpunjabi/3d-website-skill / skills/3d-website-architect
3d-website-architect
VerifiedExpert skill for designing, building, and deploying modern premium websites with advanced animations and 3D interactive experiences using Three.js, React Three Fiber, GSAP, and Framer Motion. Use this skill whenever the user wants to build a website with 3D elements, create an immersive web experience, add interactive 3D graphics to a page, build a premium landing page with cinematic visuals, design a modern startup website with animations, create WebGL or Three.js scenes, build a product showcase with 3D models, or produce any kind of visually impressive, award-winning web interface. Also trigger when the user says things like "make it look like Awwwards", "add 3D to my site", "build an interactive landing page", "create an immersive experience", "premium website with animations", "modern startup page", "hero with particles or globe", "floating 3D elements", or mentions anything related to Three.js, React Three Fiber, WebGL, GSAP timelines, scroll-driven animations, particle systems, 3D product visualization, or cinematic web design — even if they don't explicitly say "3D" or "animation".
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 32.3 KB |
| evals/evals.json | config | 7.0 KB |
| references/3d-integration.md | markdown | 23.0 KB |
| references/animation-patterns.md | markdown | 20.9 KB |
| references/design-systems.md | markdown | 16.6 KB |
references/3d-integration.md
View on GitHub# 3D Integration Reference
Complete reference for integrating Three.js and React Three Fiber into modern web experiences.
Consult this when implementing Step 7 of the Immersive Design Process.
## Table of Contents
1. [Canvas Setup](#canvas-setup)
2. [Lighting Systems](#lighting-systems)
3. [Common Scene Recipes](#common-scene-recipes)
4. [Geometry Patterns](#geometry-patterns)
5. [Shader Materials](#shader-materials)
6. [Post-Processing](#post-processing)
7. [Mouse & Scroll Interaction](#mouse--scroll-interaction)
8. [Performance Optimization](#performance-optimization)
9. [Responsive 3D](#responsive-3d)
10. [Loading & Error Handling](#loading--error-handling)
11. [Model Loading](#model-loading)
---
## Canvas Setup
### Basic R3F Canvas Configuration
```tsx
import { Canvas } from '@react-three/fiber';
import { Suspense } from 'react';
function Scene3D() {
return (
<div className="absolute inset-0 -z-10">
<Canvas
camera={{ position: [0, 0, 5], fov: 45 }}
dpr={[1, 2]} // Pixel ratio: min 1, max 2 (no need for 3x)
gl={{
antialias: true,
alpha: true, // Transparent background — lets CSS bg show
powerPreference: 'high-performance',
}}
style={{ pointerEvents: 'none' }} // Pass clicks through to UI
>
<Suspense fallback={null}>
<HeroScene />
</Suspense>
</Canvas>
</div>
);
}
```
### Canvas as Background Layer
The most common pattern for 3D websites is using the canvas as a background behind HTML content:
```tsx
// Layout: Canvas behind content
<div className="relative min-h-screen">
{/* 3D Background Layer */}
<div className="absolute inset-0 -z-10">
<Canvas gl={{ alpha: true }} style={{ pointerEvents: 'none' }}>
<BackgroundScene />
</Canvas>
</div>
{/* HTML Content Layer */}
<div className="relative z-10">
<HeroContent />
</div>
</div>
```
### Canvas for Interactive Sections
When the 3D scene is the main content (product viewer, interactive demo):
```tsx
<div className="w-full h-[600px] rounded-2xl overflow-hidden border border-white/10">
<Canvas camera={{ position: [0, 0, 4], fov: 50 }}>
<Suspense fallback={<LoadingFallback />}>
<ProductViewer modelUrl="/models/product.glb" />
<OrbitControls enableZoom={false} autoRotate autoRotateSpeed={1} />
<Environment preset="city" />
</Suspense>
</Canvas>
</div>
```
### Performance Mode Canvas
For sections where 3D is ambient (not always visible):
```tsx
<Canvas
frameloop="demand" // Only render when something changes
performance={{ min: 0.5 }} // Adaptive resolution
>
```
---
## Lighting Systems
### Standard Three-Point Lighting
```tsx
function StandardLighting() {
return (
<>
{/* Ambient — base illumination */}
<ambientLight intensity={0.4} color="#ffffff" />
{/* Key light — main directional light */}
<directionalLight
position={[5, 5, 5]}
intensity={1}
color="#ffffff"
castShadow
/>
{/* Fill light — soften shadows */}
<pointLight position={[-5, 0, -5]} intensity={0.3} color="#6366f1" />
{/* Rim light — edge definition */}
<pointLight position={[0, 5, -5]} intensity={0.5} color="#8b5cf6" />
</>
);
}
```
### Accent-Colored Lighting for Product Niches
```tsx
// AI / SaaS — cool blue-purple
<pointLight position={[5, 3, 5]} intensity={0.8} color="#6366f1" />
<pointLight position={[-5, -2, 3]} intensity={0.4} color="#8b5cf6" />
// Cybersecurity — cyan alerts
<pointLight position={[5, 3, 5]} intensity={0.8} color="#22d3ee" />
<pointLight position={[-5, -2, 3]} intensity={0.3} color="#06b6d4" />
// Creative — warm copper
<pointLight position={[5, 3, 5]} intensity={0.7} color="#d4956a" />
<pointLight position={[-5, -2, 3]} intensity={0.3} color="#e8c49a" />
```
### Environment Maps
```tsx
import { Environment } from '@react-three/drei';
// Preset environments (no file needed)
<Environment preset="night" /> // Dark, moody — best for dark themes
<Environment preset="city" /> // Neutral reflections — product viewers
<Environment preset="studio" /> // Clean lighting — presentations
<Environment preset="sunset" /> // Warm, atmospheric — creative
// Custom HDR environment
<Environment files="/textures/custom-env.hdr" />
```
---
## Common Scene Recipes
### Floating Geometric Background
The classic "premium startup" 3D background — floating shapes with subtle motion:
```tsx
import { Float, MeshDistortMaterial } from '@react-three/drei';
import { useFrame } from '@react-three/fiber';
import { useRef } from 'react';
function FloatingShapes() {
return (
<group>
{/* Main focal shape */}
<Float speed={2} rotationIntensity={0.5} floatIntensity={1}>
<mesh position={[0, 0, 0]}>
<icosahedronGeometry args={[1.5, 1]} />
<MeshDistortMaterial
color="#1e1b4b"
emissive="#6366f1"
emissiveIntensity={0.4}
roughness={0.3}
metalness={0.7}
distort={0.2}
speed={2}
/>
</mesh>
</Float>
{/* Orbiting smaller shapes */}
{[...Array(6)].map((_, i) => (
<Float key={i} speed={1.5 + i * 0.3} floatIntensity={0.5}>
<mesh
position={[
Math.cos((i / 6) * Math.PI * 2) * 3,
Math.sin((i / 6) * Math.PI * 2) * 2,
-2 + Math.random() * 2,
]}
scale={0.2 + Math.random() * 0.3}
>
<octahedronGeometry args={[1, 0]} />
<meshStandardMaterial
color="#0f0f23"
emissive="#8b5cf6"
emissiveIntensity={0.3}
wireframe={i % 2 === 0}
transparent
opacity={0.6}
/>
</mesh>
</Float>
))}
</group>
);
}
```
### Globe / Sphere Visualization
For AI, SaaS, and network products — a globe with connection arcs:
```tsx
import { Sphere, Line } from '@react-three/drei';
import { useRef } from 'react';
import { useFrame } from '@react-three/fiber';
import * as THREE from 'three';
function Globe() {
const globeRef = useRef<THREE.Mesh>(null);
useFrame((_, delta) => {
if (globeRef.current) {
globeRef.current.rotation.y += delta * 0.1;
}
});
return (
<group>
{/* Main globe */}
<mesh ref={globeRef}>
<sphereGeometry args={[2, 64, 64]} />
<meshStandardMaterial
color="#0a0a1a"
emissive="#6366f1"
emissiveIntensity={0.1}
roughness={0.8}
metalness={0.2}
wireframe
transparent
opacity={0.3}
/>
</mesh>
{/* Solid inner sphere for depth */}
<mesh>
<sphereGeometry args={[1.95, 32, 32]} />
<meshStandardMaterial
color="#050510"
roughness={1}
metalness={0}
/>
</mesh>
{/* Glowing dots on surface */}
{generateGlobePoints(50).map((pos, i) => (
<mesh key={i} position={pos} scale={0.03}>
<sphereGeometry args={[1, 8, 8]} />
<meshBasicMaterial color="#6366f1" />
</mesh>
))}
</group>
);
}
function generateGlobePoints(count: number): [number, number, number][] {
const points: [number, number, number][] = [];
for (let i = 0; i < count; i++) {
const phi = Math.acos(2 * Math.random() - 1);
const theta = Math.random() * Math.PI * 2;
const r = 2.01;
points.push([
r * Math.sin(phi) * Math.cos(theta),
r * Math.sin(phi) * Math.sin(theta),
r * Math.cos(phi),
]);
}
return points;
}
```
### Particle Field
Ambient particle system for hero backgrounds:
```tsx
import { useRef, useMemo } from 'react';
import { useFrame } from '@react-three/fiber';
import * as THREE from 'three';
function ParticleField({ count = 500 }) {
const points = useRef<THREE.Points>(null);
const particles = useMemo(() => {
const positions = new Float32Array(count * 3);
const sizes = new Float32Array(count);
for (let i = 0; i < count; i++) {
positions[i * 3] = (Math.random() - 0.5) * 20;
positions[i * 3 + 1] = (Math.random() - 0.5) * 20;
positions[i * 3 + 2] = (Math.random() - 0.5) * 20;
sizes[i] = Math.random() * 2;
}
return { positions, sizes };
}, [count]);
useFrame((_, delta) => {
if (points.current) {
points.current.rotation.y += delta * 0.02;
points.current.rotation.x += delta * 0.01;
}
});
return (
<points ref={points}>
<bufferGeometry>
<bufferAttribute
attach="attributes-position"
args={[particles.positions, 3]}
/>
<bufferAttribute
attach="attributes-size"
args={[particles.sizes, 1]}
/>
</bufferGeometry>
<pointsMaterial
size={0.02}
color="#6366f1"
transparent
opacity={0.6}
sizeAttenuation
depthWrite={false}
/>
</points>
);
}
```
### Morphing Blob
Abstract organic shape using noise-based distortion:
```tsx
import { MeshDistortMaterial, Sphere } from '@react-three/drei';
function MorphingBlob() {
return (
<Sphere args={[1.5, 64, 64]}>
<MeshDistortMaterial
color="#1e1b4b"
emissive="#6366f1"
emissiveIntensity={0.5}
roughness={0.2}
metalness={0.8}
distort={0.4}
speed={2}
/>
</Sphere>
);
}
```
---
## Geometry Patterns
### Low-Poly Hero Elements
Keep geometry count low for performance:
| Geometry | Triangles | Best For |
|----------|-----------|----------|
| `icosahedronGeometry(1, 0)` | 20 | Low-poly accent shapes |
| `icosahedronGeometry(1, 1)` | 80 | Stylized spheres |
| `octahedronGeometry(1, 0)` | 8 | Diamond/crystal shapes |
| `torusKnotGeometry(1, 0.3, 64, 8)` | ~1k | Organic knot shapes |
| `dodecahedronGeometry(1, 0)` | 36 | Geometric accent |
| `sphereGeometry(1, 32, 32)` | ~2k | Smooth sphere |
| `sphereGeometry(1, 64, 64)` | ~8k | High-quality globe |
### Custom Geometry with Curves
```tsx
import * as THREE from 'three';
function RibbonGeometry() {
const curve = new THREE.CatmullRomCurve3([
new THREE.Vector3(-3, 0, 0),
new THREE.Vector3(-1, 1, 1),
new THREE.Vector3(1, -1, -1),
new THREE.Vector3(3, 0, 0),
]);
return (
<mesh>
<tubeGeometry args={[curve, 64, 0.05, 8, false]} />
<meshStandardMaterial
color="#6366f1"
emissive="#6366f1"
emissiveIntensity={0.5}
/>
</mesh>
);
}
```
---
## Shader Materials
### Gradient Sphere Shader
A glowing gradient sphere — perfect for AI product hero sections:
```tsx
const vertexShader = `
varying vec2 vUv;
varying vec3 vNormal;
void main() {
vUv = uv;
vNormal = normalize(normalMatrix * normal);
gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
}
`;
const fragmentShader = `
uniform float uTime;
uniform vec3 uColor1;
uniform vec3 uColor2;
varying vec2 vUv;
varying vec3 vNormal;
void main() {
float fresnel = pow(1.0 - dot(vNormal, vec3(0.0, 0.0, 1.0)), 2.0);
vec3 color = mix(uColor1, uColor2, vUv.y + sin(uTime * 0.5) * 0.1);
float alpha = fresnel * 0.8 + 0.1;
gl_FragColor = vec4(color, alpha);
}
`;
function GradientSphere() {
const materialRef = useRef<THREE.ShaderMaterial>(null);
useFrame(({ clock }) => {
if (materialRef.current) {
materialRef.current.uniforms.uTime.value = clock.getElapsedTime();
}
});
return (
<mesh>
<sphereGeometry args={[2, 64, 64]} />
<shaderMaterial
ref={materialRef}
vertexShader={vertexShader}
fragmentShader={fragmentShader}
transparent
uniforms={{
uTime: { value: 0 },
uColor1: { value: new THREE.Color('#6366f1') },
uColor2: { value: new THREE.Color('#a855f7') },
}}
/>
</mesh>
);
}
```
### Animated Wireframe Noise
```tsx
const noiseVertexShader = `
uniform float uTime;
varying vec2 vUv;
// Simplex noise function
vec3 mod289(vec3 x) { return x - floor(x * (1.0/289.0)) * 289.0; }
vec4 mod289(vec4 x) { return x - floor(x * (1.0/289.0)) * 289.0; }
vec4 permute(vec4 x) { return mod289(((x*34.0)+1.0)*x); }
// ... (include full simplex noise or import via glslify)
void main() {
vUv = uv;
vec3 pos = position;
float displacement = sin(pos.x * 3.0 + uTime) * sin(pos.y * 3.0 + uTime) * 0.15;
pos += normal * displacement;
gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
}
`;
```
---
## Post-Processing
### Common Effect Combinations
```tsx
import { EffectComposer, Bloom, ChromaticAberration, Vignette } from '@react-three/postprocessing';
import { BlendFunction } from 'postprocessing';
function PostEffects() {
return (
<EffectComposer>
{/* Bloom — glow on bright/emissive surfaces */}
<Bloom
luminanceThreshold={0.6}
luminanceSmoothing={0.9}
intensity={0.5}
mipmapBlur
/>
{/* Chromatic Aberration — subtle RGB split for cinematic feel */}
<ChromaticAberration
offset={[0.0005, 0.0005]}
blendFunction={BlendFunction.NORMAL}
/>
{/* Vignette — darkened edges for focus */}
<Vignette
offset={0.3}
darkness={0.7}
blendFunction={BlendFunction.NORMAL}
/>
</EffectComposer>
);
}
```
### Post-Processing Performance Rules
- Bloom is the most useful effect — adds cinematic glow to emissive materials
- Chromatic aberration: keep offset below 0.001 — subtlety is key
- Avoid stacking more than 3 effects — each adds a full-screen render pass
- On mobile: disable post-processing entirely or use only Bloom at low intensity
- Use `mipmapBlur` on Bloom for better quality at lower performance cost
---
## Mouse & Scroll Interaction
### Mouse-Follow Camera
```tsx
import { useFrame, useThree } from '@react-three/fiber';
function MouseFollowCamera() {
const { camera } = useThree();
useFrame(({ pointer }) => {
// Smooth follow with damping
camera.position.x += (pointer.x * 0.5 - camera.position.x) * 0.05;
camera.position.y += (pointer.y * 0.3 - camera.position.y) * 0.05;
camera.lookAt(0, 0, 0);
});
return null;
}
```
### Mouse-Reactive Particles
```tsx
function ReactiveParticles() {
const points = useRef<THREE.Points>(null);
useFrame(({ pointer }) => {
if (points.current) {
// Tilt particle field based on mouse position
points.current.rotation.x = pointer.y * 0.1;
points.current.rotation.y = pointer.x * 0.1;
}
});
return <points ref={points}>{/* ... geometry & material */}</points>;
}
```
### Scroll-Driven 3D Scene
Using Framer Motion's `useScroll` to drive Three.js animations:
```tsx
import { useScroll } from 'framer-motion';
import { useFrame } from '@react-three/fiber';
import { useRef, useEffect, useState } from 'react';
function ScrollScene() {
const [scrollProgress, setScrollProgress] = useState(0);
// In the HTML component wrapping the Canvas:
// const { scrollYProgress } = useScroll();
// useMotionValueEvent(scrollYProgress, 'change', setScrollProgress);
// Pass scrollProgress as a prop or via context to the 3D component
const groupRef = useRef<THREE.Group>(null);
useFrame(() => {
if (groupRef.current) {
groupRef.current.rotation.y = scrollProgress * Math.PI * 2;
groupRef.current.position.y = scrollProgress * -5;
}
});
return <group ref={groupRef}>{/* ... scene content */}</group>;
}
```
### GSAP ScrollTrigger + Three.js
```tsx
import { useEffect, useRef } from 'react';
import { useThree } from '@react-three/fiber';
import gsap from 'gsap';
import { ScrollTrigger } from 'gsap/ScrollTrigger';
gsap.registerPlugin(ScrollTrigger);
function ScrollTriggered3D() {
const { camera } = useThree();
useEffect(() => {
const tl = gsap.timeline({
scrollTrigger: {
trigger: '#features-section',
start: 'top center',
end: 'bottom center',
scrub: 1,
},
});
tl.to(camera.position, { z: 3, y: 2, duration: 1 });
tl.to(camera.rotation, { x: -0.3, duration: 1 }, '<');
return () => { tl.kill(); };
}, [camera]);
return null;
}
```
---
## Performance Optimization
### Geometry & Material Optimization
```tsx
// GOOD: Share geometries and materials across instances
const sharedGeometry = new THREE.IcosahedronGeometry(1, 1);
const sharedMaterial = new THREE.MeshStandardMaterial({ color: '#6366f1' });
function OptimizedShapes() {
return (
<>
{positions.map((pos, i) => (
<mesh key={i} position={pos} geometry={sharedGeometry} material={sharedMaterial} />
))}
</>
);
}
// EVEN BETTER: Use InstancedMesh for many identical objects
function InstancedShapes({ count = 100 }) {
const meshRef = useRef<THREE.InstancedMesh>(null);
const dummy = useMemo(() => new THREE.Object3D(), []);
useEffect(() => {
for (let i = 0; i < count; i++) {
dummy.position.set(
(Math.random() - 0.5) * 10,
(Math.random() - 0.5) * 10,
(Math.random() - 0.5) * 10,
);
dummy.updateMatrix();
meshRef.current?.setMatrixAt(i, dummy.matrix);
}
meshRef.current!.instanceMatrix.needsUpdate = true;
}, [count, dummy]);
return (
<instancedMesh ref={meshRef} args={[sharedGeometry, sharedMaterial, count]} />
);
}
```
### Dynamic Import for 3D Components
```tsx
import dynamic from 'next/dynamic';
const HeroScene = dynamic(() => import('@/components/three/HeroScene'), {
ssr: false, // Three.js requires browser APIs
loading: () => <div className="h-screen bg-[#050510]" />,
});
```
### Performance Monitoring
```tsx
import { useFrame } from '@react-three/fiber';
import { useRef } from 'react';
function PerformanceMonitor() {
const frameCount = useRef(0);
const lastTime = useRef(performance.now());
useFrame(() => {
frameCount.current++;
const now = performance.now();
if (now - lastTime.current >= 1000) {
const fps = frameCount.current;
if (fps < 30) {
console.warn(`Low FPS: ${fps} — consider reducing scene complexity`);
}
frameCount.current = 0;
lastTime.current = now;
}
});
return null;
}
```
### Performance Checklist
| Optimization | Impact | How |
|-------------|--------|-----|
| `dpr={[1, 2]}` on Canvas | High | Limits pixel ratio to 2x max |
| `frameloop="demand"` | High | Only render when needed |
| InstancedMesh | High | For many identical objects |
| Shared geometry/materials | Medium | Reduce GPU memory |
| Low-poly geometry | Medium | < 10k triangles per mesh |
| Draco compression for models | Medium | 80-90% smaller file size |
| `dispose()` on unmount | Medium | Prevent memory leaks |
| Texture compression (WebP, basis) | Medium | Smaller download, faster load |
| Frustum culling (default on) | Low | Skip off-screen objects |
---
## Responsive 3D
### Device Detection
```tsx
import { useEffect, useState } from 'react';
function useDeviceCapability() {
const [capability, setCapability] = useState<'high' | 'medium' | 'low'>('high');
useEffect(() => {
const cores = navigator.hardwareConcurrency || 2;
const isMobile = /Android|iPhone|iPad/.test(navigator.userAgent);
const hasWebGL2 = !!document.createElement('canvas')
.getContext('webgl2');
if (isMobile || cores <= 2 || !hasWebGL2) {
setCapability('low');
} else if (cores <= 4) {
setCapability('medium');
} else {
setCapability('high');
}
}, []);
return capability;
}
```
### Adaptive Scene Complexity
```tsx
function AdaptiveScene() {
const capability = useDeviceCapability();
return (
<Canvas
dpr={capability === 'low' ? [1, 1] : [1, 2]}
frameloop={capability === 'low' ? 'demand' : 'always'}
>
<Suspense fallback={null}>
{capability === 'high' && (
<>
<ParticleField count={1000} />
<PostEffects />
</>
)}
{capability === 'medium' && (
<ParticleField count={300} />
)}
{capability === 'low' && (
<SimpleRotatingShape />
)}
<HeroGeometry detail={capability === 'high' ? 2 : 0} />
</Suspense>
</Canvas>
);
}
```
---
## Loading & Error Handling
### Canvas Suspense Pattern
```tsx
function Scene3D() {
return (
<div className="relative h-screen">
{/* Loading skeleton shown during 3D init */}
<div className="absolute inset-0 bg-[#050510] animate-pulse" />
<Canvas>
<Suspense fallback={<LoadingIndicator />}>
<SceneContent />
</Suspense>
</Canvas>
</div>
);
}
function LoadingIndicator() {
// This renders inside the Canvas as 3D content
return (
<mesh>
<sphereGeometry args={[0.5, 16, 16]} />
<meshBasicMaterial color="#6366f1" wireframe />
</mesh>
);
}
```
### WebGL Error Boundary
```tsx
import { Component, ReactNode } from 'react';
class WebGLErrorBoundary extends Component<
{ children: ReactNode; fallback: ReactNode },
{ hasError: boolean }
> {
state = { hasError: false };
static getDerivedStateFromError() {
return { hasError: true };
}
componentDidCatch(error: Error) {
console.error('WebGL Error:', error);
}
render() {
if (this.state.hasError) {
return this.props.fallback;
}
return this.props.children;
}
}
// Usage
<WebGLErrorBoundary fallback={<CSSAnimatedBackground />}>
<Canvas>
<Scene />
</Canvas>
</WebGLErrorBoundary>
```
### WebGL Feature Detection
```tsx
function useWebGLSupport() {
const [supported, setSupported] = useState(true);
useEffect(() => {
try {
const canvas = document.createElement('canvas');
const gl = canvas.getContext('webgl2') || canvas.getContext('webgl');
setSupported(!!gl);
} catch {
setSupported(false);
}
}, []);
return supported;
}
```
---
## Model Loading
### Loading glTF/GLB Models
```tsx
import { useGLTF } from '@react-three/drei';
function ProductModel({ url }: { url: string }) {
const { scene } = useGLTF(url);
return <primitive object={scene} scale={1} position={[0, 0, 0]} />;
}
// Preload to start downloading immediately
useGLTF.preload('/models/product.glb');
```
### Model with Animation
```tsx
import { useGLTF, useAnimations } from '@react-three/drei';
import { useEffect } from 'react';
function AnimatedModel({ url }: { url: string }) {
const { scene, animations } = useGLTF(url);
const { actions } = useAnimations(animations, scene);
useEffect(() => {
actions['idle']?.play();
}, [actions]);
return <primitive object={scene} />;
}
```
### Model Optimization Checklist
| Step | Tool | Impact |
|------|------|--------|
| Export as GLB (binary glTF) | Blender / any 3D tool | Smaller file, single file |
| Apply Draco compression | `gltf-pipeline` CLI | 80–90% size reduction |
| Reduce polygon count | Blender decimate modifier | Faster rendering |
| Bake textures to single atlas | Blender | Fewer draw calls |
| Use power-of-2 textures | Image editor | GPU-optimal |
| Max texture size: 2048×2048 | Image editor | Balance quality/performance |
```bash
# Draco compress a GLB file
npx gltf-pipeline -i model.glb -o model-compressed.glb --draco.compressionLevel 7
```
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deployment | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |