Skip to main content
skill CX Codex

r3f-fundamentals · bbeierle12 — Claude Code skill: what it does, how to install

r3f-fundamentals guides setup of React Three Fiber scenes, Canvas configuration, lighting, camera rigs, and render loop logic in declarative JSX.

MIT 125 installs ★ 9 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add Bbeierle12/Skill-MCP-Claude --skill r3f-fundamentals -a claude-code
Open on GitHub

What r3f-fundamentals does

This skill supplies core patterns for React Three Fiber projects. It shows the coding assistant how Three.js imperative calls map to React JSX nodes, handling automatic memory disposal on unmount and scene graph nesting via standard component tags.

It covers Canvas properties, including WebGL renderer settings, DPR clamping, shadow map setup, and switching between perspective or orthographic cameras. It also outlines the three frameloop modes (always, demand, never) and details light components like directionalLight and spotLight.

For animations, the skill documents useFrame usage, delta timing, and execution priorities. Keep in mind that these patterns expect @react-three/fiber installed in your project workspace.

What it helps with

  • Configure the Canvas component with custom WebGL flags, DPR ranges, and shadow support
  • Structure nested scene graphs using group and mesh containers in JSX
  • Implement on-demand rendering with manual invalidate triggers to save GPU resources
  • Animate 3D meshes per frame using delta time inside the useFrame hook
  • Position lights and shadow cameras for directional and point light sources

Example prompts for the agent

  • Configure a responsive Canvas with demand frameloop and custom camera FOV
  • Create a reusable rotating mesh component animated with useFrame and delta time
  • Set up directional lighting with castShadow and shadow-camera boundary props

How to install r3f-fundamentals

1Skills CLI (Vercel)

npx skills add Bbeierle12/Skill-MCP-Claude --skill r3f-fundamentals -a claude-code

2Manually: put the files in place

~/.claude/skills/r3f-fundamentals/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/r3f-fundamentals/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about r3f-fundamentals

How to install r3f-fundamentals in Claude Code?

Run npx skills add Bbeierle12/Skill-MCP-Claude --skill r3f-fundamentals -a claude-code. The file will be placed in ~/.claude/skills/r3f-fundamentals/SKILL.md.

What does r3f-fundamentals do?

It provides foundational knowledge for React Three Fiber: scene setup, Canvas options, camera management, lights, and declarative Three.js conventions.

When does the skill recommend using frameloop demand?

For static scenes that do not require continuous frame loops, redrawing only when state changes or when invalidate() is explicitly called.

Source text

SKILL.md · MIT
---
name: r3f-fundamentals
description: React Three Fiber core setup, Canvas configuration, scene hierarchy, camera systems, lighting, render loop, and React integration patterns. Use when setting up a new R3F project, configuring the Canvas component, managing scene structure, or understanding the declarative Three.js-in-React paradigm. The foundational skill that all other R3F skills depend on.
---

# React Three Fiber Fundamentals

Declarative Three.js via React components. R3F maps Three.js objects to JSX elements with automatic disposal, reactive updates, and React lifecycle integration.

## Quick Start

```tsx
import { Canvas } from '@react-three/fiber';

function App() {
  return (
    <Canvas>
      <ambientLight intensity={0.5} />
      <pointLight position={[10, 10, 10]} />
      <mesh>
        <boxGeometry args={[1, 1, 1]} />
        <meshStandardMaterial color="hotpink" />
      </mesh>
    </Canvas>
  );
}
```

## Core Principle: Declarative Scene Graph

R3F converts Three.js imperative API to React's declarative model:

| Three.js (Imperative) | R3F (Declarative) |
|----------------------|-------------------|
| `new THREE.Mesh()` | `<mesh>` |
| `mesh.position.set(1, 2, 3)` | `<mesh position={[1, 2, 3]}>` |
| `scene.add(mesh)` | JSX nesting handles hierarchy |
| `mesh.geometry.dispose()` | Automatic on unmount |

## Canvas Configuration

```tsx
import { Canvas } from '@react-three/fiber';

<Canvas
  // Renderer settings
  gl={{ antialias: true, alpha: false, powerPreference: 'high-performance' }}
  dpr={[1, 2]}                    // Device pixel ratio range
  shadows                          // Enable shadow maps
  
  // Camera (default: PerspectiveCamera)
  camera={{ 
    fov: 75, 
    near: 0.1, 
    far: 1000, 
    position: [0, 0, 5] 
  }}
  
  // Or use orthographic
  orthographic
  camera={{ zoom: 50, position: [0, 0, 100] }}
  
  // Performance
  frameloop="demand"              // 'always' | 'demand' | 'never'
  performance={{ min: 0.5 }}      // Adaptive performance
  
  // Events
  onCreated={({ gl, scene, camera }) => {
    // Access Three.js objects after mount
  }}
  
  // Sizing
  style={{ width: '100vw', height: '100vh' }}
/>
```

### Frameloop Modes

| Mode | When to Use |
|------|-------------|
| `always` | Continuous animation (games, simulations) |
| `demand` | Static scenes, only re-render on state change |
| `never` | Manual control via `invalidate()` |

```tsx
// Demand mode with manual invalidation
import { useThree } from '@react-three/fiber';

function Controls() {
  const invalidate = useThree(state => state.invalidate);
  
  const handleDrag = () => {
    // Update state...
    invalidate(); // Request re-render
  };
}
```

## Scene Hierarchy

JSX nesting = Three.js parent-child relationships:

```tsx
<group position={[0, 2, 0]} rotation={[0, Math.PI / 4, 0]}>
  {/* Children inherit parent transforms */}
  <mesh position={[1, 0, 0]}>
    <sphereGeometry args={[0.5, 32, 32]} />
    <meshStandardMaterial color="blue" />
  </mesh>
  
  <mesh position={[-1, 0, 0]}>
    <boxGeometry args={[0.8, 0.8, 0.8]} />
    <meshStandardMaterial color="red" />
  </mesh>
</group>
```

### Common Container Components

```tsx
// Group: Transform container (no rendering)
<group position={[0, 0, 0]} />

// Object3D: Base class, rarely used directly
<object3D />

// Scene: Usually implicit (Canvas creates one)
<scene />
```

## Camera Systems

### Default Perspective Camera

```tsx
<Canvas camera={{ 
  fov: 75,              // Field of view (degrees)
  aspect: width/height, // Auto-calculated
  near: 0.1,            // Near clipping plane
  far: 1000,            // Far clipping plane
  position: [0, 5, 10]
}} />
```

### Custom Camera Component

```tsx
import { PerspectiveCamera } from '@react-three/drei';

function Scene() {
  return (
    <>
      <PerspectiveCamera 
        makeDefault           // Set as active camera
        fov={60} 
        position={[0, 2, 8]} 
      />
      {/* Scene contents */}
    </>
  );
}
```

### Camera Access

```tsx
import { useThree } from '@react-three/fiber';

function CameraController() {
  const { camera } = useThree();
  
  useEffect(() => {
    camera.lookAt(0, 0, 0);
  }, [camera]);
  
  return null;
}
```

## Lighting

### Light Types

```tsx
// Ambient: Uniform, directionless
<ambientLight intensity={0.4} color="#ffffff" />

// Directional: Sun-like, parallel rays
<directionalLight 
  position={[5, 10, 5]} 
  intensity={1} 
  castShadow 
/>

// Point: Radiates from position
<pointLight 
  position={[0, 5, 0]} 
  intensity={1} 
  distance={20}        // Range (0 = infinite)
  decay={2}            // Physical falloff
/>

// Spot: Cone-shaped
<spotLight 
  position={[0, 10, 0]} 
  angle={Math.PI / 6}  // Cone angle
  penumbra={0.5}       // Edge softness
  castShadow 
/>

// Hemisphere: Sky/ground gradient
<hemisphereLight 
  skyColor="#87ceeb" 
  groundColor="#362907" 
  intensity={0.6} 
/>
```

### Shadow Setup

```tsx
<Canvas shadows>
  <directionalLight
    castShadow
    position={[10, 10, 10]}
    shadow-mapSize={[2048, 2048]}
    shadow-camera-far={50}
    shadow-camera-left={-10}
    shadow-camera-right={10}
    shadow-camera-top={10}
    shadow-camera-bottom={-10}
  />
  
  <mesh castShadow>
    <boxGeometry />
    <meshStandardMaterial />
  </mesh>
  
  <mesh receiveShadow rotation={[-Math.PI / 2, 0, 0]} position={[0, -1, 0]}>
    <planeGeometry args={[20, 20]} />
    <meshStandardMaterial />
  </mesh>
</Canvas>
```

## Render Loop (useFrame)

`useFrame` runs every frame (60fps target). This is where animation happens.

```tsx
import { useFrame, useThree } from '@react-three/fiber';
import { useRef } from 'react';

function RotatingBox() {
  const meshRef = useRef<THREE.Mesh>(null!);
  
  useFrame((state, delta) => {
    // state: R3F state (camera, scene, clock, etc.)
    // delta: Time since last frame (seconds)
    
    meshRef.current.rotation.x += delta;
    meshRef.current.rotation.y += delta * 0.5;
  });
  
  return (
    <mesh ref={meshRef}>
      <boxGeometry />
      <meshNormalMaterial />
    </mesh>
  );
}
```

### useFrame State Object

```tsx
useFrame((state) => {
  state.clock        // THREE.Clock
  state.clock.elapsedTime  // Total time (seconds)
  state.camera       // Active camera
  state.scene        // Scene object
  state.gl           // WebGLRenderer
  state.size         // { width, height }
  state.viewport     // { width, height, factor, distance }
  state.mouse        // Normalized mouse position [-1, 1]
  state.raycaster    // THREE.Raycaster
});
```

### Render Priority

```tsx
// Lower priority runs first, higher runs later
// Default is 0

useFrame(() => {
  // Update physics
}, -1);  // Runs before default

useFrame(() => {
  // Update visuals
}, 0);   // Default

useFrame(() => {
  // Post-processing / camera
}, 1);   // Runs after default
```

## Accessing Three.js Objects

### useThree Hook

```tsx
import { useThree } from '@react-three/fiber';

function SceneInfo() {
  const { 
    gl,           // WebGLRenderer
    scene,        // THREE.Scene
    camera,       // Active camera
    size,         // Canvas dimensions
    viewport,     // Viewport in Three.js units
    clock,        // THREE.Clock
    set,          // Update state
    get,          // Get current state
    invalidate,   // Request re-render (demand mode)
    advance,      // Advance one frame (never mode)
  } = useThree();
  
  return null;
}
```

### Refs for Direct Access

```tsx
import { useRef } from 'react';
import * as THREE from 'three';

function DirectAccess() {
  const meshRef = useRef<THREE.Mesh>(null!);
  const materialRef = useRef<THREE.MeshStandardMaterial>(null!);
  
  useEffect(() => {
    // Direct Three.js API access
    meshRef.current.geometry.computeBoundingBox();
    materialRef.current.needsUpdate = true;
  }, []);
  
  return (
    <mesh ref={meshRef}>
      <boxGeometry />
      <meshStandardMaterial ref={materialRef} />
    </mesh>
  );
}
```

## Events

R3F provides pointer events on meshes:

```tsx
<mesh
  onClick={(e) => console.log('click', e.point)}
  onContextMenu={(e) => console.log('right click')}
  onDoubleClick={(e) => console.log('double click')}
  onPointerOver={(e) => console.log('hover')}
  onPointerOut={(e) => console.log('unhover')}
  onPointerDown={(e) => console.log('down')}
  onPointerUp={(e) => console.log('up')}
  onPointerMove={(e) => console.log('move')}
>
  <boxGeometry />
  <meshStandardMaterial />
</mesh>
```

### Event Object

```tsx
onClick={(e) => {
  e.stopPropagation();    // Stop event bubbling
  e.point                 // THREE.Vector3 intersection point
  e.distance              // Distance from camera
  e.object                // Intersected object
  e.face                  // Intersected face
  e.faceIndex             // Face index
  e.uv                    // UV coordinates
  e.camera                // Camera used for raycasting
  e.delta                 // Distance from last event
}}
```

## Suspense & Loading

R3F integrates with React Suspense for async loading:

```tsx
import { Suspense } from 'react';
import { useLoader } from '@react-three/fiber';
import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';

function Model() {
  const gltf = useLoader(GLTFLoader, '/model.glb');
  return <primitive object={gltf.scene} />;
}

function App() {
  return (
    <Canvas>
      <Suspense fallback={<LoadingSpinner />}>
        <Model />
      </Suspense>
    </Canvas>
  );
}

function LoadingSpinner() {
  const meshRef = useRef<THREE.Mesh>(null!);
  useFrame((_, delta) => {
    meshRef.current.rotation.z += delta * 2;
  });
  
  return (
    <mesh ref={meshRef}>
      <torusGeometry args={[1, 0.2, 16, 32]} />
      <meshBasicMaterial color="white" wireframe />
    </mesh>
  );
}
```

## Dependencies

```json
{
  "dependencies": {
    "@react-three/fiber": "^8.15.0",
    "three": "^0.160.0",
    "react": "^18.2.0",
    "react-dom": "^18.2.0"
  },
  "devDependencies": {
    "@types/three": "^0.160.0"
  }
}
```

## File Structure

```
r3f-fundamentals/
├── SKILL.md
├── references/
│   ├── canvas-props.md       # Complete Canvas prop reference
│   ├── hooks-api.md          # useThree, useFrame, useLoader
│   └── event-system.md       # Event handling deep-dive
└── scripts/
    ├── templates/
    │   ├── basic-scene.tsx   # Minimal starter
    │   ├── lit-scene.tsx     # With proper lighting
    │   └── interactive.tsx   # With events and animation
    └── utils/
        └── canvas-config.ts  # Preset configurations
```

## Reference

- `references/canvas-props.md` — Complete Canvas configuration options
- `references/hooks-api.md` — All R3F hooks with examples
- `references/event-system.md` — Pointer events and raycasting

© Bbeierle12 · MIT · Bbeierle12/Skill-MCP-Claude

Similar skills

All skills for Frontend and UI →

r3f-fundamentals by other authors comes first.

r3f-fundamentals EnzeD r3f-fundamentals — a skill that teaches the agent to build React Three Fiber scenes: Canvas, typed JSX, render-loop hooks, and resource ownership. For scene architecture, not detailed materials. CX Codex +1 2,400installs react-three-fiber Claude Design Skillstack A Claude plugin for 3D scenes built with React Three Fiber, the React renderer for Three.js. Scenes are components, with state and reusable abstractions. ★ 1,428repo stars r3f-best-practices three-agent-skills r3f-best-practices — a skill with 70+ rules for writing, reviewing, and optimizing React Three Fiber code. It prevents costly re-renders and organizes work with the Poimandres stack. CX Codex +1 1,700installs threejs-fundamentals calesthio threejs-fundamentals — a skill for building Three.js scenes, setting up cameras and renderers, and working with Object3D hierarchies and transforms. CX Codex +1 1,200installs r3f-postprocessing EnzeD r3f-postprocessing — a skill that walks the agent through postprocessing in React Three Fiber: glow on chosen meshes, depth of field, SSAO. Useful when the render looks off and you cannot pin down why. CX Codex +1 2,300installs r3f-loaders EnzeD r3f-loaders guides 3D asset loading and reuse in React Three Fiber. Helps set up hooks, preloading, scene cloning, and fallback UI. CX Codex +1 2,100installs threejs-r3f AThevon threejs-r3f is a Claude Code skill for building 3D scenes with Three.js and React Three Fiber. It covers shaders, postprocessing, and performance patterns. CX Codex +1 1,000installs

From the same set19

The whole set →
gsap-sequencing The gsap-sequencing skill guides complex GSAP timelines with labels, nested sequences, callbacks, and precise placement. Use it for coordinated UI motion. CX Codex +1 163installs audio-analysis audio-analysis is a Claude Code skill for inspecting audio with Tone.js and the Web Audio API. It supports work on visualizations, beat detection, and audio-reactive features. CX Codex +1 151installs software-architecture software-architecture — a skill that walks the agent through SOLID and Clean Architecture, with a bad and a good version of the same TypeScript code for each principle. CX Codex +1 150installs particles-physics particles-physics is a Claude Code skill that adds forces and velocity fields to particle motion in scenes with gravity, wind, attractors or turbulence. CX Codex +1 134installs shader-noise shader-noise is a Claude Code skill with GLSL noise algorithms for generating organic textures, terrain, clouds, fire, and cellular patterns in shaders. CX Codex +1 121installs form-ux-patterns The form-ux-patterns skill guides the design of complex forms with grouped fields, step-by-step flows, and conditional inputs. Use it for checkout or onboarding experiences. CX Codex +1 120installs audio-reactive audio-reactive maps audio analysis data to visual parameters, CSS transforms, and 3D scenes. CX Codex +1 108installs postfx-effects postfx-effects is a Claude Code skill with post-processing recipes for React Three Fiber scenes, including depth of field, chromatic aberration, vignette, and film grain. CX Codex +1 106installs

Project sponsors

Companies that keep this analytics open