Alchemy · Photoreal seamless PBR textures

Turn noise into matter.

Alchemy is a GPU texture lab for games and 3D. Stack generators, filters and AI images into photoreal materials that tile perfectly, and take home every PBR map your engine wants, up to 8192².

A Windows desktop app and a browser app · runs locally on your GPU

Turn the dials. Get a different material.

Every generator exposes its own parameters as inspector controls, plus a seed, per-feature tone variation, macro mottling, a secondary gradient and tile-safe transforms. Here is what a few dial changes do. Each image lists the exact settings used.

Settings are named exactly as they appear in the app.

A full PBR pack, every time

One stack in. Every map out.

Color, height, roughness and metalness are composited through the stack together, and the rest is derived on the GPU from the result. Pick a material and a map below.

Base color

sRGB albedo with color variation per feature, macro mottling and an Oklab check against real-world albedo ranges.

Normal

Sobel normals from the composited height, wraparound-safe, in OpenGL or DirectX convention per engine.

Roughness & metalness

Painted per layer and composited like height: rust is rough and dielectric over smooth steel, wet patches turn glossy.

AO, height, depth, specular

Ambient occlusion and the other derived maps come from the same relief, resolution-independent.

Emissive, opacity, anisotropy, sheen

Neon and lit windows glow, leaves and fences cut out, brushed metal and hair stretch highlights, velvet catches grazing light.

Seamless by construction, not by blur.

Every generator is periodic on the torus: noise, cells, patterns and simulations wrap exactly, so there is no edge to hide and no cross-fade to smear detail. Transforms only allow whole-number repeats, offsets and quarter turns. Uploaded photos and AI images get seam enforcement, and every map carries a live seam-quality score.

Resolution independent: the same material at 512 or 8192 px, with filters in texture space.

Verified, not assumed: an automated sweep renders every generator variant and measures its seams.

Tile-repeat preview in the 3D view, the look-at-it proof.

What's inside

A whole material studio in one window.

338 generators

Noise, cellular, patterns, tiles, stone, ground, wood, metal, architecture, textiles, organic and body, grunge, building, urban, manmade and geographic elements, faces and a reaction-diffusion simulation.

58 filters

Levels, HSV, gradient map, blurs, warps, slope blur, edge wear, cavity dirt, dust, wetness and puddles, rain streaks, erosion, moss, snow, rust and verdigris, peeling paint, soot and scorch, frost.

286 materials

Ready-to-edit stacks from brick and oak to blood-pooled cobbles, heat-tinted steel and neon shop signs, plus aged and damaged variants of the classics.

272 gradient ramps

Multi-stop ramps for wood, stone, metal, fire, camo, skin and soot; the ones naming a real material are sampled from real-world albedo.

Lettering, glow and cut-outs

A built-in stroke font prints signs, plates, key legends and book spines. Generators write emissive and opacity maps for neon, lava, lit rooms, leaves and fences.

Anisotropy and sheen

Brushed and spun metal, machined finishes and hair stretch their highlights; velvet, suede, knits and skin peach fuzz catch a soft rim of light. Both export for every engine.

Library browser

Thumbnails rendered by the real pipeline, cached and fingerprinted by shader source: only what changed re-renders. Category filters and search across everything.

KTX2 / Basis UASTC

GPU-compressed exports with mip chains from a bundled WASM encoder, correct sRGB/linear tags and a manifest, zipped.

Local REST API

Every generator, filter, material and control over HTTP, rendered on your GPU, with a built-in wiki and an OpenAPI 3.1 document.

Whole heads, from a template or a photo.

Anatomical skin: flushed cheeks, thin skin around the eyes, beard shadow, pores, freckles, moles and broken capillaries, sized in millimetres from the eye distance.

Faces from photos: 478 landmarks found locally with MediaPipe, frontalized, unwrapped, de-lit and mirrored to fill what the camera missed.

Eight face filters: complexion, eye makeup, lipstick, beards grown hair by hair, aging, skin details, injuries and character looks.

A real head to judge them on: refracting eyes, 3D lashes, hair cards grown from the texture's own anisotropy, wrap-lit skin and baked AO.

Standard UV layouts: lat-long, glTF sphere, cylindrical wrap and front projection.

From texture to textured model.

Import almost anything: glTF/GLB (Draco, meshopt, KTX2), FBX, DAE, OBJ+MTL, PLY, STL, 3MF, AMF, 3DS, USD/USDZ, VRML, VTK, LWO and .zip archives.

Pick slots in the viewport and assign materials with UV or triplanar mapping, plus normal, roughness, metalness and displacement controls.

Nine unwrap methods: Smart Project, Conformal, ARAP, xatlas, Box, Planar, Cylindrical, Spherical and Repack, with packing, texel density and a full distortion report.

Bake to UVs: triplanar results become ordinary UV textures, every map included, normals re-expressed in the mesh's frame.

GLB export with emissive, cut-outs, anisotropy and sheen extensions.

Engine-ready

Packed the way your engine reads it.

Export as PNG or KTX2 (Basis UASTC or uncompressed) with mip chains. Presets name the files, pack the channels and flip normals per engine. Anisotropy and sheen come along wherever the engine supports them.

Preset	Files	Packing
Unreal Engine	`T_*_BC` `_N` `_ORM` `_H` `_E` `_A` `_Fuzz`	ORM = occlusion, roughness, metallic; DirectX normals; tangent + anisotropy
Unity URP / Built-in	`BaseMap` `Normal` `MetallicSmoothness` `Occlusion` `Height` `Emission`	Smoothness in the alpha of the metallic map
Unity HDRP	`BaseColor` `Normal` `MaskMap` `Height` `Emissive` `Tangent` `Anisotropy` `Sheen`	Mask map = metallic, occlusion, detail, smoothness
glTF / Godot / web	`baseColor` `normal` `occlusionRoughnessMetallic` `height` `emissive` `anisotropy` `sheen`	KHR_materials_anisotropy and KHR_materials_sheen conventions
Blender / DCC	`BaseColor` `Normal` `Roughness` `Metallic` `AO` `Height` `Alpha` `Emission` …	Separate maps, including Anisotropic Rotation and Sheen Roughness
All maps	Every map, separate files	Including legacy specular and depth

Desktop app + REST API

Your GPU, as a texture server.

The desktop app is also a local render server. A hidden engine window renders API jobs on your GPU without touching the project you have open, and restarts itself if the GPU process dies.

/api/v1: list and render every generator, filter, material and control; get every map in one JSON reply.
API wiki generated from the live catalog, with thumbnails and curl, Python, JavaScript and PowerShell examples.
Safe by default: localhost only, DNS-rebinding protection, optional API key.

# every map of a material, laid out for Unreal
curl -X POST http://127.0.0.1:8787/api/v1/generate \
  -H "content-type: application/json" \
  -d '{ "material": "cobblestone-street",
        "resolution": 2048, "preset": "unreal" }'

# or a stack of your own
{ "layers": [
    { "generator": "stone.cobbles", "params": { ... } },
    { "filter": "cavityDirt" },
    { "filter": "wetness" } ],
  "maps": ["albedo", "normal", "roughness"],
  "format": "ktx2" }

Everything in one place.

The editor, the library, the face tools, the model workspace and the API server live in one desktop app that runs entirely on your machine. No cloud, no uploads, no subscriptions to render.

Windows 10/11 x64WebGL2-capable GPUWorks offlineData stays on your machine