# crucible (codepawl/crucible)

> 67js is a WebGL2 3D engine that AI agents can drive. A scene is plain data, and an agent builds and changes it through an MCP server, then checks PNG previews and renders stills or MP4 video.

- GitHub: https://github.com/codepawl/crucible
- GitHub.Locker page: https://github.locker/codepawl/crucible
- Stars: 752
- Language: JavaScript
- License: MIT
- Last push: 2026-11-17

## Questions and answers

Written by GitHub.Locker from the README and the repository; check the README below for details.

**Is it a standalone app or a library I import into my own project?**

It is a library. You import it into a web page as an ESM package and load only the addons you use. It also ships an MCP server so an agent can build scenes for you.

**How do I get it running?**

The easiest way is to paste the install prompt from the README into Claude Code, Codex, Cursor, Gemini CLI or OpenCode and let the agent install the package and connect the MCP server. By hand, install @codepawlhq/67js, which is imported under the alias 67js.

**What do I need first?**

Node.js 20.19 or later for the tools, a WebGL2-capable browser for rendering, and a local Chrome install for the MCP server.

**Does it match Blender or beat three.js?**

Not proven. The goal is to be as capable as Blender and as light as three.js, but the README says its benchmarks do not show a general speed advantage over three.js or visual parity with Blender.

**Where does it run?**

In the browser through WebGL2. The MCP server needs a local Chrome installation on the machine where it runs.

**Can I run it without a GPU?**

Yes. On a machine without a GPU, pass --backend cpu to the MCP server.

**What is the core idea behind 67js?**

A scene is plain data: each part has a geometry, a matrix and a material. An agent edits that data through a JSON recipe, so the server accepts no arbitrary code and no remote asset URLs.

**What can an agent actually do with it?**

It writes a JSON recipe, sets lights and fog, imports GLB assets, adds motion, and gets PNG previews back. It can compare up to four views in a review grid and run render jobs for stills and MP4 video.

**What do the addons cover?**

Terrain, vegetation, glTF characters with retargeting and IK, baked liquid, wheeled vehicles, Rapier physics, mesh modeling, path-traced stills and custom GLSL post passes.


---

## README (checked against GitHub 2026-11-18)

Source: https://github.com/codepawl/crucible/blob/main/README.md

<p align="center">
  <a href="https://crucible.codepawl.com">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://crucible.codepawl.com/brand/crucible-lockup-dark.png">
      <img alt="Crucible" src="https://crucible.codepawl.com/brand/crucible-lockup.png" width="360">
    </picture>
  </a>
</p>

<h3 align="center">Realtime 3D for the web, shaped by designers and AI agents</h3>

<p align="center">
  <a href="https://www.npmjs.com/package/@codepawlhq/crucible"><img alt="npm version" src="https://img.shields.io/npm/v/@codepawlhq/crucible?style=flat-square&label=npm&color=4f4e5a&labelColor=2a282d"></a>
  <a href="LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-4f4e5a?style=flat-square&labelColor=2a282d"></a>
  <img alt="Node.js 20.19 or later" src="https://img.shields.io/badge/node-%E2%89%A520.19-4f4e5a?style=flat-square&labelColor=2a282d">
  <img alt="MCP server for agents" src="https://img.shields.io/badge/agents-MCP%20server-4f4e5a?style=flat-square&labelColor=2a282d">
</p>

<p align="center">
  <a href="https://crucible.codepawl.com">Website</a> ·
  <a href="https://crucible.codepawl.com/docs.html">Docs</a> ·
  <a href="https://crucible.codepawl.com/showcase.html">Showcase</a> ·
  <a href="https://crucible.codepawl.com/llms.txt">Guide for agents</a> ·
  <a href="https://github.com/codepawl/crucible/blob/main/CHANGELOG.md">Changelog</a> ·
  <a href="https://github.com/codepawl/crucible/discussions">Discussions</a>
</p>

<p align="center">
  <a href="https://crucible.codepawl.com"><img src="https://crucible.codepawl.com/previews/hero-classroom.webp" alt="A sunlit classroom with wooden desks and chairs, a chalkboard and tall windows with blinds, path traced by Crucible" width="100%"></a>
  <br>
  <sub>Classroom by Christophe Seux, CC0, from the Blender demo files, path traced in Crucible with Cook</sub>
</p>

<p align="center">
  <img src="https://crucible.codepawl.com/previews/feature-clockwork.webp" alt="A gold and steel gyroscope with a glowing teal core, turning, rendered by Crucible" width="32%">
  <img src="https://crucible.codepawl.com/previews/feature-flicker-fixed.webp" alt="A low camera pan over a warehouse floor with yellow lines and racks, drawn without flicker" width="32%">
  <img src="https://crucible.codepawl.com/previews/feature-cook-dof.webp" alt="The native path tracer focusing from a red sphere in front to a gold and a purple sphere behind it" width="32%">
</p>

Crucible is a fast, lightweight realtime 3D engine for the web, with an MCP server for AI agents. It makes high-quality 3D easy to understand and easy to shape.

> **67js → Crucible.** 67js is the old name. The `@codepawlhq/67js` package is deprecated: install `@codepawlhq/crucible` instead. Old 67js.codepawl.com links redirect here.

AI agents carry the heavy technical setup: geometry, modifiers, lighting, checks and exports. Designers keep creative control of framing, form, lighting and materials on the same scene recipe, delivering fast web embeds within strict byte and memory budgets.

Scenes built with Crucible open live in the browser on the [showcase](https://crucible.codepawl.com/showcase.html).

## Gallery

<p align="center">
  <a href="https://crucible.codepawl.com/showcase.html?scene=airport"><img src="https://crucible.codepawl.com/previews/showcase-airport.webp" alt="Airport ramp, rendered by Crucible" width="49%"></a>
  <a href="https://crucible.codepawl.com/showcase.html?scene=port"><img src="https://crucible.codepawl.com/previews/showcase-port.webp" alt="Container port, rendered by Crucible" width="49%"></a>
  <a href="https://crucible.codepawl.com/showcase.html"><img src="https://crucible.codepawl.com/previews/cook-monk.webp" alt="A monastery courtyard with a stone well, seen from a desk with an open book, path traced by Cook" width="49%"></a>
  <a href="https://crucible.codepawl.com/object.html"><img src="https://crucible.codepawl.com/previews/wall-e.webp" alt="A robot model in the object studio, rendered by Crucible" width="49%"></a>
</p>

Made something with Crucible? [Post it in Show and tell](https://github.com/codepawl/crucible/discussions/new?category=show-and-tell). We feature picked work on the [showcase](https://crucible.codepawl.com/showcase.html#community), with credit.

## What it is

Crucible is a realtime 3D engine for designers, web pages and AI agents. It has a fast WebGL2 rasterizer, a path tracer, addons for terrain, vegetation, characters, liquid, vehicles and media export, and an MCP server. A scene is plain data: each part has a geometry, a matrix and a material.

Designers shape composition, lighting and materials directly alongside agents building through the MCP server. Exported scenes stay lightweight on the web and keep strict runtime budgets. [docs/goal.md](https://github.com/codepawl/crucible/blob/main/docs/goal.md) defines each part.
See the [documentation](https://crucible.codepawl.com/docs.html), the [guide for agents](https://crucible.codepawl.com/llms.txt) and the [FAQ](https://crucible.codepawl.com/docs.html#faq).

## Install

**Let your agent do it.** Paste this prompt into Claude Code, Codex, Cursor, Gemini CLI or OpenCode. The agent installs the package, reads the guide and connects the MCP server.

```text
Install Crucible from npm as `crucible@npm:@codepawlhq/crucible` and connect its MCP server with `npx crucible-mcp`. Read
https://crucible.codepawl.com/llms.txt first and follow it.
```

**Claude Code plugin.** One command adds the MCP server and both skills.

```text
/plugin marketplace add codepawl/crucible
/plugin install crucible@crucible
```

**By hand**

```sh
npm install crucible@npm:@codepawlhq/crucible
```

The registry name is `@codepawlhq/crucible`, and the alias `crucible` keeps imports short. The package is ESM and needs Node.js 20.19 or later. Glaze and the WebGL2 path tracer need a WebGL2 browser, and the WebGPU backends need WebGPU.

A new minor version ships about once a week. Before 1.0, a minor version can change the API, and [CHANGELOG.md](https://github.com/codepawl/crucible/blob/main/CHANGELOG.md) lists each change. npx keeps the copy it downloaded first. To update, run `npm install crucible@npm:@codepawlhq/crucible@latest` or `npx -y -p @codepawlhq/crucible@latest crucible-mcp`.

## Quick start

```js
import { CrucibleRenderer, box, sphere } from 'crucible';

// Column-major 4x4 matrix: scale, then move.
const placed = ([x, y, z], [width, height, depth] = [1, 1, 1]) =>
  new Float32Array([width, 0, 0, 0, 0, height, 0, 0, 0, 0, depth, 0, x, y, z, 1]);

const parts = [
  {
    name: 'Floor',
    geometry: box(),
    matrix: placed([0, 0, 0], [8, 0.1, 8]),
    material: { color: [0.4, 0.42, 0.45], metallic: 0, roughness: 0.9, emission: 0 },
  },
  {
    name: 'Ball',
    geometry: sphere(48, 24),
    matrix: placed([0, 1, 0]),
    material: { color: [0.8, 0.3, 0.2], metallic: 0, roughness: 0.35, emission: 0 },
  },
];

const canvas = document.querySelector('canvas');
const renderer = new CrucibleRenderer(canvas, parts, { samples: 4, memoryBudgetMiB: 256 });
renderer.render({ eye: [4, 3, 6], target: [0, 1, 0] });
```

Call `renderer.updateParts(parts)` to move or recolour parts without a new upload.
Call `renderer.resize()` after the canvas changes size, and `renderer.dispose()` before you replace the renderer.
The [guide](docs/guide.md) covers cameras, lights, effects and every material field.
To save a PNG from a script, use the [render-from-a-script recipe](docs/guide.md#render-a-png-from-a-script-without-mcp).

## For agents

The package includes an MCP server that connects an agent to a persistent browser renderer.
The server needs a local Chrome installation.

```sh
npx crucible-mcp --backend gpu --memory 192
```

`--backend gpu` renders with hardware WebGL2 through Chrome. Use `--backend cpu` on a machine without a GPU.
With bun, `bunx crucible-mcp` takes the same flags; CI runs the packaged server under bun on every pull request.
An agent authors a [JSON recipe](docs/agent-scene.md), sets [lights and fog](docs/agent-look.md), imports [GLB assets](docs/agent-asset.md) and adds [motion](docs/agent-motion.md).
It gets PNG previews back, compares up to four views in a [review grid](docs/agent-review.md) and runs [render jobs](docs/agent-render-jobs.md) for stills and MP4 video.
The server accepts no arbitrary code and no remote asset URLs. The [MCP reference](docs/mcp.md) lists its tools.

Two skills teach an agent to drive the MCP tools: [build-crucible-scene](skills/build-crucible-scene/SKILL.md) for scenes and materials, and [render-crucible-media](skills/render-crucible-media/SKILL.md) for image and video export.
For a plain-text guide, give the agent [llms.txt](https://crucible.codepawl.com/llms.txt).

[viz3d](https://github.com/codepawl/viz3d) uses Crucible. It is a skill that turns places, systems and events into 3D apps and films, and it renders its films and stills in Crucible.
To add it in Claude Code, run `/plugin marketplace add codepawl/viz3d`, then `/plugin install visualize-in-3d@codepawl`.

## Render images and video

The render command exports a scene to PNG or MP4 through headless Chrome, on the GPU or on the CPU.

```sh
npm run render -- --kind image --scene nature --backend gpu --preset high --output artifacts/nature.png
```

Video export streams one frame at a time, so a film never sits in memory.
The [render skill](skills/render-crucible-media/SKILL.md) lists every preset and flag.

## Addons

Each addon is a separate import, so a page loads only what it uses.

| Area | Import | Guide |
| --- | --- | --- |
| Lighting | `crucible/addons/hdri` | [Image-based lighting](docs/lighting.md) from `.hdr` files |
| Terrain | `crucible/addons/terrain`, `crucible/addons/texture-set` | [Chunked terrain](https://crucible.codepawl.com/terrain.md) with scanned ground layers |
| Vegetation | `crucible/addons/vegetation`, `crucible/addons/grass`, `crucible/addons/clutter` | [Trees](https://crucible.codepawl.com/vegetation.md), [grass](https://crucible.codepawl.com/grass.md) and [ground clutter](https://crucible.codepawl.com/clutter.md) with wind and level of detail |
| Characters | `crucible/addons/gltf`, `crucible/addons/retarget`, `crucible/addons/skeleton-pose` | [glTF import](docs/gltf.md), [clip retargeting](https://crucible.codepawl.com/retarget.md) and [pose layers with IK](docs/skeleton-pose.md) |
| Liquid | `crucible/addons/spume` | [Baked liquid playback](https://crucible.codepawl.com/spume.md) with refraction and spray |
| Vehicles | `crucible/addons/vehicle` | [Wheeled vehicles on a path](https://crucible.codepawl.com/vehicle.md) |
| Physics | `crucible/addons/physics` | [Rapier contacts and joints](docs/physics.md) recorded into a timeline |
| Live games | `crucible/addons/runtime` | [Game loop](docs/runtime.md) with fixed or variable steps and pluggable systems |
| Live games | `crucible/addons/input` | [Input](docs/input.md): keyboard, mouse, gamepad, touch, device motion, replay and custom sources mapped to named actions and axes |
| Live games | `crucible/addons/streaming` | [Streaming](docs/streaming.md): loader plugins, distance and request loading, a byte budget with LRU eviction and LOD with hysteresis |
| Live games | `crucible/addons/netcode` | [Netcode](docs/netcode.md): server or host authority, pluggable transports, delta snapshots, client prediction with reconciliation and remote interpolation |
| Live games | `crucible/addons/physics-runtime` | [Live physics](docs/physics-runtime.md): a physics world stepped in the game loop, contact and sensor events, ray, shape and overlap queries |
| Live games | `crucible/addons/physics-jolt` | [Jolt engine](docs/physics-runtime.md#jolt): a second engine for live physics, with the same events and queries; needs the optional `jolt-physics` package |
| Live games | `crucible/addons/audio` | [Spatial audio](docs/audio.md): sounds on nodes, played from contacts, markers and input, with buses and a limiter |
| Live games | `crucible/addons/animation-graph` | [Animation graph](docs/animation-graph.md): states, 1D and 2D blend spaces, parameter transitions with crossfades and masked layers for any rig |
| Live games | `crucible/addons/player` | [Player](docs/player.md): character, vehicle and flight controllers, follow, first-person, top-down, orbit, chase and side-scroller camera rigs with wall pull-in, custom kinds, swappable at runtime |
| Live games | `crucible/addons/game-rules` | [Game rules](docs/game-rules.md): a JSON rule document of variables, triggers and actions, played as a runtime system |
| Live games | `crucible/addons/game` | [Game](docs/game.md): a scene recipe with a `game` section played in a page, and the `scene_export_web` MCP tool that writes it as a static web build |
| Modeling | `crucible/addons/mesh`, `crucible/addons/modeling`, `crucible/addons/sculpt` | [Mesh editing](docs/mesh.md), [modeling](docs/modeling.md) and [sculpt brushes](https://crucible.codepawl.com/sculpt.md) |
| Offline light | `crucible/addons/path-tracer`, `crucible/addons/light-bake` | [Path-traced stills](https://crucible.codepawl.com/path-tracer.md) and [baked lightmaps](https://crucible.codepawl.com/light-bake.md) |
| Post passes | `crucible/addons/user-pass` | [Your own full-screen GLSL passes](docs/user-passes.md): dither, pixel downscale, quantise |
| Agents | `crucible/addons/agent-scene`, `crucible/addons/agent-asset` | [Scene sessions](docs/agent-scene.md) with revisions and checkpoints |

The [documentation page](https://crucible.codepawl.com/docs.html) lists every guide.

## Renderers

| Name | What it is | Runs on |
| --- | --- | --- |
| Glaze (`CrucibleRenderer`) | The real-time rasterizer | WebGL2 |
| Cook | The path tracer, one still per job | CPU (default), WebGL2, Vulkan ray queries through the optional Cook package (`@codepawlhq/cook`), and WebGPU (opt-in, library only) |
| Real-time path tracer | A hybrid tracer with a radiance cache and a temporal denoiser. It is experimental, and the MCP server does not expose it | WebGPU, with a WebGL2 fallback |
| Light bake | Baked lightmaps | CPU, WebGL2 and WebGPU |

The WebGPU backend of Cook traces a BVH in WGSL compute, because browsers have no hardware ray tracing.
MCP render jobs take the Cook backends cpu, gpu and native only.

## Quality tiers

The roadmap in [issue 890](https://github.com/codepawl/crucible/issues/890) groups the renderers into four tiers.
The tier names are working names.
The `quality` setting that picks a tier ships: `scene_render_submit` takes `settings.quality` ([Render quality](docs/mcp.md#render-quality)).
Refine-at-rest is planned ([issue 903](https://github.com/codepawl/crucible/issues/903)).
The path tracer planned for realtime-high does not exist yet ([issue 901](https://github.com/codepawl/crucible/issues/901) and [issue 902](https://github.com/codepawl/crucible/issues/902)).

Six scenes at 960x540, medians over 3 interleaved runs on an idle card.
FLIP is the error against a Cycles 4096-sample reference, and lower is better.
Every value is the range of the per-scene medians across the six scenes.
The full per-scene tables are in the [bench/tiers folder](https://github.com/codepawl/crucible/blob/main/bench/tiers/results/matrix-960.table.md). They land with [pull request 931](https://github.com/codepawl/crucible/pull/931), after [pull request 921](https://github.com/codepawl/crucible/pull/921) and before this one.

<!-- tiers-table:start -->

| Tier | For | Runs on | Trade-off | Crucible measured | Blender measured | FLIP vs Cycles |
| --- | --- | --- | --- | --- | --- | --- |
| draft | A quick look while editing | Glaze, 0.5 render scale, 1 sample, light shading, 8 bit target | Aliased edges, no environment lookup, a quarter of the pixels enlarged | 0.54 to 1.04 ms a frame with the pixel read; 0.26 to 0.33 ms queued back to back | EEVEE 5.3, 1 sample: 56 to 59 ms a render call | Glaze 0.045 to 0.188, EEVEE 0.041 to 0.562 |
| realtime | Interactive use | Glaze, default settings | Indirect light is approximate | 0.77 to 0.98 ms a frame with the pixel read; 0.35 to 0.50 ms queued back to back | EEVEE 5.3, 64 samples: 288 to 363 ms a render call | Glaze 0.030 to 0.197, EEVEE 0.042 to 0.562 |
| realtime-high | Better interactive frames | Planned: Glaze on WebGPU with a GI cache and upscaling ([issue 901](https://github.com/codepawl/crucible/issues/901), [issue 902](https://github.com/codepawl/crucible/issues/902)) | More VRAM | not measurable yet | none | none |
| final | Finished stills | Cook native, 256 samples (Vulkan ray queries, the optional `@codepawlhq/cook` package) | More samples than Cycles for the same noise | 1.73 to 4.24 ms a sample; 0.71 to 1.32 s for 256 samples with setup | Cycles 5.3 OptiX: 6.81 to 26.41 ms a sample; 3.43 to 8.46 s for 256 samples with setup | Cook native 0.019 to 0.080, Cycles 0.010 to 0.039 |
| final | Finished stills | Cook webgpu, 256 samples (WGSL compute, software BVH, library only) | Slower per sample than native, same image | 5.88 to 17.33 ms a sample; 1.94 to 4.86 s for 256 samples with setup | same Cycles | Same as native: FLIP between the two images 0.0000 to 0.0003 |

<!-- tiers-table:end -->

Glaze runs the realtime tier in under about 1 ms a frame at 960x540 on these scenes (0.77 to 0.98 ms), measured with a pixel read.
The EEVEE times are one full background render call, including scene sync, with EEVEE ray tracing off and no global illumination.
They are not a frame rate comparison.
The draft tier is not faster than realtime here. At 960x540 a Glaze frame costs about as much as the browser pixel read, so the queued figures are the ones that differ.

Cook native draws a sample 3.8 to 6.2 times faster than Cycles 5.3 OptiX, but needs more samples for the same noise.
On the three noise-limited scenes (lit-interior, spot-area and light-linking) it needs 6.6 to 19.0 times Cycles' samples for the same error.
That makes it 1.05 to 4.02 times Cycles' time for the sampling alone, and 0.87 to 2.52 times with setup included.

On metal, glass and outdoor-hdri the error falls slower than 1/N between 256 and 1024 samples, which points to bias.
Cook does not reach Cycles' error there, so no equal-error ratio is given.
Cook webgpu draws a sample 3.3 to 4.1 times slower than native.

Cook gpu (WebGL2) and Cook cpu are not in this run.
Cook cpu needs no card, so VRAM does not apply.
[docs/cycles-parity.md](https://github.com/codepawl/crucible/blob/main/docs/cycles-parity.md) has the Cook against Cycles method on one scene.

The experimental real-time path tracer is not the realtime-high tier.
These figures come from lit-interior only, measured before the idle gate with the card 17 to 20 percent busy.
On the WebGPU backend it draws a frame in 5.6 ms.
FLIP drops under 0.20 after 16 frames (0.15 s) and under 0.10 after 64 frames (0.41 s).
It ends at 0.056 after 256 frames.

The WebGL2 fallback takes 6.7 ms per frame and 6.1 s for the first frame, which includes shader compile.
It runs at 2 bounces against an 8-bounce reference.

Machine: RTX 3060 12 GB (driver 621.14), Intel i7-14700KF, Chrome 157 headless on D3D11, Node 24, Blender 5.3, measured 2026-11-11.
The card was idle: each run waited for at most 15 percent utilisation, and 0 of 162 runs were contended.

## Performance

Each number below comes from this repository's benchmarks.

- **Bundle size.** On `lit-box`, Crucible is 58,788 bytes gzip and three.js is 133,797 (2.28 times smaller). This is the `npm run size` result on 2026-11-11. The goal of 50,000 bytes is not met yet. [bench/size/README.md](https://github.com/codepawl/crucible/blob/main/bench/size/README.md) has every scene.
- **Path tracing on the GPU.** One run on 2026-11-03, on a shared machine, traced the 1920 by 1080 demo room (181,708 triangles, 64 samples, 8 bounces). The 8-thread CPU tracer took 585.9 s. The WebGL2 GPU tracer took 58.15 s, and that figure includes 10.3 s of shader compile. Whether the CPU figure is end to end is not recorded, so read the two as separate figures, not a speedup. [docs/webgpu-decision.md](https://github.com/codepawl/crucible/blob/main/docs/webgpu-decision.md) has the method.
- **Cook against Cycles.** See [Quality tiers](#quality-tiers) and [docs/cycles-parity.md](https://github.com/codepawl/crucible/blob/main/docs/cycles-parity.md).

[docs/verification.md](docs/verification.md) has older results and their limits.
They compare matching scenes on the same hardware. They do not show a general speed advantage over three.js or visual parity with Blender.

## Run the site locally

1. Install Node.js 22.12 or later.
2. Run `npm ci`.
3. Run `npm run dev`. Vite prints the local URL.

## Contributing

Read [CONTRIBUTING.md](https://github.com/codepawl/crucible/blob/main/CONTRIBUTING.md) before you open a pull request. It covers setup, checks, code style and the release flow.
Coding agents start with [AGENTS.md](https://github.com/codepawl/crucible/blob/main/AGENTS.md), and `npm run preflight` runs the pull request checks locally.
Questions and ideas go in [Discussions](https://github.com/codepawl/crucible/discussions), and what you made goes in [Show and tell](https://github.com/codepawl/crucible/discussions/new?category=show-and-tell). Bug reports: [SUPPORT.md](https://github.com/codepawl/crucible/blob/main/.github/SUPPORT.md).

## Sponsors

Crucible is free and MIT licensed. [Sponsors](https://github.com/sponsors/codepawl) pay for GPU time, test hardware and the hours that go into it.
Company sponsors get their logo here from $100 a month.

[![Sponsor CodePawl](https://img.shields.io/badge/Sponsor-CodePawl-4f4e5a?style=for-the-badge&logo=githubsponsors&logoColor=white&labelColor=2a282d)](https://github.com/sponsors/codepawl)

## Credits

- [gl-matrix](https://github.com/toji/gl-matrix) supplies the matrix math.
- The glTF addon has its own parser. The Draco, meshopt and KTX2 decoders are [three.js](https://threejs.org/) loaders that you pass in.
- The textures and the HDRI on the site are CC0 scans from [Poly Haven](https://polyhaven.com) and [ambientCG](https://ambientcg.com). See [the texture credits](https://github.com/codepawl/crucible/blob/main/public/textures/CREDITS.md).
- The Bistro renders use [Amazon Lumberyard Bistro](https://developer.nvidia.com/orca/amazon-lumberyard-bistro) (CC BY 4.0, from the NVIDIA ORCA library) under a CC0 [Poly Haven](https://polyhaven.com/a/kloofendal_48d_partly_cloudy_puresky) sky.
- The showcase models and their sources are listed in each world's `scene.json` under `public/showcase/`.
- The Crucible and CodePawl wordmarks use [Plus Jakarta Sans](https://fonts.google.com/specimen/Plus+Jakarta+Sans) (SIL Open Font License).

## License

[MIT](LICENSE) © CodePawl

<br>

<p align="center">
  <a href="https://codepawl.com">
    <picture>
      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/codepawl/crucible/main/public/brand/codepawl-lockup-dark.png">
      <img alt="CodePawl" src="https://raw.githubusercontent.com/codepawl/crucible/main/public/brand/codepawl-lockup.png" width="180">
    </picture>
  </a>
  <br>
  <sub>Crucible is made by CodePawl, an independent 3D studio in Vietnam.</sub>
  <br>
  <sub>
    <a href="https://x.com/codepawl">X</a> ·
    <a href="https://github.com/codepawl">GitHub</a> ·
    <a href="https://www.youtube.com/@codepawlhq">YouTube</a> ·
    <a href="https://www.threads.com/@codepawl">Threads</a>
  </sub>
</p>

