Convert FLI to TGA

Drag and drop files here or click to select.
Max file size 100mb.
Uploading progress:

FLI vs TGA Format Comparison

Aspect FLI (Source Format) TGA (Target Format)
Format Overview
FLI
Autodesk FLIC Animation

Animation format created by Autodesk in 1985 for Animator and Animator Pro. Stores frame-by-frame animation with 256-color palette and delta compression. FLI uses fixed 320x200 resolution while FLC supports arbitrary sizes. Ubiquitous in DOS-era games and multimedia.

Legacy Format Lossless
TGA
Truevision TGA (Targa)

Raster image format created by Truevision in 1984. Supports uncompressed and RLE-compressed storage with alpha channel. Widely used in game development, 3D rendering, and video production. One of the earliest formats to support 32-bit RGBA images.

Legacy Format Lossless
Technical Specifications
Structure: Chunk-based binary with frame delta compression
Color Depth: 8-bit indexed (256-color palette)
Resolution: FLI: 320×200 fixed, FLC: arbitrary
Compression: RLE + delta frame encoding
Extensions: .fli, .flc
Structure: 18-byte header + optional footer
Color Depth: 8/16/24/32-bit (indexed/RGB/RGBA)
Compression: None or RLE
Transparency: Full alpha channel (32-bit)
Extensions: .tga, .tpic
Syntax Examples

FLI uses binary format (not human-readable):

Header: 128 bytes
  Magic: 0xAF11 (FLI) / 0xAF12 (FLC)
  Frames: N, Width: W, Height: H
  Depth: 8 bits, Delay: D ms
Frame chunks: delta-compressed

TGA uses a compact header format:

Header: 18 bytes
  ID Length, Color Map Type
  Image Type (1-11)
  Color Map Spec
  Image Spec: X, Y, W, H, Depth
Image Data (bottom-up default)
Optional footer (TGA 2.0)
Content Support
  • 256-color indexed palette per frame
  • Frame-by-frame animation sequences
  • Delta compression between frames
  • Palette rotation/cycling effects
  • Variable frame delay timing
  • RLE compression for first frame
  • No audio track support
  • 8/16/24/32-bit color depths
  • Full alpha channel (32-bit)
  • Color-mapped (palette) mode
  • Optional RLE compression
  • Bottom-up or top-down scan
  • Image ID field
  • Developer and extension areas
Advantages
  • Efficient delta frame compression
  • Simple format, easy to parse
  • Individual frames easily extractable
  • Native Pillow/Python support
  • Compact animation storage
  • Lossless palette-based encoding
  • Full alpha transparency
  • Game development standard
  • Simple, fast format
  • 32-bit RGBA support
  • No patent restrictions
  • Pillow native support
Disadvantages
  • Limited to 256 colors
  • No audio support
  • FLI fixed at 320×200
  • No transparency/alpha
  • Obsolete format
  • No modern codec features
  • Large files (uncompressed)
  • RLE less efficient than modern codecs
  • No web browser support
  • No metadata standards
  • Being replaced by PNG/WebP
Common Uses
  • DOS game cutscenes and cinematics
  • Autodesk Animator animations
  • Multimedia CD-ROM presentations
  • Scientific visualizations
  • Architectural walkthroughs
  • Game development textures
  • 3D rendering output
  • Video production frames
  • Sprite sheets and game assets
  • Alpha-composited graphics
Best For
  • Retro game asset extraction
  • DOS-era animation preservation
  • Legacy multimedia archives
  • Palette-based pixel art sequences
  • Game asset development
  • 3D rendering pipelines
  • Alpha transparency needs
  • Legacy game engine support
Version History
FLI Introduced: 1985 (Autodesk Animator)
FLC Introduced: 1992 (Animator Pro)
Status: Legacy (no longer developed)
Evolution: Superseded by AVI, MPEG, MP4
Introduced: 1984 (Truevision)
TGA 2.0: 1989 (footer, extensions)
Status: Stable, widely supported
Evolution: TGA 1.0 → TGA 2.0
Software Support
Pillow (Python): Native read support (FliImagePlugin)
FFmpeg: Full read/write support
ImageMagick: Read support
Other: XnView, IrfanView, GIMP (via plugin)
Game Engines: Unity, Unreal, Godot, Source
3D Apps: Maya, Blender, 3ds Max
Editors: Photoshop, GIMP, Pillow
Other: ImageMagick, XnView, IrfanView

Why Convert FLI to TGA?

Converting FLI animation frames to TGA format creates game-ready assets compatible with virtually every game engine and 3D application. TGA is one of the most widely supported texture formats in game development, making it ideal for repurposing retro animation content in modern projects.

TGA's support for 32-bit RGBA enables adding alpha transparency to extracted FLI frames. This is essential for game sprites, UI overlays, and composited graphics where the animation frame needs to blend with backgrounds or other layers.

Both FLI and TGA have roots in the same early computer graphics era (1984-1985), making TGA a natural companion format. Many DOS-era game developers used both formats — FLI for animations and TGA for static textures — so the conversion bridges these related asset types.

TGA format is supported by all major game engines (Unity, Unreal, Godot, Source), 3D applications (Maya, Blender, 3ds Max), and image editors. This universal game development support makes TGA an excellent intermediate format for bringing FLI content into modern production pipelines.

Key Benefits of Converting FLI to TGA:

  • Game Engine Standard: Supported by Unity, Unreal, Godot, Source, and all major engines
  • Alpha Transparency: Full 32-bit RGBA for sprites and composited graphics
  • Same Era Heritage: Both FLI and TGA from the same DOS/early graphics era
  • 3D App Support: Compatible with Maya, Blender, 3ds Max, and all 3D software
  • Simple Format: Fast loading with no complex decompression overhead
  • No Patents: Completely patent-free and freely implementable
  • Pillow Support: Both FLI and TGA natively supported by Python Pillow

Practical Examples

Example 1: Game Sprite Asset

Input FLI file (sprite_anim.fli):

FLI sprite animation:
  Resolution: 320x200
  Colors: 256-color palette
  Content: Character sprite
  Key frame for game asset

Output TGA file (sprite.tga):

TGA game asset:
✓ 32-bit RGBA format
✓ Alpha channel ready
✓ Unity/Unreal compatible
✓ Sprite sheet material
✓ Game engine loadable
✓ Texture pipeline ready
✓ Fast engine loading

Example 2: 3D Texture Material

Input FLI file (wall_anim.fli):

FLI wall animation:
  Resolution: 320x200
  Colors: 256 palette
  Content: Surface texture
  Retro wall pattern

Output TGA file (texture.tga):

TGA texture file:
✓ 24-bit RGB output
✓ Maya/Blender compatible
✓ UV mapping ready
✓ Material texture source
✓ 3D rendering pipeline
✓ Retro aesthetic preserved
✓ Standard game format

Example 3: Retro Game Mod Asset

Input FLI file (cutscene.fli):

FLI cutscene animation:
  Resolution: 320x200
  Colors: 256 palette
  Content: Game cutscene
  Modding resource

Output TGA file (mod_texture.tga):

Mod-ready TGA:
✓ Source Engine compatible
✓ Game mod texture
✓ Half-Life/Counter-Strike ready
✓ Standard mod format
✓ Workshop uploadable
✓ Community standard
✓ Fast game loading

Frequently Asked Questions (FAQ)

Q: What is TGA format?

A: TGA (Truevision Graphics Adapter, also called Targa) is a raster image format from 1984. It supports 8-32 bit color with optional RLE compression and was one of the first formats to support full alpha transparency. TGA is widely used in game development and 3D rendering.

Q: Why is TGA popular in game development?

A: TGA's simplicity, alpha channel support, no patent restrictions, and wide engine compatibility make it a game development favorite. It loads quickly, supports transparency for sprites, and is accepted by every game engine and 3D application.

Q: Should I use TGA or PNG for game assets?

A: Both work well. TGA is more traditional in game development with faster loading in some engines. PNG offers better compression and wider general-purpose support. Many modern engines prefer PNG. Use TGA when a specific engine or pipeline requires it.

Q: Does TGA support animation?

A: No, TGA is a single-frame format. The converter extracts one frame from the FLI animation as a static TGA image. For animated sequences, save individual frames as numbered TGA files (frame_001.tga, frame_002.tga, etc.).

Q: Can I add transparency to TGA from FLI?

A: The converter creates TGA images from opaque FLI frames. You can add alpha transparency afterward in Photoshop, GIMP, or Blender by defining transparent regions. TGA fully supports 8-bit alpha channels in 32-bit RGBA mode.

Q: How does TGA compare to DDS?

A: TGA is uncompressed or RLE-compressed; DDS uses GPU-native block compression (DXT/BCn). DDS is more efficient in VRAM but lossy; TGA is lossless and simpler. TGA is better for source assets; DDS for final game textures.

Q: Can web browsers display TGA?

A: No, TGA is not supported by web browsers. For web display, use PNG, WebP, JPEG, or AVIF. TGA is designed for game engines, 3D applications, and professional production software.

Q: What is the difference between TGA 1.0 and 2.0?

A: TGA 2.0 (1989) added a footer section with extension area, developer area, and a signature stamp. TGA 2.0 also supports postage stamp thumbnails and color correction tables. Most modern tools read both versions transparently.