Your 3D asset could be technically flawless — perfect topology, clean UVs, optimized LODs — and still sit unsold on a marketplace because the preview render looks flat. A well-executed turntable is the single highest-ROI investment you can make in your asset listing. Here's exactly how to produce one in Blender, Unity, and Unreal Engine 5.
What Makes a Turntable Render Worth Watching
A turntable render is a 360° rotation of your asset under controlled lighting, typically 5–10 seconds looped, showcasing silhouette, surface detail, and material response. Buyers on asset marketplaces decide in under three seconds whether to click through. A turntable that shows clean silhouette transitions, crisp specular highlights, and accurate material color in the first two seconds converts dramatically better than static screenshots alone.
Key qualities that separate professional turntables from amateur ones:
- Neutral backdrop: 18% grey or pure white — let the asset speak, not the environment
- Three-point lighting: key, fill, and rim — rim light especially defines edge quality at all rotation angles
- Consistent frame rate: 24fps minimum; 30fps for engine captures; 60fps if you want smooth slow-mo
- Duration: one full 360° rotation in 8–12 seconds is the sweet spot — long enough to read, short enough to loop naturally
Before you touch a render button, lock your camera to a slightly elevated angle (15–25° above horizon) looking down at the asset. Dead-center horizontal reads like a tech demo. Elevated reads like a showcase.
Blender: Setting Up a Turntable in Cycles or EEVEE
Blender is the fastest path from model to turntable. The trick is rotating the world around the camera, not the camera around the asset — this keeps your lighting consistent throughout the spin.
Step 1 — Parent your asset to an Empty:
```python
# In Blender Python console or as a script
import bpy
# Add an Empty at world origin
bpy.ops.object.empty_add(type='PLAIN_AXES', location=(0, 0, 0))
empty = bpy.context.object
empty.name = "Turntable_Root"
# Parent your asset to the empty
asset_obj = bpy.data.objects["YourAssetName"]
asset_obj.parent = empty
asset_obj.matrix_parent_inverse = empty.matrix_world.inverted()
```
Step 2 — Animate the Empty's Z rotation:
In the Timeline, set a keyframe at Frame 1 with Z rotation = 0°. Jump to Frame 240 (for a 10-second clip at 24fps). Set Z rotation = 360°. In the Graph Editor, set both keyframes to Linear interpolation — this gives perfectly even speed with no ease-in/out wobble.
Step 3 — Three-point lighting rig:
| Light | Type | Strength | Position |
|-------|------|----------|----------|
| Key | Area (1×1m) | 800W | Front-left, 45° up |
| Fill | Area (2×2m) | 200W | Front-right, 20° up |
| Rim | Spot | 1200W | Behind-right, 60° up |
Set all lights to not rotate with the Empty — they stay fixed while the asset spins under them. This creates the specular highlight sweep that makes materials read correctly.
Step 4 — Render settings for turntable output:
- Render engine: EEVEE for speed (< 2 min), Cycles for accuracy (30–90 min)
- Output format: PNG sequence, not video directly — PNG sequences survive crashes
- Resolution: 1920×1080 minimum; 2048×2048 square if your marketplace supports it
- Denoise: enabled (Cycles); Bloom off (distracting on neutral backgrounds)
Unity: Real-Time Turntable Captures
For assets destined for Unity buyers, a real-time turntable recorded directly in the engine carries extra weight — it proves in-engine performance and shows accurate PBR material response under Unity's lighting model.
Setup in Unity 6 (URP or HDRP):
- Create a new scene: File > New Scene > Basic (Built-in) or URP equivalent
- Add a Directional Light at 50° X, -30° Y as your key
- Add a Reflection Probe at origin, baked — critical for correct specular on metallic surfaces
- Import your asset, zero out all transforms, center to world origin
Rotation script:
```csharp
using UnityEngine;
public class TurntableRotator : MonoBehaviour
{
[SerializeField] private float degreesPerSecond = 36f; // 10s full rotation
void Update()
{
transform.Rotate(Vector3.up, degreesPerSecond * Time.deltaTime);
}
}
```
Attach `TurntableRotator` to your asset root, set `degreesPerSecond` to 36 for a 10-second rotation. Record via Unity Recorder (package: `com.unity.recorder`): set output to MP4, 1920×1080, 30fps, 300 frames.
HDRP tip: Enable Path Tracing in the Volume component for near-Cycles quality in real-time — expect 5–15s per frame in preview mode, but the result is indistinguishable from offline renders for a 10-second clip.
Unreal Engine 5: Sequencer + Movie Render Queue
UE5's Movie Render Queue (MRQ) produces the highest-quality frames of any engine, and Lumen global illumination makes your asset look its absolute best with near-zero setup.
Turntable setup in UE5:
- Place your asset in a blank level (use Lit mode, not Unlit)
- Add a Sky Light (set to capture scene) and one Rect Light as key
- Open Sequencer: `Window > Cinematics > Sequencer`
- Add a Camera Actor track. Set camera position at asset distance, elevated 20°
- Add your asset to Sequencer, animate its Z rotation: 0° at frame 0, 360° at frame 300 (10s at 30fps)
Movie Render Queue settings for portfolio output:
```
Output Format: .exr sequence (for compositing) or .png
Anti-Aliasing: Temporal Super Resolution, 32 samples
Motion Blur: disabled (clean turntables do not need it)
Console Variables:
r.MotionBlurQuality 0
r.Lumen.Reflections.Allow 1
r.Nanite.MaxPixelsPerEdge 0.5
```
Render to PNG sequence, then assemble in DaVinci Resolve or Blender's Video Sequence Editor. Export as H.264 MP4 at CRF 18 for a near-lossless web-ready file under 20MB.
Post-Processing and Marketplace Export
The render is done — now make it pop without overdoing it.
Color grade checklist:
- [ ] Lift blacks slightly (0.02–0.05) — pure black backgrounds swallow edge detail
- [ ] Add subtle vignette — draws eye to center, hides compression artifacts at edges
- [ ] Contrast: S-curve, not lift/gamma/gain — more natural on 3D surfaces
- [ ] Saturation: +5 to +10 max — enough to look vivid on marketplace thumbnails without going cartoony
- [ ] Sharpen at export stage, not pre-export — avoids ringing on normal map-driven surface detail
Format requirements by platform:
| Platform | Format | Max Size | Loop |
|----------|--------|----------|------|
| Sketchfab | MP4 H.264 | 50MB | Auto |
| Unity Asset Store | MP4/GIF | 10MB | Manual |
| Unreal Fab | MP4 | 100MB | Auto |
| BitSoul Marketplace | MP4 H.264 | 50MB | Auto |
For BitSoul Marketplace uploads, aim for a square 1:1 crop for the thumbnail frame and a 16:9 video with the asset centered — the listing layout uses both. Use the first frame of your turntable as your static thumbnail: freeze on a three-quarter view that shows the most interesting surface and silhouette simultaneously.
Final Checklist Before Publishing
- [ ] Asset centered at world origin — no offset drift during rotation
- [ ] All materials assigned and rendering correctly (no pink/error materials)
- [ ] Rim light visible at 180° rotation point — confirms rig is correct
- [ ] No clipping between asset and ground plane
- [ ] Audio track removed (or add subtle ambient if preferred)
- [ ] Exported as H.264 MP4, not HEVC — broadest browser compatibility
- [ ] Thumbnail frame selected from three-quarter view
- [ ] File size under platform limit
A clean turntable takes 30–90 minutes to set up correctly the first time. After that, it's a 10-minute swap for each new asset: drop in the model, match the camera distance, render. Save your rigs as `.blend`, `.unitypackage`, and `.uproject` templates and reuse them across your entire catalog.
If you're selling on BitSoul Marketplace, a turntable video in your listing significantly outperforms static previews. Set it up once, template it, and apply it to every asset you publish.