Substance Painter Export Presets for 3D Marketplaces: My Expert Guide

3D Asset Market Trends

After years of selling assets across every major platform, I’ve learned that flawless exports aren't a luxury—they're the foundation of a professional 3D marketplace business. In this guide, I'll share the exact Substance Painter export presets and workflow I use to ensure my models, including those generated with AI tools like Tripo, upload and perform correctly the first time, every time. This is for 3D artists and technical artists who want to eliminate upload errors and build a reliable, scalable asset creation pipeline.

Key takeaways:

• Marketplace success hinges on technical compliance; a robust preset library is your most valuable tool.
• A "one-size-fits-all" export does not exist; you need tailored presets for Unreal, Unity, and web formats.
• Integrating AI-generated geometry requires a specific pre-painting checklist for retopology and UVs.
• Automation through scripts and a rigorous validation process are non-negotiable for professional output.
• Sharing standardized presets across a team is the fastest way to ensure consistency and quality.

Why Marketplace Export Presets Are Non-Negotiable

The Universal Marketplace Requirements I Always Check

Every marketplace has a technical specification document, and ignoring it is the fastest way to get your asset rejected or buried in negative reviews. The universal constants I always verify are texture resolution (must be power-of-two, e.g., 1024, 2048, 4096), supported file formats (typically PNG or TGA for raster, sometimes TIF), and a strict naming convention for texture maps. I also check for specific requirements on color space (sRGB for albedo, linear for roughness/metalness) and whether or not embedded alpha channels are allowed for certain maps. Treating these specs as law saves countless hours of rework.

How My Failed Uploads Shaped My Preset Philosophy

Early in my career, I’d manually configure each export. The result? Inconsistent filenames, incorrect bit depths, and failed uploads due to unsupported compression. One particularly painful memory involves a 50-asset pack where every normal map was exported in the wrong format for the target engine. Since that day, I've operated on a core principle: never export manually for a marketplace. A preset is a contract that guarantees consistency, and consistency builds trust with customers and platform algorithms alike.

The One-Size-Fits-None Problem and My Solution

You cannot use the same export settings for the Unreal Engine Marketplace and Sketchfab. Unreal expects specific packing of Ambient Occlusion, Roughness, and Metallic into a single texture (ORM), while a GLTF/GLB model for the web needs those as separate, standard PBR maps. My solution is a dedicated preset library. I don't have one "Best Export" preset; I have "UE5_Marketplace_4K," "Unity_URP_2K," and "Web_GLTF_2K." This targeted approach is the only way to meet the nuanced needs of each ecosystem.

Building My Core Preset Library: A Step-by-Step Workflow

My Standardized Texture Set and Map Naming Convention

Before I touch an export setting, I define what maps I need. My standard PBR set for a non-metal/rough workflow is: Albedo, Normal, Roughness, Metallic, AmbientOcclusion, and sometimes Height. For a spec/gloss workflow, it's Diffuse, Normal, Specular, Glossiness. The naming is critical. I use this consistent pattern: {AssetName}_{MaterialID}_{MapType}.png (e.g., SciFiPanel_01_Albedo.png). This keeps files organized for me and easily parsable by any game engine's material system.

Configuring Resolution and Bit Depth: What I Set and Why

My starting point is always the highest resolution I intend to sell (e.g., 4K). I create presets for 4K, 2K, and 1K versions. For bit depth, Albedo/Diffuse maps are always 8-bit with sRGB color space. Normal maps are 8-bit unless I need extreme precision for a hero asset, then I might use 16-bit. Grayscale maps like Roughness and Metallic are always 8-bit. I never export these as 16-bit; it's unnecessary file bloat for marketplace assets. The key is to set the "Color Space" per map correctly in the Export dialog: sRGB for color, Linear (raw) for everything else.

File Format and Compression: Balancing Quality and File Size

For Unreal and Unity, I primarily use PNG. It offers lossless compression and is universally supported. I avoid JPEG entirely due to its lossy nature. For very large asset packs where every megabyte counts, I might use TGA with RLE compression, but PNG is my default. For web formats like GLTF, the choice is often made for me—the standard is PNG or JPEG for textures bundled in the GLB. In Substance Painter, I disable any "Dithering" for grayscale exports to avoid introducing unnecessary noise.

Platform-Specific Presets: My Tailored Configurations

My Unreal Engine Marketplace Preset (UE5 Ready)

This preset is built for Unreal's material system. The most important step is configuring the ORM (OcclusionRoughnessMetallic) packed texture. In my preset, I set the R channel to Ambient Occlusion, G to Roughness, and B to Metallic. I also ensure my normal maps are exported in DirectX format (the Unreal default). My texture set typically includes: Albedo, Normal, ORM, and optionally Emissive. I always check "Output maps in sub-folders" and organize them into /Textures/.

My Unity Asset Store Preset (URP/HDRP Compatible)

Unity's pipeline varies, so my preset is designed for the broadest compatibility. I export maps as separate files: Albedo, Normal, Metallic, Smoothness (I invert my roughness map for this), and Occlusion. For HDRP, I might also include a Mask map (Metallic, Occlusion, Detail Mask, Smoothness). A crucial tip: I set the normal map format to OpenGL, as this is Unity's expected format. I also explicitly avoid packing Occlusion and Smoothness together unless I'm creating a dedicated HDRP asset, as URP's Lit shader expects them separately.

My Sketchfab & Generic GLTF/GLB Preset for Web

For web-viewable models, efficiency is key. My preset exports the standard PBR set: BaseColor, Normal, Roughness, Metallic, and Emissive. I often cap resolution at 2K to keep download sizes reasonable. I use PNG compression but will sometimes allow JPEG for the BaseColor if the model is very complex and the quality loss is acceptable. The most important step here is to verify the export in a local GLTF viewer like Babylon.js Sandbox before upload to ensure all maps are correctly linked and displayed.

Integrating AI-Generated Assets: My Tripo AI Pipeline

From Tripo AI Mesh to Painter: My Retopology & UV Check

When I bring a model from Tripo into my pipeline, my first stop is never Substance Painter. I first check the retopology. While Tripo's output is clean, I often run a quick automated retopo pass to ensure an optimal, uniform quad structure for animation or deformation if needed. Next, I inspect the UVs. I look for adequate texel density, minimal stretching, and a logical layout. I often repack the UVs to maximize space and ensure islands have proper padding. This 10-minute check prevents texture bleeding and baking artifacts later.

Applying & Baking Smart Materials for Marketplace Consistency

AI-generated models can have unique surface details. To ensure my textures are production-ready and tileable across similar assets, I use Substance Painter's baking tools. I bake a high-poly detail map from the original AI mesh onto my retopologized low-poly mesh. This allows me to apply tiling Smart Materials while retaining the model's unique high-frequency detail. This step is crucial for creating a cohesive, stylistically consistent look across a whole pack of AI-assisted assets.

Exporting AI-Assisted Models with Confidence Using My Presets

Once textured, the AI-origin of the model becomes irrelevant. I treat it like any other asset and run it through my standard marketplace preset workflow. The value of my presets is fully realized here: whether the base mesh was hand-sculpted, scanned, or AI-generated, the export to Unreal, Unity, or the web is identical and guaranteed to be compliant. This allows me to leverage the speed of AI for ideation and base geometry without introducing technical debt into the final delivery stage.

Advanced Optimization & Validation: My Final Checks

Automating with I/O Scripts: The Scripts I Run Before Export

I use simple Python scripts via Substance Painter's I/O Scripting API to automate pre-export tasks. One script runs a texture set audit, ensuring all required maps (Albedo, Normal, Roughness) are present and correctly configured. Another script standardizes all layer names across the project to match my naming convention. This automation eliminates human error and is especially powerful when batch-processing multiple assets from a tool like Tripo.

Validating Exports in Engines & Viewers: My QA Process

An export isn't complete until it's validated. My process:

1. Immediate Visual Check: I open the exported textures in a viewer like Adobe Bridge to check for obvious corruption or incorrect color space.
2. Engine Import: I import the textures and FBX into a blank Unreal or Unity project (depending on the preset). I apply them to a material and view them under different lighting conditions (HDRi sky, direct light).
3. Functional Check: I verify that roughness maps affect shininess, normal maps react to light, and metallic maps behave correctly.

Updating Presets: How I Evolve My Templates with New Tech

Marketplaces and engines update their requirements. I review my presets quarterly. When Unreal 5.4 introduced new material features, I updated my UE preset to optionally export a PackedMaterialAttributes map. I subscribe to the RSS feeds for the Unity and Unreal marketplace technical blogs. When a new format like Basis Universal gains wider support, I'll create a new experimental preset for it. My preset library is a living system, not a static set of files.

Common Pitfalls and Pro-Tips from My Experience

The Alpha Channel Mistakes I See (and How I Avoid Them)

The most common error is unintentional alpha channels. Exporting a simple Albedo PNG from Painter sometimes includes an empty alpha channel, which can confuse some game engine importers. In my presets, I explicitly set the "Alpha Channel" export option to "None" for all maps that don't require transparency (Albedo, Normal, Roughness, etc.). I only enable "Alpha Channel: Embedded" for maps that truly use it, like an Opacity or Cutout map.

Managing Multi-Material Assets for Clean Exports

For assets with multiple material IDs (e.g., a character with skin, metal, and cloth), I organize my Painter project with one Texture Set per material. My export preset is configured to export all texture sets in one batch, using the naming convention {AssetName}_{TextureSetName}_{MapType}.png. This keeps all files for one asset together. I also use a "Common" texture set for shared maps like a global dirt overlay, which gets baked into each material's export automatically.

My Template Sharing System for Team Projects

Consistency across a team is vital. I don't just share SPP (Painter project) files; I share the entire project template. This includes:

• The configured SPP file with empty, correctly named Texture Sets.
• A ./export-presets/ folder with all my JSON preset files.
• A README.txt file with the exact steps to install the presets (copy to the Substance Painter assets/ folder).
• This system ensures that whether I'm working alone or with others, every asset we produce for a marketplace shares the same technical foundation.