TGA (.tga)

---
name: tga
description: "Describe and analyze TGA (.tga) image format specs, alpha handling, compression, and its use in game asset pipelines."
metadata:
  tags: "file-formats, image-format, tga, texture-format, alpha-channel, game-development, compression-rle"
  source: "https://skilldb.dev/skills/file-formats-skills/tga"
  pack: "file-formats-skills"
  category: "Technology & Engineering"
---

# TGA (.tga)

## When to use this skill
Use when the user says things like:
- "Explain the TGA file format and its use cases."
- "Tell me TGA alpha channel details."
- "Compare TGA compression options (uncompressed vs RLE)."
- "What are TGA color depths and palettes?"
- "Explain TGA metadata and origin options."


You are a file format specialist with deep knowledge of the TGA (Targa) image format, its role in game development, alpha channel support, and its place in modern asset pipelines.

## Overview

TGA (Truevision Graphics Adapter), also known as TARGA (Truevision Advanced Raster Graphics Adapter), was developed by Truevision Inc. in 1984 for use with their video display hardware. It was one of the first widely available formats to support 24-bit color and an alpha channel (32-bit RGBA), making it historically important for video production and game development. TGA became the de facto standard texture format in game development during the 1990s and 2000s, and it remains in active use in many game studios and engines today due to its simplicity, alpha channel support, and established pipeline integration. The format was acquired by Avid Technology through their purchase of Truevision.

## Technical Specifications

- **File extension(s):** `.tga`, `.tpic` (rare), `.vda`, `.icb`, `.vst` (legacy)
- **MIME type:** `image/x-tga`, `image/x-targa`
- **Compression type:** Uncompressed or RLE (Run-Length Encoding). RLE is lossless and works well for images with large areas of flat color. No lossy compression option.
- **Color depth:** 8-bit (256-color palette or grayscale), 15-bit (5-5-5 RGB), 16-bit (5-5-5-1 RGBA or 5-6-5 RGB), 24-bit (8-8-8 RGB), 32-bit (8-8-8-8 RGBA)
- **Max dimensions:** 65,535 x 65,535 pixels (16-bit unsigned width and height fields)
- **Transparency:** Full 8-bit alpha channel in 32-bit mode; 1-bit alpha in 16-bit mode
- **Pixel order:** Configurable origin (bottom-left is default, top-left is common). Specified by bits 4-5 of the image descriptor byte.
- **Metadata support:** Minimal. TGA 2.0 extension area supports author, comments, date, job name, software info, gamma, and a postage-stamp (thumbnail). Most software ignores extension data.
- **Color map:** Optional palette (color map) for indexed-color images
- **TGA versions:** TGA 1.0 (original), TGA 2.0 (1989, added extension area and developer directory)

## How to Work With It

### Opening & Viewing

- **Image editors:** Photoshop, GIMP, Paint.NET, IrfanView, XnView all support TGA
- **Game engines:** Unreal Engine, Unity, Godot import TGA textures natively
- **3D tools:** Maya, 3ds Max, Blender support TGA for texture I/O
- **OS support:** Not natively previewed in Windows Explorer or macOS Finder without third-party tools

### Creating & Editing

- **Photoshop:** Save As > Targa (.tga). Choose 32 bits/pixel for RGBA with alpha. RLE compression option available.
- **GIMP:** Export As > .tga. Select RLE compression and origin position.
- **Game textures:** Create at power-of-two dimensions (512, 1024, 2048, 4096) for GPU compatibility. Include alpha for transparency masks, specular maps, or packed channel data.
- **Channel packing:** Game developers often store multiple maps in TGA channels (e.g., R=metallic, G=roughness, B=AO, A=height).

### Converting To/From

- **TGA to PNG:** `magick input.tga output.png` (preserves alpha)
- **PNG to TGA:** `magick input.png output.tga`
- **TGA to DDS:** `texconv -f BC3_UNORM input.tga` (DirectXTex tool for game-ready compression)
- **Batch convert:** `magick mogrify -format png *.tga`
- **Python:** `from PIL import Image; Image.open("in.tga").save("out.png")`
- **Game pipeline:** TGA source textures are typically converted to DDS/KTX/compressed formats by the engine's asset pipeline at build time

## Common Use Cases

- Game development texture authoring (diffuse, normal, specular, mask maps)
- 3D modeling and rendering texture maps
- Video production and motion graphics (alpha channel compositing)
- Sprite sheets and 2D game assets
- Channel-packed texture maps (multiple data channels in RGBA)
- VFX pipeline intermediate format
- Legacy application compatibility

## Pros & Cons

**Pros:**
- Simple, well-understood format (easy to implement parsers)
- Full 8-bit alpha channel support (was pioneering when introduced)
- RLE compression reduces file size for appropriate content
- Deeply integrated into game development pipelines
- No patent or licensing concerns
- Exact pixel preservation (lossless)
- Fast to read and write (minimal header parsing)

**Cons:**
- Large file sizes (no modern compression; uncompressed 4K RGBA is ~67 MB)
- RLE is only effective for images with large flat color areas
- No EXIF or meaningful metadata support
- No color management (no ICC profiles)
- Not supported in web browsers
- Pixel origin confusion (bottom-left vs. top-left) causes frequent bugs
- Being gradually replaced by PNG in many workflows and DDS/KTX for game textures
- No HDR support (8-bit maximum per channel)

## Compatibility

| Platform | Support |
|----------|---------|
| Photoshop | Full |
| GIMP | Full |
| Paint.NET | Full |
| Unreal Engine | Native texture import |
| Unity | Native texture import |
| Godot | Native texture import |
| Blender | Full |
| Maya / 3ds Max | Full |
| Web browsers | Not supported |
| OS preview | Requires third-party viewer |

## Practical Usage

### Game Texture Authoring Pipeline
The typical TGA workflow in game development:

1. **Author** textures in Photoshop/Substance Painter at power-of-two dimensions (1024x1024, 2048x2048, 4096x4096)
2. **Export** as 32-bit TGA (RGBA) for textures needing alpha, 24-bit TGA (RGB) otherwise
3. **Import** into the engine (Unreal, Unity, Godot) — the engine's asset pipeline compresses to DDS/BC/ASTC at build time
4. **Version control** the source TGA files alongside your project (or in a separate art repository)

### Channel Packing
Game developers routinely pack multiple texture maps into a single TGA's RGBA channels to reduce texture samples in shaders:

```
R = Metallic
G = Roughness
B = Ambient Occlusion
A = Height map (or emission mask)
```

Create these in Photoshop using channel operations, or in Substance Painter by configuring export templates. Channel-packed textures reduce GPU memory usage and draw calls.

### Batch Conversion for Engine Import
When migrating assets between engines or updating texture formats:

```bash
# Convert all TGA textures to PNG (for engines that prefer PNG source)
magick mogrify -format png *.tga

# Convert PNG to 32-bit TGA with alpha
magick input.png -type TrueColorAlpha output.tga

# DirectXTex: convert TGA to GPU-compressed DDS for runtime use
texconv -f BC7_UNORM -y -o ./compressed/ *.tga
```

### VFX Compositing
TGA's alpha channel support made it a standard in video compositing pipelines (After Effects, Nuke, DaVinci Resolve). Render passes with transparent backgrounds are exported as 32-bit TGA sequences for layered compositing.

## Anti-Patterns

**Using TGA for web or document images.** TGA has zero browser support and produces large files. Use PNG or WebP for any non-game, non-VFX context.

**Storing non-power-of-two textures for game use.** GPUs require (or strongly prefer) power-of-two dimensions for mipmapping and compression. Textures at 1000x1000 instead of 1024x1024 waste memory due to padding and may cause rendering issues.

**Confusing pixel origin direction.** TGA's origin defaults to bottom-left, but many tools export top-left. If textures appear vertically flipped in your engine, check the image descriptor byte (bits 4-5). Standardize origin direction across your pipeline.

**Using uncompressed TGA when RLE would help.** For textures with large flat-color areas (UI elements, masks, debug textures), RLE compression can reduce file size by 50-80%. Enable RLE compression in your export settings.

**Ignoring the shift to PNG in modern engines.** Unity and Godot both prefer PNG as source format due to better compression and wider tooling. TGA remains dominant in Unreal Engine workflows, but evaluate whether your engine benefits from TGA specifically before committing to it.

## Related Formats

- **PNG:** Modern lossless replacement with better compression, metadata, and web support
- **DDS:** GPU-compressed texture format (game runtime format; TGA is often the source)
- **BMP:** Similar uncompressed raster format without alpha channel support
- **TIFF:** More feature-rich lossless format for professional imaging
- **PSD:** Layered format for texture authoring before flattening to TGA
- **KTX/KTX2:** Khronos texture container (Vulkan/OpenGL equivalent of DDS)
- **EXR:** HDR format used alongside TGA in VFX pipelines