Escape the Hierarchy Trap: How Tag File Systems Work

We’ve been living in a tree for 50 years.

Ever since the dawn of modern computing, we’ve organized our digital lives into Hierarchical File Systems. You have a root, you have branches (folders), and you have leaves (files). It’s neat, it’s tidy, and it’s also fundamentally broken for the way we actually think.

Why? Because a file often belongs in more than one place.

Is that invoice.pdf in /Work/Invoices, or is it in /Clients/ACME/2024? In a hierarchy, you have to choose. You either duplicate the file (wasteful), use symlinks (messy), or just hope your future self remembers your arbitrary decision.

Enter: The Tag File System (TFS).

In a Tag File System, the physical location of a file is irrelevant. Instead of being "inside" a folder, a file is "associated" with one or more tags.

Think of it like Gmail labels vs. Outlook folders. In Outlook, an email is in a folder. In Gmail, an email has labels. You can view your "Taxes" label and your "Important" label, and the same email appears in both.

• Hierarchical: Path-based (/home/user/photos/cats/oscar.jpg)
• Tag-based: Attribute-based (oscar.jpg + type:photo + subject:cat + name:oscar)

How do you actually build this? You can't just delete folders and expect your OS to keep working. Most Tag File Systems are implemented as overlays.

The most common way to implement a TFS (like the excellent TMSU ) is to use a sidecar database—usually SQLite.

The database maps file hashes or paths to a list of tags.

Failed to render diagram. Check syntax.
graph LR
    subgraph Database
        Files[Files Table]
        Tags[Tags Table]
        Map[File_Tags Mapping]
    end

    FileA[cat.jpg] --> Files
    Tag1[#pets] --> Tags
    Tag2[#cute] --> Tags

    Files --- Map
    Tags --- Map

To make this usable by your favorite apps (like Photoshop or VLC), these systems use FUSE (Filesystem in Userspace).

FUSE allows a program to "pretend" to be a disk partition. When you browse a FUSE-mounted Tag File System, the folders you see aren't real. If you enter a directory named query/cats+cute/, the FUSE driver:

1. Intercepts the ls command.
2. Queries the SQLite database for files tagged with both "cats" and "cute".
3. Returns those files as if they were actually sitting in that folder.

If we wanted to build a tiny version of this, we'd start with a way to track these relationships. Here is a conceptual implementation using Go and a simple map (in reality, you'd use SQL).

EXPANDCOPY
go
package main

import (
	"fmt"
)

type FileID string

type TagSystem struct {
	// Maps Tag -> Set of FileIDs
	Tags map[string]map[FileID]bool
	// Maps FileID -> Set of Tags (for quick lookup)
	Files map[FileID]map[string]bool
}

func NewTagSystem() *TagSystem {
	return &TagSystem{
		Tags:  make(map[string]map[FileID]bool),
		Files: make(map[FileID]map[string]bool),
	}
}

func (ts *TagSystem) TagFile(file FileID, tag string) {
	if ts.Tags[tag] == nil {
		ts.Tags[tag] = make(map[FileID]bool)
	}
	if ts.Files[file] == nil {
		ts.Files[file] = make(map[string]bool)
	}
	ts.Tags[tag][file] = true
	ts.Files[file][tag] = true
}

func (ts *TagSystem) Query(tags ...string) []FileID {
	if len(tags) == 0 {
		return nil
	}

	// Start with the first tag's files
	results := make(map[FileID]bool)
	for f := range ts.Tags[tags[0]] {
		results[f] = true
	}

	// Intersect with subsequent tags (AND logic)
	for _, tag := range tags[1:] {
		for f := range results {
			if !ts.Tags[tag][f] {
				delete(results, f)
			}
		}
	}

	var final []FileID
	for f := range results {
		final = append(final, f)
	}
	return final
}

func main() {
	tfs := NewTagSystem()

	tfs.TagFile("vacation_01.jpg", "2024")
	tfs.TagFile("vacation_01.jpg", "beach")
	tfs.TagFile("work_notes.pdf", "2024")
	tfs.TagFile("work_notes.pdf", "boring")

	fmt.Println("Files from 2024 at the beach:", tfs.Query("2024", "beach"))
	// Output: [vacation_01.jpg]
}

Tag file systems sound like paradise, but why aren't we all using them as our primary OS?

1. The "Clean Room" Problem: Hierarchies are low-maintenance. You just throw a file in a folder. Tags require discipline. If you don't tag your files, they vanish into a black hole.
2. Standardization: There is no "Tagging Standard." If you move your files from Linux (TMSU) to macOS, your tags don't come with you unless they are embedded in the file metadata (like EXIF or ID3 tags).
3. Performance: Querying a database with 10 million files and complex tag intersections can be slower than a simple directory lookup.

Tag File Systems represent a move from location-based computing to meaning-based computing. While we might not be ready to ditch folders entirely, adding a tagging layer to your workflow—especially for large media libraries or research papers—can save you from the "Where did I put that?" nightmare.