Skybox Formats Explained: Equirectangular vs Cubemap vs HDRI

TL;DR

If you're targeting Unity URP/HDRP, Unreal 5, or modern WebGL, use equirectangular (2:1 PNG/EXR). If targeting legacy Unity built-in pipeline, mobile GPUs without high-precision panoramic sampling, or Three.js with cube reflections, convert to cubemap (6 faces). Use HDRI (.hdr/.exr) when you need IBL lighting contribution, not just a backdrop. The three formats describe the same scene — they differ in how the pixels are unpacked.

One practical rule of thumb: if your engine has a "Panoramic" or "HDRI Backdrop" skybox shader built in and you're on a modern GPU, stay equirectangular and skip the conversion step entirely. You lose nothing and you keep the pipeline simple. Cubemaps are the right answer when the engine or the hardware forces your hand, not when you're just following old tutorials written for Unity 5.

Generate a panorama →

Convert panorama to cubemap →

The three formats at a glance

All three formats represent the same underlying data: a 360°×180° view of an environment. The differences are purely about how that spherical data gets flattened into a file and how the GPU or renderer unpacks it at runtime. An equirectangular panorama and a cubemap built from the same source are mathematically equivalent — same photons, different geometry. HDRI adds a third dimension: linear, high-dynamic-range pixels instead of gamma-encoded 8-bit values. Understanding those three dimensions (layout, geometry, bit depth) is the whole game.

Equirectangular (2:1 panorama)

Equirectangular is the canonical format for storing a full 360° environment in a single file. The name comes from the map projection of the same name: longitude maps to the horizontal axis, latitude maps to the vertical axis, and the result is a rectangle with a 2:1 aspect ratio. A 4096×2048 image is 360° wide and 180° tall — a perfect mirror of the sphere it represents.

The projection introduces predictable distortion. Near the equator (the vertical center of the image), pixels are densely packed and proportional. Near the poles (top and bottom edges), pixels stretch dramatically — a single horizontal band near the top of the image might represent only 1° of vertical arc on the sphere, yet it gets the same number of pixels as a band near the equator that spans 10°. This is why skies generated as equirectangular panoramas look blurry at the top and bottom when viewed flat, but look correct when mapped onto a sphere or used inside a skybox shader.

For modern engines, this pole distortion is not a problem. The skybox shader handles the UV remapping internally. Unity's Panoramic skybox shader, Unreal's HDRI Backdrop actor, Babylon.js, and Three.js's EquirectangularReflectionMapping all accept 2:1 equirectangular directly and do the sphere mapping on the GPU. You give the engine one image; it takes care of everything.

Pros: Single file. Easy to inspect in any image viewer. Widely supported by modern tools. Easy to edit in Photoshop or GIMP if you need to touch up seams. The standard output format for AI panorama generators, 360° cameras, and most environment painting tools.

Cons: Pole distortion makes hand-painting difficult. Not the native format for legacy or mobile GPUs. Some older reflection probe workflows expect cubemaps. A very high-resolution equirectangular (say, 8192×4096) will have most of its pixel budget wasted on the over-sampled poles.

For most workflows in 2026, equirectangular is the right starting point. Convert only when the target system genuinely requires cubemap input.

For a deeper dive on the format itself, see What is an equirectangular image?.

Cubemap (6 faces)

A cubemap represents the environment as six square faces: positive X, negative X, positive Y, negative Y, positive Z, negative Z — or in plain terms, right, left, up, down, front, and back. Each face is a standard perspective render with a 90° field of view. Stitch all six together and you have a complete sphere, no pole distortion, and uniform pixel density across the entire surface.

Naming conventions

The six faces follow different naming conventions depending on the engine or tool. Here are the four most common:

Getting the naming wrong is the single most common source of upside-down or inside-out skyboxes. When in doubt, load each face individually and verify orientation before batching. The cubemap generator lets you select which naming convention to use on export, so you can match whatever your engine expects without manual renaming.

Where cubemaps shine

Legacy Unity (built-in render pipeline): Unity's built-in pipeline predates widespread support for panoramic sampling shaders. The default 6-Sided skybox material expects six separate textures, one per face. If you're shipping a mobile game on the built-in pipeline — or maintaining a project that predates URP — cubemap is your only practical option without rewriting the skybox system.

Unreal Cube Render Target: UE5's reflection capture actors and cube render targets are natively cubemap-based. If you're baking reflections into a static level or building a reflection probe workflow, you're working with cubemaps at the engine level even if you imported equirectangular assets.

Three.js CubeTextureLoader: Three.js's CubeTextureLoader expects six files. If you're building a WebGL scene with THREE.CubeReflectionMapping for environment-mapped materials, you need individual face files. THREE.EquirectangularReflectionMapping is an alternative for modern setups, but CubeTextureLoader is still the default in many starter templates.

Mobile GPU performance: On lower-end Android hardware, panoramic sampling from a single 2:1 texture can be more expensive than sampling from a cubemap, because the GPU has to compute the UV projection per fragment. A pre-baked cubemap shifts that math to load time. The practical difference is small on modern mid-range phones, but matters on budget hardware at scale.

Pros: Uniform pixel density — no wasted resolution at poles. Native format for reflection probes. Required by legacy pipelines. Predictable face layout that artists can hand-paint.

Cons: Six files to manage. Naming convention fragmentation across engines. Seams between faces require careful attention if hand-painting. More conversion steps if your source is equirectangular.

You can convert any 2:1 equirectangular to a cubemap in the browser via our cubemap generator — pure front-end, no upload, free.

HDRI (high dynamic range image)

HDRI stands for High Dynamic Range Image. The "high dynamic range" part is the critical word. A standard 8-bit PNG stores 256 discrete values per channel, with a typical dynamic range of about 2–3 stops. A 32-bit float HDRI stores fractional values from near zero to tens of thousands — a dynamic range of 20+ stops. In practical terms: the sun in a real outdoor HDRI is 100,000× brighter than the deep shadow under a car, and the file preserves that ratio intact.

That ratio is what makes HDRI useful for image-based lighting (IBL). When a renderer samples an HDRI environment map for diffuse and specular contribution, it uses the actual luminance values in the file to compute realistic light bounces and specular highlights. A bright sun in a true HDRI will produce a sharp specular highlight on a polished surface. The same scene stored as 8-bit LDR will produce a blown-out, flat highlight — the renderer treats the whole sky as roughly the same brightness because the file can't represent the difference.

File formats

The two dominant HDRI containers are:

• Radiance .hdr (also called RGBE): A legacy format developed by Greg Ward in the 1980s. Stores 32-bit values as 8-bit mantissa + 8-bit shared exponent per pixel (RGBE encoding). Widely supported by Blender, Substance Painter, Marmoset, and most DCC tools. Smaller files than EXR. The format produced by the AI HDRI Generator.
• OpenEXR .exr: The modern standard for visual effects and high-end rendering. True 16-bit or 32-bit float per channel, no shared-exponent compromise. Supports multi-layer, multi-part, and tiled formats. Preferred in VFX pipelines, supported by Blender Cycles and Unreal Engine's HDRI Backdrop with .exr input.

HDRI vs backdrop — an honest distinction

A lot of game dev content blurs the line between "HDRI skybox" and "HDRI lighting." They are not the same thing. If you just want a visually nice sky behind your level and you're not relying on the environment map for lighting contribution, you do not need true HDRI. An 8-bit LDR equirectangular panorama will look just as good at a fraction of the file size. The sky is a backdrop; it doesn't need 32-bit precision.

You need true HDRI when:

• Your physically based materials need accurate specular highlights from a dominant light source (sun, area light, neon sign).
• You want soft, directional ambient from the environment without placing explicit lights.
• You're doing look-dev or product visualization where exposure accuracy matters.
• You're matching a real photographed environment for virtual production.

An honest note about AI-generated HDRI

AI panorama generators — including our own AI HDRI Generator — produce 8-bit LDR pixels. The output is then wrapped in a Radiance .hdr container, which technically makes it an "HDRI file." But the pixel data is still 8-bit, tone-mapped, and gamma-encoded. The sun in an AI-generated sky is not 100,000× brighter than the shadows — it's at most 3–4 stops above neutral, the same as any 8-bit image.

What this means in practice: AI HDRI is excellent for soft ambient IBL, mood direction, fictional interiors, and backdrop variety. It will give you plausible-looking specular from bright sky regions. It will not give you the sharp, physically accurate sun specular that a bracketed-photography HDRI from Poly Haven provides. Both are useful. Know which one you need before you start.

For true HDR, use Poly Haven (CC0, captured, excellent quality) or Lumiere for studio-grade HDRIs. Use AI generation for speed, volume, and fictional environments.

Conversion paths

Understanding the conversion paths between formats saves you from unnecessary roundtrips and lossy operations.

Equirectangular → Cubemap is the most common direction. Options:

• Cubemap generator (browser-based, free, no upload required, supports all four engine naming conventions)
• Blender Compositor: use an Equirectangular node feeding into six renders with a Cube projection camera setup
• panorama-to-cubemap npm package: a JavaScript library that runs in Node.js and outputs individual face PNGs

Cubemap → Equirectangular is less common but sometimes needed (e.g., if you have only cubemap assets and need to edit the environment in a panoramic editor). Options: Photoshop (with the Perspective Warp tool and manual assembly, tedious but possible), Blender (camera rig rendering), ImageMagick with a custom transformation matrix. This direction is not currently supported by our browser tools — it's on the roadmap if demand materializes, but the math is considerably more complex in a browser context without WebGL compute.

8-bit LDR PNG → HDR container: Our AI HDRI Generator wraps the LDR panorama in a Radiance .hdr file so that Blender, Unreal, and Unity HDRP can ingest it without conversion steps on your end. The pixel values remain 8-bit LDR. True HDR capture — achieving genuine 20+ stop dynamic range — requires bracketed exposure photography (5–7 exposures, merged in Lightroom or PTGui) or rendering in a physically-based renderer with a proper camera model. There is no algorithmic way to recover true HDR from a single 8-bit source image.

Which format should you use?

Are you using URP / HDRP / UE5 / WebGL / modern engine?
├─ Yes → Use equirectangular. Engine handles it natively.
└─ No → Are you on legacy Unity built-in or mobile?
    ├─ Yes → Convert to cubemap.
    └─ No → Are you doing IBL lighting (not just backdrop)?
        ├─ Yes → Use HDRI (true 32-bit, e.g., Poly Haven).
        └─ No → Stick with equirectangular.

Per-engine quick reference:

• Unity URP: Panoramic skybox material. Use equirectangular (PNG or EXR). Single-file, no conversion.
• Unity HDRP: HDRI Sky volume component. Use equirectangular EXR or HDR for lighting; equirectangular PNG for backdrop-only.
• Unity built-in: 6-Sided skybox material. Use cubemap (6 faces). Convert with our cubemap generator.
• Unreal Engine 5: HDRI Backdrop actor. Use equirectangular HDR/EXR. For Lumen, Unreal will use the environment map for indirect lighting contribution — use genuine HDRI here for best results.
• Blender Cycles: World shader with Equirectangular Environment Texture node. Use equirectangular HDR/EXR. The bit depth directly affects the quality of specular highlights on reflective materials.
• Blender Eevee: Same node setup as Cycles. Eevee uses reflection cubemaps internally, but the input is still equirectangular — Eevee bakes its own cubemaps from it at scene load. You do not need to supply a cubemap manually.
• Three.js: EquirectangularReflectionMapping for modern setups (single equirectangular PNG/HDR) or CubeTextureLoader for legacy setups (6 face files). If starting a new project, use equirectangular — it simplifies the asset pipeline significantly.
• WebXR / A-Frame: a-sky component accepts equirectangular. Both 360° image viewers and full VR scenes use the same format. No cubemap required unless you're implementing a custom reflection shader.

Common pitfalls

1. Visible seam at the wrap line. Equirectangular panoramas wrap at the left/right edge. If the left edge pixel row doesn't match the right edge pixel row, you get a visible vertical stripe in your skybox. This happens most often when AI generation introduces random noise or vignetting at the image borders. The Skybox Generator includes a prompt rewriter and generation pipeline specifically tuned to minimize seam artifacts — the model is conditioned to produce seamlessly wrapping skies. If you're generating with a general-purpose image model instead, apply a horizontal seam-blending pass in Photoshop (offset the image by 50%, blend the new center, then offset back).

2. Wrong cubemap face orientation. Each engine expects faces in a different coordinate system and handedness. Unity uses a left-handed Y-up coordinate system; Unreal uses a left-handed Z-up system. The same cubemap asset can produce mirrored or rotated results in different engines. The safest workflow is to use engine-specific naming conventions and verify each face by loading it as a plain texture before assembling the final skybox. Our cubemap generator explicitly labels the output with the convention you select, so Unity, Unreal, Three.js, and Blender exports each get the correct face orientation.

3. 8-bit content treated as HDR. Loading an 8-bit PNG equirectangular into Blender Cycles as the World Environment Texture will technically work — Blender will accept it — but you will not get physically plausible specular from the sun. The file simply doesn't have enough dynamic range. Blender will clamp every pixel into the same narrow band, and your specular highlights will be soft and featureless. If your scene depends on IBL quality, you need true HDR source data. This applies equally to AI-generated .hdr files: the container format is HDR, but the content may be LDR. Check the histogram in your DCC tool before committing to an HDRI source.

4. Resolution mismatch between source and cubemap face size. If you extract a 1024×1024 cubemap face from a 2048×1024 source equirectangular, you're sampling from roughly 512×512 pixels of useful source data per face (the rest goes to adjacent faces). The result will look blocky, especially at face corners where the perspective distortion is highest. Rule of thumb: your source equirectangular width should be at least 4× your desired cubemap face size for clean results. For a 1024×1024 face, start from a 4096×2048 equirectangular. For a 2048×2048 face (the quality ceiling for most game use cases), use an 8192×4096 source.

Generate your first skybox

If you're starting from scratch, the fastest path is to describe your environment in plain English and generate an equirectangular panorama directly. The Skybox Generator handles prompt optimization, seam wrapping, and 2:1 output in one step. Generated images are ready to drop into Unity URP, HDRP, Unreal 5, or any WebGL scene without any conversion.

If your target is a legacy pipeline or mobile engine that requires six cubemap faces, run the output through the Cubemap Generator. Select your engine's naming convention (Unity, Unreal, Three.js, or Blender), download the zip, and import. The entire pipeline — generation to cubemap — runs in the browser with no server upload.

For IBL lighting specifically, check the AI HDRI Generator for Radiance .hdr export. Remember the LDR caveat above: use it for soft ambient and mood, supplement with Poly Haven assets for hard specular accuracy.

Related reading

• What is an equirectangular image?
• AI HDRI for Blender, Unreal, Unity
• How to write 360° panorama prompts