# What File Formats Does ArmorPaint Support for Import and Export?

> ArmorPaint supports OBJ, FBX, glTF/GLB, and Blender .blend imports. Export to OBJ, PNG textures, and native .armor project files. Discover ArmorPaint's file format compatibility.

- Repository: [Armory 3D/armorpaint](https://github.com/armory3d/armorpaint)
- Tags: api-reference
- Published: 2026-09-13

---

**ArmorPaint supports importing OBJ, FBX, glTF/GLB, and Blender .blend files, while exporting to OBJ, PNG textures, and its native JSON-based .armor project format.**

ArmorPaint is an open-source 3D texture painting application built on the Armory3D engine. Understanding what file formats ArmorPaint supports for import and export is critical for integrating the tool into your asset pipeline. This guide examines the actual source code implementation to provide definitive, technical answers on file compatibility.

## Import File Formats in ArmorPaint

The import system in ArmorPaint is modular, with built-in support for four primary 3D mesh formats. The detection logic resides in [`paint/sources/io/import_mesh.c`](https://github.com/armory3d/armorpaint/blob/main/paint/sources/io/import_mesh.c), which routes files to specialized loaders based on file extension.

### Wavefront OBJ (.obj)

**Wavefront OBJ** is the most straightforward import format, handled natively without external plugins. In [`paint/sources/io/import_mesh.c`](https://github.com/armory3d/armorpaint/blob/main/paint/sources/io/import_mesh.c), the system detects the `.obj` extension and dispatches to `import_obj_run` for parsing.

```c
// From paint/sources/io/import_mesh.c (lines 27-34)
if (ends_with(path, ".obj")) {
    import_obj_run(path);
    return;
}

```

The `import_obj_run` function parses geometry, normals, and UV coordinates directly from the ASCII format.

### Blender (.blend)

**Blender .blend files** receive native support through a dedicated loader. When the filename ends with `.blend`, the system calls the specialized Blender importer defined in [`paint/sources/io/import_blend_mesh.c`](https://github.com/armory3d/armorpaint/blob/main/paint/sources/io/import_blend_mesh.c).

```c
// From paint/sources/io/import_mesh.c (lines 29-37)
else if (ends_with(path, ".blend")) {
    import_blend_mesh_run(path);
    return;
}

```

This allows artists to import meshes directly from Blender without intermediate exports, preserving mesh data through ArmorPaint's direct integration with the Blender file specification.

### Autodesk FBX (.fbx)

**Autodesk FBX** import relies on the plugin system rather than core engine code. The FBX plugin utilizes the `ufbx` library located in `paint/plugins/io_fbx/ufbx/`. The UI layer in [`paint/sources/ui/box_import_mesh.c`](https://github.com/armory3d/armorpaint/blob/main/paint/sources/ui/box_import_mesh.c) validates FBX files before handing them to the plugin pipeline.

```c
// From paint/sources/ui/box_import_mesh.c (lines 37-44)
if (ends_with(path, ".fbx")) {
    // Delegates to FBX plugin via ufbx
    io_fbx_import(path);
}

```

The plugin architecture allows for robust FBX support while keeping the core engine lightweight.

### glTF 2.0 (.gltf / .glb)

**glTF and GLB** files share the same plugin infrastructure as FBX. The UI recognition logic in [`box_import_mesh.c`](https://github.com/armory3d/armorpaint/blob/main/box_import_mesh.c) checks for both `.gltf` and `.glb` extensions at lines 55-58, routing them through the import plugin system for modern, efficient transmission format support.

```c
// Extension detection for glTF variants
if (ends_with(path, ".gltf") || ends_with(path, ".glb")) {
    io_gltf_import(path);
}

```

## Export File Formats in ArmorPaint

Export capabilities in ArmorPaint focus on mesh geometry, texture data, and project persistence. Each format serves distinct workflow needs, from asset baking to project archival.

### Wavefront OBJ (.obj)

**OBJ export** is implemented in [`paint/sources/io/export_obj.c`](https://github.com/armory3d/armorpaint/blob/main/paint/sources/io/export_obj.c), writing geometry, vertex normals, and UV data to the standard Wavefront specification. The implementation handles both ASCII formatting and coordinate system transformations.

```c
// From paint/sources/io/export_obj.c (lines 10-18, 67-75)
void export_obj_run(const char *path) {
    FILE *fp = fopen(path, "w");
    // Write vertex data
    for (int i = 0; i < vertex_count; i++) {
        fprintf(fp, "v %.6f %.6f %.6f\n", 
                vertices[i].x, vertices[i].y, vertices[i].z);
    }
    // Write face indices...
    fclose(fp);
}

```

This ensures broad compatibility with other 3D applications that support the decades-old OBJ standard.

### PNG Textures (.png)

**Texture exports** are forced to PNG format by the UI layer. In [`paint/sources/ui/box_export.c`](https://github.com/armory3d/armorpaint/blob/main/paint/sources/ui/box_export.c), the `box_export_tab_export_textures` function sets a strict file-type filter limiting output to PNG images.

```c
// Conceptual extraction from paint/sources/ui/box_export.c
void box_export_tab_export_textures() {
    char *path = dialog_save("Export Textures", "texture.png");
    if (path) {
        // Filter ensures .png extension
        export_texture_png(path);
    }
}

```

This guarantees lossless compression and alpha channel preservation for painted texture sets.

### Native Project Files (.armor)

**Project persistence** uses a JSON-based `.armor` format. While not a mesh exchange format, this is the native container for undo/redo history and layer data. The saving mechanism utilizes `iron_file_save_bytes` to serialize project state.

```c
// Project save logic utilizing iron_file_save_bytes
void project_save(const char *path) {
    char *json_data = project_serialize_to_json();
    iron_file_save_bytes(path, (uint8_t *)json_data, strlen(json_data));
}

```

These files maintain full editability, unlike the flattened mesh exports.

## Summary

- **ArmorPaint imports** four mesh formats natively: **OBJ**, **Blender .blend**, **FBX**, and **glTF/GLB**
- **OBJ importing** uses `import_obj_run` in [`paint/sources/io/import_mesh.c`](https://github.com/armory3d/armorpaint/blob/main/paint/sources/io/import_mesh.c) (lines 27-34)
- **FBX and glTF** rely on the plugin architecture in `paint/plugins/io_fbx/` and `paint/plugins/io_gltf/`
- **ArmorPaint exports** to **OBJ meshes**, **PNG textures**, and **JSON-based .armor project files**
- **Texture exports** are strictly limited to PNG format via `box_export_tab_export_textures` in [`paint/sources/ui/box_export.c`](https://github.com/armory3d/armorpaint/blob/main/paint/sources/ui/box_export.c)

## Frequently Asked Questions

### Can ArmorPaint import STL files for 3D printing workflows?

No, ArmorPaint does not support STL import according to the source code analysis. The [`import_mesh.c`](https://github.com/armory3d/armorpaint/blob/main/import_mesh.c) file only implements detection for `.obj`, `.blend`, `.fbx`, `.gltf`, and `.glb` extensions. To use STL models, you must convert them to OBJ format using Blender or other intermediary tools before importing into ArmorPaint.

### Does ArmorPaint support exporting to FBX format?

No, ArmorPaint cannot export to FBX format. While the application imports FBX through the `io_fbx` plugin system, the export functionality in `paint/sources/io/` only implements OBJ writing via [`export_obj.c`](https://github.com/armory3d/armorpaint/blob/main/export_obj.c). For FBX workflows, export as OBJ from ArmorPaint and convert using Blender or Autodesk tools.

### What image format should I use for textures exported from ArmorPaint?

ArmorPaint exports textures exclusively as **PNG files**. The UI code in [`box_export.c`](https://github.com/armory3d/armorpaint/blob/main/box_export.c) enforces a file-type filter that restricts texture exports to PNG format, ensuring lossless quality and alpha channel support for your painted textures. There is no option to export as JPEG, TIFF, or EXR from the standard export dialog.

### How does ArmorPaint handle Blender files differently from OBJ files?

ArmorPaint processes **Blender .blend files** through [`import_blend_mesh.c`](https://github.com/armory3d/armorpaint/blob/main/import_blend_mesh.c), which reads Blender's native binary format directly, while **OBJ files** are parsed as ASCII text via [`import_obj.c`](https://github.com/armory3d/armorpaint/blob/main/import_obj.c). The .blend importer can potentially preserve more mesh attributes specific to Blender's data structure, though both ultimately convert to ArmorPaint's internal mesh representation for painting operations.