/ˌfæt θɜːrtiˈtuː/
noun — "widely compatible file allocation table filesystem."
FAT32, short for File Allocation Table 32, is a disk filesystem designed to organize, store, and retrieve files on block-based storage devices using a table-driven allocation model. It represents an evolution of earlier FAT variants and is defined by its use of 32-bit cluster addressing, allowing larger volumes and files than its predecessors while maintaining broad hardware and software compatibility.
Technically, FAT32 structures a storage volume into fixed-size allocation units called clusters. Each cluster consists of one or more logical blocks addressed using LBA (Logical Block Addressing). The core data structure is the File Allocation Table itself, which maps each cluster to either the next cluster in a file chain, an end-of-file marker, or a free-space indicator. This table allows the filesystem to track how files are physically laid out across non-contiguous regions of disk.
The filesystem layout of FAT32 includes several well-defined regions. A reserved area at the beginning of the volume contains boot and filesystem metadata. Following this is one or more copies of the File Allocation Table for redundancy. The data region occupies the remainder of the disk and contains directory entries and file contents stored as chains of clusters. Directory entries hold metadata such as filenames, timestamps, attributes, and the starting cluster of each file.
One defining characteristic of FAT32 is its simplicity. The filesystem does not implement journaling, access control lists, or advanced metadata structures. This design minimizes overhead and makes implementation straightforward, which is why FAT32 is supported by firmware, operating systems, and embedded devices across decades of hardware evolution. However, this simplicity also means reduced resilience against unexpected power loss or corruption.
Operationally, when a file is written, the filesystem allocates free clusters and records their sequence in the File Allocation Table. Reading the file requires following this cluster chain from start to end. Deleting a file marks its clusters as available but does not immediately erase the data, which has implications for data recovery and security. Allocation and lookup operations are linear in nature, which can affect performance on very large volumes.
There are important technical constraints associated with FAT32. Individual files are limited to a maximum size of 4 gigabytes minus 1 byte. Volume size is bounded by cluster size and addressable cluster count, with practical limits typically around 2 terabytes depending on implementation. These limits stem from the filesystem’s on-disk structures and addressing model rather than from storage hardware capabilities.
In real-world workflows, FAT32 is commonly used for removable media such as USB flash drives, memory cards, and external storage intended for cross-platform use. Operating systems map file offsets to cluster chains, convert those to logical block addresses, and issue read or write requests through storage drivers. Firmware environments, including bootloaders and system initialization code, often rely on FAT32 because of its predictable structure and minimal requirements.
FAT32 interacts closely with other system layers. Disk partitioning schemes define the logical block ranges that contain the filesystem. Firmware such as BIOS and UEFI can parse FAT32 volumes directly to locate boot files. Operating systems expose the filesystem through standard file APIs while internally managing allocation, caching, and consistency. Despite its age, FAT32 remains relevant due to this deep integration.
The following simplified conceptual example illustrates cluster chaining in FAT32:
File start cluster: 5
FAT[5] = 8
FAT[8] = 12
FAT[12] = EOF
This chain indicates that the file occupies clusters 5, 8, and 12 in sequence, even if those clusters are physically scattered across the disk.
Conceptually, FAT32 behaves like a handwritten index at the front of a notebook that lists which pages belong to each topic. The index is easy to read and update, works in many contexts, and requires no specialized tools, but it becomes inefficient and fragile as the notebook grows larger and more complex.
See FileSystem, LBA, Disk Partitioning, NTFS.