Draft:Ul2fs

• Comment: Zero independent sources that discus UL2FS; no indication of meeting Wikipedia's notability criteria. Helpful Raccoon (talk) 05:29, 3 October 2026 (UTC)

---

UL2FS

Full name	Unix friendly Linked List File System
Introduced	September 17, 2026 (2026-09-17) with FUSE driver
Partition IDs	EFI: Linux System Partition
Structures
Directory contents	Table
File allocation	Linked list
Bad blocks	Not implemented
Bootable	yes
Limits
Min volume size	1408 bytes with 128 byte blocks, 28672 bytes with 4KiB blocks
Max volume size	1 EiB for 4kiB blocks, 16EiB for 64KiB blocks, 2^112 bytes for 16EiB blocks
Max file size	18,446,744,073,709,551,999 bytes (16 EiB-1)
File size granularity	1 byte
Max no. of files	4,294,967,294 (inodes)
Max filename length	122 or 123 bytes
Max dirname length	Implementation dependent
Max directory depth	unlimited
Allowed filename characters	any byte except 0x0 or /
Features
Dates recorded	Modified timestamp, creation timestamp
Date range	1970-01-01 to 2106-02-07 (36812-02-20 if using extra fields in the inode)
Date resolution	1 second
Attributes	link count
File system permissions	POSIX bits + UID + GID
Transparent compression	only at the block level
Transparent encryption	only at the block level
Copy-on-write	no
Other
Supported operating systems	Hardcore Linux (replaced ext4 in September 28, 2026 (2026-09-28))
Website	https://github.com/AMAZING2545/HardcoreLinux/ (source at tools/src/axfs)

UL2FS(Unix friendly Linked List FileSystem) is a FUSE filesystem for Linux and other Unix operating system that support FUSE.

UL2FS was designed to be a simple filesystem that could replace Ext4 in embedded systems, since it has full POSIX permissions, Hard link and Symbolic link support, while having higher metadata density. Its FAT-like design makes it easy to implement in Firmware, which might be appealing for low power devices.

Features

• Inodes
• POSIX bits
• Low metadata overhead
• Hard links
• Symbolic links

Structure

Boot sector

UL2FS reserves the first block to the Superblock, which contains all informations to mount and use the filesystem.

Superblock

parameter	size	comment
JMP instruction	8 bytes	X86 needs 3 bytes, RISC architectures generally need more
block size	1 byte	expressed as 2^x
volume name	32 bytes	any byte except 0x0
reserved blocks	2 bytes	does not include the superblock's block
FAT size	4 bytes	the size of the allocation table in blocks
size	8 bytes	size of the volume in blocks
inodes	4 bytes	amount of inodes in blocks
root directory size	1 byte	deprecated, must be set to zero
cylinders	2 bytes	used only in legacy systems
heads	2 bytes	used only in legacy systems
sectors-per-track	2 bytes	used only in legacy systems
extended FAT size	2 bytes	upper part of FAT size, generally ignored
used blocks	8 bytes	generally ignored

UL2FS usually keeps only one copy of the superblock, but a implementation can store a copy in a reserved sector.citation needed

File Allocation Table

main article: Design of the FAT file system#FAT.

UL2FS' FAT region behaves the same as other FAT filesystems, except that it uses 48-bit pointers instead of 28/32-bit of FAT32 or ExFAT. 48 bit pointers allow for very large volumes that can exceed Exabytes and Zettabytes.

UL2FS only uses 0(free block) and -1(end of chain) as reserved entries in the FAT.

Inode Region

the inode table contains the inodes, which are structures that store file metadata and location on disk.

Inode

name	size	comment
POSIX bits	2 bytes	octal POSIX bits
user	2 bytes	owner of the inode
group	2 bytes	group owner of the inode
era	2 bytes	now unused, can be split in two to extend timestamps
created	4 bytes	unsigned UNIX timestamp
modified	4 bytes	unsigned UNIX timestamp
links	2 bytes	link count
size	8 bytes	file size in bytes
start	6 bytes	first block in the chain

note: the inode does not store the file type (regular, directory, link).

Directory Table

Directories are stored as entries in special inodes that do not contain plain data.

each directory has at least two entries:

• "." is a hard link to itself
• ".." is a hard link to the parent (itself if it is the root directory)

each entry is stored in a 128-byte entry.

Directory entry

name	size	comment
filename	123 bytes	any byte except 0x0 and /
attributes	1 byte	0 = regular, 1 = directory, 2 = symlink
inode	4 bytes	pointer in the inode table

Data region

the data region lies after the inode table and contains file data, directories and symlinks.

Performance

No formal comparison is available right now

As for all FAT-like filesystems random seek is O(n) and sequential seek is O(1)citation needed

Support

UL2FS can be built from source on any Linux distro that has FUSE support.

UL2FS is the native filesystem of the Hardcore Linux project, as it is a subproject of it

See also

Design of the FAT file system

Unix filesystem