{"id":78587,"date":"2026-09-16T01:21:47","date_gmt":"2026-09-16T01:21:47","guid":{"rendered":"https:\/\/www.devopsschool.com\/blog\/?p=78587"},"modified":"2026-09-16T01:21:51","modified_gmt":"2026-09-16T01:21:51","slug":"%cf%80fs-pi-file-system-complete-tutorial","status":"publish","type":"post","link":"https:\/\/www.devopsschool.com\/blog\/%cf%80fs-pi-file-system-complete-tutorial\/","title":{"rendered":"\u03c0fs (Pi File System) Complete Tutorial"},"content":{"rendered":"\n

What Is \u03c0fs, Why Does It Exist, How Does It Work, and What Can It Teach Us?<\/h2>\n\n\n\n

Updated: September 2026<\/strong><\/p>\n\n\n\n

\u03c0fs\u2014pronounced \u201cPi FS\u201d<\/strong> and commonly represented by the repository name pifs<\/code>\u2014is one of the strangest, funniest, and surprisingly educational filesystem experiments ever created.<\/p>\n\n\n\n

Its central idea sounds impossible:<\/p>\n\n\n\n

\n

Instead of storing your files on disk, find their contents somewhere inside the digits of \u03c0 and store only information describing where those contents can be found.<\/p>\n<\/blockquote>\n\n\n\n

If \u03c0 contains every possible finite sequence of digits, then somewhere inside \u03c0 should be:<\/p>\n\n\n\n

    \n
  • every text file,<\/li>\n\n\n\n
  • every image,<\/li>\n\n\n\n
  • every program,<\/li>\n\n\n\n
  • every video,<\/li>\n\n\n\n
  • every database,<\/li>\n\n\n\n
  • every ZIP archive,<\/li>\n\n\n\n
  • every file that has ever existed,<\/li>\n\n\n\n
  • and every finite file that could ever exist.<\/li>\n<\/ul>\n\n\n\n

    So why store the file itself?<\/p>\n\n\n\n

    Why not just store its location inside \u03c0<\/strong>?<\/p>\n\n\n\n

    That is the joke\u2014and the computer science lesson\u2014behind \u03c0fs.<\/p>\n\n\n\n

    \u03c0fs is a real FUSE filesystem written in C by Philip Langdale. It can be compiled and mounted on Linux, and ordinary commands such as cat<\/code>, echo<\/code>, cp<\/code>, ls<\/code>, and editors can interact with it through the filesystem interface. The project describes itself as a \u201cdata-free filesystem,\u201d although, as we will discover, the metadata required by the implementation is actually larger than the original data.<\/p>\n\n\n\n

    Today, \u03c0fs should be considered an experimental\/educational filesystem and an information-theory thought experiment\u2014not a production storage technology<\/strong>. The repository now explicitly directs users toward its newer spiritual successor, InferenceFS<\/strong>.<\/p>\n\n\n\n

    \n\n\n\n

    1. What Is \u03c0fs?<\/h1>\n\n\n\n

    \u03c0fs is a userspace filesystem that represents file bytes using positions in the hexadecimal expansion of \u03c0.<\/p>\n\n\n\n

    Conceptually, instead of storing:<\/p>\n\n\n

    Hello World\n<\/code><\/span><\/pre>\n\n\n
    the filesystem tries to store something conceptually resembling:<\/p>\n\n\n
    byte H -> position X in \u03c0\nbyte e -> position Y in \u03c0\nbyte l -> position Z in \u03c0\n...\n<\/code><\/span><\/pre>\n\n\n
    When the file is read again, \u03c0fs calculates the corresponding digits of \u03c0 and reconstructs each byte.<\/p>\n\n\n\n
    The filesystem interface is provided through FUSE\u2014Filesystem in Userspace<\/strong>.<\/p>\n\n\n\n
    FUSE allows a normal userspace application to behave like a filesystem. The Linux kernel forwards filesystem operations such as:<\/p>\n\n\n
    open()\nread()\nwrite()\nmkdir()\nunlink()\nstat()\n<\/code><\/span><\/pre>\n\n\n
    to the userspace filesystem implementation.<\/p>\n\n\n\n
    Modern libfuse documentation describes exactly this architecture: a standalone userspace process receives filesystem requests from the kernel through libfuse callbacks.<\/p>\n\n\n\n
    \u03c0fs implements those callbacks itself.<\/p>\n\n\n\n
    \n\n\n\n
    2. The Big Idea Behind \u03c0fs<\/h1>\n\n\n\n
    Suppose \u03c0 were a normal number<\/strong>.<\/p>\n\n\n\n
    Informally, a number is normal in a base if every finite sequence of digits occurs with the expected frequency.<\/p>\n\n\n\n
    For base 16, this would imply that sequences such as:<\/p>\n\n\n
    00\n01\n02\n...\nFE\nFF\n<\/code><\/span><\/pre>\n\n\n
    all appear repeatedly.<\/p>\n\n\n\n
    Longer sequences would also occur:<\/p>\n\n\n
    48656C6C6F\n<\/code><\/span><\/pre>\n\n\n
    which is hexadecimal for:<\/p>\n\n\n
    Hello\n<\/code><\/span><\/pre>\n\n\n
    and so would every other finite hexadecimal sequence.<\/p>\n\n\n\n
    Therefore, if \u03c0 is normal in base 16, every finite binary file can theoretically be represented somewhere within its hexadecimal expansion.<\/p>\n\n\n\n
    There is one enormous caveat:<\/p>\n\n\n\n
    \u03c0 has not been proven to be normal.<\/h2>\n\n\n\n
    The \u03c0fs premise relies on a widely studied but unproven property of \u03c0. Even the project’s issue tracker contains discussion pointing out that the required property has not been proven.<\/p>\n\n\n\n
    So the theoretical statement is:<\/p>\n\n\n\n
    \n
    If \u03c0 is normal\u2014or at least contains every finite hexadecimal sequence\u2014then every finite file occurs somewhere in \u03c0.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
    Not:<\/p>\n\n\n\n
    \n
    \u201cMathematics has proven that every possible file is inside \u03c0.\u201d<\/p>\n<\/blockquote>\n\n\n\n
    That distinction matters.<\/p>\n\n\n\n
    \n\n\n\n
    3. Why Hexadecimal?<\/h1>\n\n\n\n
    Computers store bytes.<\/p>\n\n\n\n
    One byte contains:<\/p>\n\n\n
    8 bits\n<\/code><\/span><\/pre>\n\n\n
    and therefore has:<\/p>\n\n\n
    2^8 = 256\n<\/code><\/span><\/pre>\n\n\n
    possible values.<\/p>\n\n\n\n
    A byte maps cleanly to two hexadecimal digits:<\/p>\n\n\n
    00000000 -> 00\n00000001 -> 01\n...\n11111111 -> FF\n<\/code><\/span><\/pre>\n\n\n
    So a binary file can simply be interpreted as a hexadecimal digit sequence.<\/p>\n\n\n\n
    For example:<\/p>\n\n\n
    Hello\n<\/code><\/span><\/pre>\n\n\n
    becomes:<\/p>\n\n\n
    48 65 6C 6C 6F\n<\/code><\/span><\/pre>\n\n\n
    \u03c0fs therefore works naturally with hexadecimal digits of \u03c0.<\/p>\n\n\n\n
    \n\n\n\n
    4. The Bailey\u2013Borwein\u2013Plouffe Formula<\/h1>\n\n\n\n
    A major ingredient in \u03c0fs is the Bailey\u2013Borwein\u2013Plouffe formula<\/strong>, commonly called BBP.<\/p>\n\n\n\n
    It can be written as:\u03c0<\/mi>=<\/mo>\u2211<\/mo>k<\/mi>=<\/mo>0<\/mn><\/mrow>\u221e<\/mi><\/munderover>1<\/mn>16<\/mn>k<\/mi><\/msup><\/mfrac>(<\/mo>4<\/mn>8<\/mn>k<\/mi>+<\/mo>1<\/mn><\/mrow><\/mfrac>\u2212<\/mo>2<\/mn>8<\/mn>k<\/mi>+<\/mo>4<\/mn><\/mrow><\/mfrac>\u2212<\/mo>1<\/mn>8<\/mn>k<\/mi>+<\/mo>5<\/mn><\/mrow><\/mfrac>\u2212<\/mo>1<\/mn>8<\/mn>k<\/mi>+<\/mo>6<\/mn><\/mrow><\/mfrac>)<\/mo><\/mrow><\/mrow>\\pi = \\sum_{k=0}^{\\infty} \\frac{1}{16^k} \\left( \\frac{4}{8k+1} – \\frac{2}{8k+4} – \\frac{1}{8k+5} – \\frac{1}{8k+6} \\right)<\/annotation><\/semantics><\/math><\/p>\n\n\n\n
    Why is this interesting?<\/p>\n\n\n\n
    Because BBP allows hexadecimal digits of \u03c0 near a particular position to be calculated without first calculating every preceding digit<\/strong>.<\/p>\n\n\n\n
    That gives \u03c0fs something similar to random access into \u03c0.<\/p>\n\n\n\n
    The bundled piqpr8.c<\/code> implementation describes itself as computing hexadecimal digits beginning at an arbitrary position. Its source notes that with IEEE 64-bit floating-point arithmetic, that implementation is reliable only up to roughly 1.18<\/mn>\u00d7<\/mo>10<\/mn>7<\/mn><\/msup><\/mrow>1.18 \\times 10^7<\/annotation><\/semantics><\/math> positions.<\/p>\n\n\n\n
    That is an important engineering distinction:<\/p>\n\n\n\n
    BBP helps retrieve digits at a known location.<\/h3>\n\n\n\n
    It does not magically tell you where an arbitrary file occurs in \u03c0<\/strong>.<\/p>\n\n\n\n
    Finding the position is still a search problem.<\/p>\n\n\n\n
    \n\n\n\n
    5. What \u03c0fs Actually Does<\/h1>\n\n\n\n
    This is where the implementation becomes much more interesting than the headline.<\/p>\n\n\n\n
    The original README explains that files are divided into individual bytes rather than attempting to search \u03c0 for an entire file at once.<\/p>\n\n\n\n
    For every byte being written, the implementation effectively does:<\/p>\n\n\n
    for<\/span> candidate_position = 0<\/span> ... maximum_position:\n    calculate byte from<\/span> \u03c0 at candidate_position\n\n    if<\/span> calculated_byte == wanted_byte:\n        save candidate_position\n        stop searching\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    The actual source contains essentially this algorithm:<\/p>\n\n\n
    for (index = 0; index < SHRT_MAX<\/span>; index<\/span>++) {\n    if<\/span> (get_byte<\/span>(index<\/span>) == *buf)<\/span> {\n        break<\/span>;\n    }\n}\n\nwrite<\/span>(info-<\/span>><\/span>fh, &index, sizeof index);\n<\/code><\/span>Code language:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
    So \u03c0fs does not<\/strong> search \u03c0 for your complete 10 MB photograph.<\/p>\n\n\n\n
    Instead, it searches for each possible byte independently.<\/p>\n\n\n\n
    \n\n\n\n
    6. \u03c0fs Architecture<\/h1>\n\n\n\n
    The architecture can be visualized as:<\/p>\n\n\n\n
                        Application\n                        |\n                  open\/read\/write\n                        |\n                        v\n                 Linux VFS Layer\n                        |\n                        v\n                    FUSE Kernel\n                        |\n                        v\n                     libfuse\n                        |\n                        v\n                 +-----------+\n                 |   \u03c0fs     |\n                 +-----------+\n                  \/         \\\n                 \/           \\\n                v             v\n       Metadata Directory   BBP Algorithm\n       ------------------   -------------\n       file paths           calculate\n       byte offsets         digits of \u03c0\n       permissions\n       timestamps\n<\/code><\/pre>\n\n\n\n
    For writes:<\/p>\n\n\n
    Application\n    |\n    | write byte\n    v\n\u03c0fs\n    |\n    | search positions in \u03c0\n    v\nBBP get_byte()\n    |\n    | find matching byte\n    v\nposition\/index\n    |\n    v\nmetadata file\n<\/code><\/span><\/pre>\n\n\n
    For reads:<\/p>\n\n\n
    Application\n    |\n    | read()\n    v\n\u03c0fs\n    |\n    | read stored index\n    v\nmetadata\n    |\n    v\nBBP get_byte(index)\n    |\n    v\noriginal byte\n<\/code><\/span><\/pre>\n\n\n
    \n\n\n\n
    7. The Metadata Directory<\/h1>\n\n\n\n
    \u03c0fs requires one important custom configuration parameter:<\/p>\n\n\n
    mdd=<metadata-directory<\/span>><\/span>\n<\/code><\/span>Code language:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
    Example:<\/p>\n\n\n
    \u03c0fs -o mdd=\/home\/u<\/span>ser\/pifs-meta \/home\/user\/pifs-mount\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    The repository defines only one \u03c0fs-specific option:<\/p>\n\n\n
    struct options {\n    char *mdd;\n};\n\nPIFS_OPT_KEY(\"mdd=%s\"<\/span>, mdd, 0<\/span>)\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    and refuses to start unless that directory exists and is readable, writable, and executable by the process.<\/p>\n\n\n\n
    The metadata directory holds the actual filesystem structure underlying \u03c0fs.<\/p>\n\n\n\n
    \n\n\n\n
    8. The Great \u03c0fs Punchline: Metadata Is Bigger Than the Data<\/h1>\n\n\n\n
    Suppose your file contains one byte:<\/p>\n\n\n
    A\n<\/code><\/span><\/pre>\n\n\n
    The current implementation searches \u03c0 for that byte and stores its position using:<\/p>\n\n\n
    short index;\n<\/code><\/span><\/pre>\n\n\n
    On typical modern Linux systems:<\/p>\n\n\n
    sizeof(short) = 2 bytes\n<\/code><\/span><\/pre>\n\n\n
    So roughly:<\/p>\n\n\n
    1 byte logical data\n      \u2193\n2 bytes \u03c0fs metadata\n<\/code><\/span><\/pre>\n\n\n
    For a 1 MB file:<\/p>\n\n\n
    Logical file:\n~1 MB\n\n\u03c0fs position metadata:\n~2 MB\n<\/code><\/span><\/pre>\n\n\n
    The code explicitly seeks through the backing metadata using:<\/p>\n\n\n
    offset * 2\n<\/code><\/span><\/pre>\n\n\n
    and its path-based getattr()<\/code> divides the physical metadata size by two before reporting the logical size.<\/p>\n\n\n\n
    So instead of infinite compression, this implementation typically produces something close to:<\/p>\n\n\n
    Compression ratio \u2248 -100%\n<\/code><\/span><\/pre>\n\n\n
    or, more plainly:<\/p>\n\n\n
    Storage used \u2248 200% of the original file\n<\/code><\/span><\/pre>\n\n\n
    before counting filesystem metadata.<\/p>\n\n\n\n
    This is intentional comedy\u2014but also a superb information-theory demonstration.<\/p>\n\n\n\n
    \n\n\n\n
    9. Why \u03c0fs Cannot Beat Information Theory<\/h1>\n\n\n\n
    Imagine a random file containing N<\/code> bits.<\/p>\n\n\n\n
    There are:2<\/mn>N<\/mi><\/msup><\/mrow>2^N<\/annotation><\/semantics><\/math><\/p>\n\n\n\n
    possible N-bit files.<\/p>\n\n\n\n
    If a lossless compression system mapped every<\/strong> possible N-bit file to fewer than N bits, there would not be enough shorter representations available.<\/p>\n\n\n\n
    This follows directly from the pigeonhole principle.<\/p>\n\n\n\n
    Some data can certainly be compressed:<\/p>\n\n\n
    AAAAAAAAAAAAAAAAAAAAAAAA\n<\/code><\/span><\/pre>\n\n\n
    contains strong redundancy.<\/p>\n\n\n\n
    But random-looking data such as encrypted or already-compressed data usually contains little exploitable redundancy.<\/p>\n\n\n\n
    \u03c0fs does not make that information disappear.<\/p>\n\n\n\n
    Instead, it effectively moves the information into:<\/p>\n\n\n
    positions inside \u03c0\n<\/code><\/span><\/pre>\n\n\n
    The location information must contain enough information to distinguish the original content.<\/p>\n\n\n\n
    The \u201caddress\u201d becomes the data.<\/p>\n\n\n\n
    That is the deeper lesson behind \u03c0fs.<\/p>\n\n\n\n
    \n\n\n\n
    10. Why Searching for an Entire File Would Be Worse<\/h1>\n\n\n\n
    Suppose \u03c0 behaves approximately like a random stream of hexadecimal digits.<\/p>\n\n\n\n
    There are:<\/p>\n\n\n
    256\n<\/code><\/span><\/pre>\n\n\n
    possible one-byte values.<\/p>\n\n\n\n
    Finding a particular byte would therefore require, very roughly, hundreds of candidate positions.<\/p>\n\n\n\n
    But a two-byte value has:<\/p>\n\n\n
    256\u00b2 = 65,536\n<\/code><\/span><\/pre>\n\n\n
    possibilities.<\/p>\n\n\n\n
    Three bytes:<\/p>\n\n\n
    256\u00b3 = 16,777,216\n<\/code><\/span><\/pre>\n\n\n
    Four bytes:<\/p>\n\n\n
    256\u2074 = 4,294,967,296\n<\/code><\/span><\/pre>\n\n\n
    For an N-byte random string, its expected location grows on the rough scale of:256<\/mn>N<\/mi><\/msup>=<\/mo>2<\/mn>8<\/mn>N<\/mi><\/mrow><\/msup><\/mrow>256^N = 2^{8N}<\/annotation><\/semantics><\/math><\/p>\n\n\n\n
    The binary representation of an index that large itself approaches approximately:<\/p>\n\n\n
    8N bits\n<\/code><\/span><\/pre>\n\n\n
    \u2014the size of the original file.<\/p>\n\n\n\n
    And searching such a space would be computationally absurd.<\/p>\n\n\n\n
    Breaking the file into individual bytes therefore makes the demo executable, but destroys any supposed storage advantage.<\/p>\n\n\n\n
    \n\n\n\n
    11. What Happens During a Write?<\/h1>\n\n\n\n
    Consider:<\/p>\n\n\n
    printf<\/span> A<\/span> > file<\/span>.txt<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
    The application calls:<\/p>\n\n\n
    write()\n<\/code><\/span><\/pre>\n\n\n
    FUSE forwards that request to \u03c0fs.<\/p>\n\n\n\n
    \u03c0fs executes its pifs_write()<\/code> callback.<\/p>\n\n\n\n
    For the byte A<\/code>, \u03c0fs repeatedly calls:<\/p>\n\n\n
    get_byte(index)\n<\/code><\/span><\/pre>\n\n\n
    starting from index zero.<\/p>\n\n\n\n
    get_byte()<\/code> invokes the BBP-related calculations in piqpr8.c<\/code>.<\/p>\n\n\n\n
    Eventually:<\/p>\n\n\n
    calculated byte == A\n<\/code><\/span><\/pre>\n\n\n
    \u03c0fs writes the corresponding numeric index into the metadata file.<\/p>\n\n\n\n
    For another byte, the process starts again.<\/p>\n\n\n\n
    And again.<\/p>\n\n\n\n
    And again.<\/p>\n\n\n\n
    The current implementation does not maintain a permanent precomputed 256-byte lookup table during the write process; each byte performs the search loop shown in the source.<\/p>\n\n\n\n
    That contributes heavily to its poor write performance.<\/p>\n\n\n\n
    \n\n\n\n
    12. What Happens During a Read?<\/h1>\n\n\n\n
    Reading reverses the process.<\/p>\n\n\n\n
    The metadata might conceptually contain:<\/p>\n\n\n
    23\n91\n37\n37\n105\n<\/code><\/span><\/pre>\n\n\n
    \u03c0fs reads each stored index and executes:<\/p>\n\n\n
    get_byte(23)\nget_byte(91)\nget_byte(37)\n...\n<\/code><\/span><\/pre>\n\n\n
    Each call calculates the appropriate digits of \u03c0.<\/p>\n\n\n\n
    Those values reconstruct the logical file.<\/p>\n\n\n\n
    The actual read callback loads a short<\/code> index and passes it into get_byte(index)<\/code>.<\/p>\n\n\n\n
    \n\n\n\n
    13. Why \u03c0fs Uses FUSE<\/h1>\n\n\n\n
    Writing an ordinary kernel filesystem would require kernel-level filesystem code.<\/p>\n\n\n\n
    FUSE provides a much simpler model.<\/p>\n\n\n\n
    An application performs:<\/p>\n\n\n
    cat \/mnt\/pifs\/example.txt\n<\/code><\/span><\/pre>\n\n\n
    Linux sees:<\/p>\n\n\n
    \/mnt\/pifs\n<\/code><\/span><\/pre>\n\n\n
    as a mounted filesystem.<\/p>\n\n\n\n
    The request travels:<\/p>\n\n\n
    Application\n   \u2193\nLinux VFS\n   \u2193\nFUSE kernel interface<\/span>\n   \u2193\nlibfuse<\/span>\n   \u2193\n\u03c0fs<\/span> userspace<\/span> process<\/span>\n<\/span><\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
    \u03c0fs produces the data and sends it back.<\/p>\n\n\n\n
    This makes \u03c0fs particularly useful for learning how virtual filesystems work.<\/p>\n\n\n\n
    \n\n\n\n
    14. \u03c0fs Source-Code Components<\/h1>\n\n\n\n
    The repository is pleasantly small.<\/p>\n\n\n\n
    The core pieces are:<\/p>\n\n\n
    pifs\/\n\u251c\u2500\u2500 autogen.sh\n\u251c\u2500\u2500 configure.ac\n\u251c\u2500\u2500 Makefile.am\n\u2514\u2500\u2500 src\/\n    \u251c\u2500\u2500 Makefile.am\n    \u251c\u2500\u2500 \u03c0fs.c\n    \u2514\u2500\u2500 piqpr8.c\n<\/code><\/span><\/pre>\n\n\n
    \u03c0fs.c<\/code><\/h2>\n\n\n\n
    Implements the FUSE filesystem.<\/p>\n\n\n\n
    Among its callbacks are:<\/p>\n\n\n
    getattr\nreadlink\nmknod\nmkdir\nunlink\nrmdir\nsymlink\nrename\nlink\nchmod\nchown\ntruncate\nopen\nread\nwrite\nstatfs\nrelease\nfsync\nsetxattr\ngetxattr\nlistxattr\nremovexattr\nopendir\nreaddir\ncreate\nlock\nutimens\n<\/code><\/span><\/pre>\n\n\n
    piqpr8.c<\/code><\/h2>\n\n\n\n
    Contains the BBP-based hexadecimal \u03c0 digit implementation.<\/p>\n\n\n\n
    Its public function is:<\/p>\n\n\n
    unsigned char get_byte(int id)\n<\/code><\/span><\/pre>\n\n\n
    which generates two hexadecimal digits and combines them into one byte.<\/p>\n\n\n\n
    configure.ac<\/code><\/h2>\n\n\n\n
    The build configuration declares:<\/p>\n\n\n
    \u03c0FS version 1.0\nC99\nFUSE >= 2.8\n<\/code><\/span><\/pre>\n\n\n
    That FUSE requirement becomes important on modern Linux distributions.<\/p>\n\n\n\n
    \n\n\n\n
    15. \u03c0fs and FUSE 2 vs FUSE 3<\/h1>\n\n\n\n
    The original code defines:<\/p>\n\n\n
    #define<\/span> FUSE_USE_VERSION<\/span> 26\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
    and includes:<\/p>\n\n\n
    #include <fuse<\/span>\/fuse.h<\/span>><\/span>\n<\/code><\/span>Code language:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
    Its build system specifically asks pkg-config<\/code> for:<\/p>\n\n\n
    fuse >= 2.8\n<\/code><\/span><\/pre>\n\n\n
    In other words:<\/p>\n\n\n\n
    \u03c0fs is a FUSE 2-era application.<\/h2>\n\n\n\n
    Modern libfuse development primarily revolves around FUSE 3. As of 2026, upstream libfuse has reached the 3.18 generation.<\/p>\n\n\n\n
    Fortunately, several distributions still provide compatibility development packages for FUSE 2.<\/p>\n\n\n\n
    For example, Ubuntu 24.04 provides:<\/p>\n\n\n
    libfuse-dev<\/span> 2.9<\/span>.9<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
    Fedora also continues publishing FUSE v2 fuse-devel<\/code> packages; Fedora 45 has FUSE 2.9.9 development files available.<\/p>\n\n\n\n
    \n\n\n\n
    16. Recommended Environment in 2026<\/h1>\n\n\n\n
    For the least-friction experiment, use:<\/p>\n\n\n
    Ubuntu<\/span> 24.04<\/span> LTS<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
    or another Linux environment where the complete FUSE 2 stack is readily available.<\/p>\n\n\n\n
    Ubuntu 24.04 still provides both the FUSE 2 development library and FUSE 2 utility package.<\/p>\n\n\n\n
    Newer distributions are gradually transitioning their command-line FUSE tooling to FUSE 3.<\/p>\n\n\n\n
    For example, Debian 13\/Trixie’s fuse<\/code> package is now transitional and depends on fuse3<\/code>, although the FUSE 2 development library remains available.<\/p>\n\n\n\n
    Similarly, Ubuntu 26.04 keeps the FUSE 2 development library but its fuse<\/code> source package no longer produces the old FUSE 2 utility binary.<\/p>\n\n\n\n
    Therefore, for learning \u03c0fs rather than debugging old FUSE compatibility:<\/p>\n\n\n\n
    \n
    Ubuntu 24.04 is a particularly convenient demo environment.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
    \n\n\n\n
    17. Installing \u03c0fs on Ubuntu 24.04<\/h1>\n\n\n\n
    Start by updating package metadata:<\/p>\n\n\n
    sudo apt update\n<\/code><\/span><\/pre>\n\n\n
    Install the compiler and build dependencies:<\/p>\n\n\n
    sudo apt install \\\n    git \\\n    build-essential \\\n    autoconf \\\n    automake \\\n    autotools-dev \\\n    pkg-config \\\n    libfuse-dev\n<\/code><\/span><\/pre>\n\n\n
    Verify the FUSE 2 development package:<\/p>\n\n\n
    pkg-config --modversion fuse\n<\/code><\/span><\/pre>\n\n\n
    You should see something similar to:<\/p>\n\n\n
    2.9<\/span>.9<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
    Check whether the FUSE mount helper is available:<\/p>\n\n\n
    command -v fusermount\n<\/code><\/span><\/pre>\n\n\n
    If your Ubuntu 24.04 installation does not contain it, inspect the package transaction and install the FUSE 2 utility package:<\/p>\n\n\n
    sudo apt install fuse\n<\/code><\/span><\/pre>\n\n\n
    Ubuntu 24.04 publishes the FUSE 2.9.9 utility package separately from FUSE 3.<\/p>\n\n\n\n
    \n\n\n\n
    18. Clone \u03c0fs<\/h1>\n\n\n\n
    Clone the repository:<\/p>\n\n\n
    git clone<\/span> https:\/\/github.com\/philipl\/pifs.git<\/span>\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
    Enter it:<\/p>\n\n\n
    cd pifs\n<\/code><\/span><\/pre>\n\n\n
    Inspect the project:<\/p>\n\n\n
    ls\n<\/code><\/span><\/pre>\n\n\n
    You should see files including:<\/p>\n\n\n
    README.md\nautogen.sh\nconfigure.ac\nMakefile.am\nsrc\/\n<\/code><\/span><\/pre>\n\n\n
    \n\n\n\n
    19. Generate the Build System<\/h1>\n\n\n\n
    Run:<\/p>\n\n\n
    .\/autogen.sh\n<\/code><\/span><\/pre>\n\n\n
    An interesting minor detail: the current autogen.sh<\/code> already executes:<\/p>\n\n\n
    autoreconf --install\n<\/code><\/span><\/pre>\n\n\n
    and then runs:<\/p>\n\n\n
    configure\n<\/code><\/span><\/pre>\n\n\n
    itself.<\/p>\n\n\n\n
    Therefore the README sequence:<\/p>\n\n\n
    .\/autogen.sh\n.\/configure\n<\/code><\/span><\/pre>\n\n\n
    contains a redundant second configure step.<\/p>\n\n\n\n
    It is harmless, but normally:<\/p>\n\n\n
    .\/autogen.sh\nmake\n<\/code><\/span><\/pre>\n\n\n
    is sufficient.<\/p>\n\n\n\n
    \n\n\n\n
    20. Compile \u03c0fs<\/h1>\n\n\n\n
    Run:<\/p>\n\n\n
    make\n<\/code><\/span><\/pre>\n\n\n
    or:<\/p>\n\n\n
    make -j\"$(nproc)\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    The resulting program should appear as:<\/p>\n\n\n
    src\/\u03c0fs\n<\/code><\/span><\/pre>\n\n\n
    Verify:<\/p>\n\n\n
    ls -l src\/\u03c0fs\n<\/code><\/span><\/pre>\n\n\n
    You can experiment without globally installing anything.<\/p>\n\n\n\n
    \n\n\n\n
    21. Optional System Installation<\/h1>\n\n\n\n
    If you want the executable in the system path:<\/p>\n\n\n
    sudo make install\n<\/code><\/span><\/pre>\n\n\n
    Then:<\/p>\n\n\n
    command -v \u03c0fs\n<\/code><\/span><\/pre>\n\n\n
    may return something similar to:<\/p>\n\n\n
    \/usr\/local\/bin\/\u03c0fs\n<\/code><\/span><\/pre>\n\n\n
    The executable itself genuinely contains the Unicode character:<\/p>\n\n\n
    \u03c0\n<\/code><\/span><\/pre>\n\n\n
    in its name.<\/p>\n\n\n\n
    If typing that is inconvenient, create a shell alias:<\/p>\n\n\n
    alias pifs='\u03c0fs'<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    or a symlink:<\/p>\n\n\n
    sudo ln -s \/usr\/local\/bin\/\u03c0fs \/usr\/local\/bin\/pifs\n<\/code><\/span><\/pre>\n\n\n
    Then you can run:<\/p>\n\n\n
    pifs\n<\/code><\/span><\/pre>\n\n\n
    instead.<\/p>\n\n\n\n
    \n\n\n\n
    22. Create the \u03c0fs Directories<\/h1>\n\n\n\n
    \u03c0fs needs two directories.<\/p>\n\n\n\n
    Metadata directory<\/h3>\n\n\n
    mkdir -p ~\/pifs-meta\n<\/code><\/span><\/pre>\n\n\n
    Mount point<\/h3>\n\n\n
    mkdir -p ~\/pifs-mount\n<\/code><\/span><\/pre>\n\n\n
    They serve completely different purposes.<\/p>\n\n\n
    ~\/pifs-meta\n<\/code><\/span><\/pre>\n\n\n
    contains the physical metadata representation.<\/p>\n\n\n
    ~\/pifs-mount\n<\/code><\/span><\/pre>\n\n\n
    is where applications see the virtual \u03c0fs filesystem.<\/p>\n\n\n\n
    \n\n\n\n
    23. Mount \u03c0fs<\/h1>\n\n\n\n
    From the source tree:<\/p>\n\n\n
    .\/src\/\u03c0fs \\\n    -o mdd=\"$HOME\/pifs-meta\"<\/span> \\\n    \"$HOME\/pifs-mount\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    If installed globally:<\/p>\n\n\n
    \u03c0fs \\\n    -o mdd=\"$HOME\/pifs-meta\"<\/span> \\\n    \"$HOME\/pifs-mount\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    The canonical syntax from the project is:<\/p>\n\n\n
    \u03c0fs -o mdd=<metadata-directory<\/span>><\/span> <mountpoint<\/span>><\/span>\n<\/code><\/span>Code language:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
    \n\n\n\n
    24. Run \u03c0fs in Foreground Mode<\/h1>\n\n\n\n
    For learning and troubleshooting, foreground mode is better:<\/p>\n\n\n
    .\/src\/\u03c0fs \\\n    -f \\\n    -o mdd=\"$HOME\/pifs-meta\"<\/span> \\\n    \"$HOME\/pifs-mount\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Keep that terminal open.<\/p>\n\n\n\n
    Then use another terminal for experiments.<\/p>\n\n\n\n
    \n\n\n\n
    25. Enable FUSE Debugging<\/h1>\n\n\n\n
    For a particularly instructive demo:<\/p>\n\n\n
    .\/src\/\u03c0fs \\\n    -d \\\n    -o mdd=\"$HOME\/pifs-meta\"<\/span> \\\n    \"$HOME\/pifs-mount\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    FUSE’s debug mode shows filesystem activity while applications interact with the mount.<\/p>\n\n\n\n
    Try another terminal:<\/p>\n\n\n
    ls ~\/pifs-mount\n<\/code><\/span><\/pre>\n\n\n
    and watch requests arrive.<\/p>\n\n\n\n
    This is one of the best ways to understand the relationship between applications, the kernel, FUSE and filesystem callbacks.<\/p>\n\n\n\n
    \n\n\n\n
    26. Your First File<\/h1>\n\n\n\n
    Create a tiny file:<\/p>\n\n\n
    printf 'Hello'<\/span> > ~\/pifs-mount\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Read it:<\/p>\n\n\n
    cat ~\/pifs-mount\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Expected logical result:<\/p>\n\n\n
    Hello\n<\/code><\/span><\/pre>\n\n\n
    Check its logical size:<\/p>\n\n\n
    wc -c ~\/pifs-mount\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Then inspect the physical metadata:<\/p>\n\n\n
    ls -l ~\/pifs-meta\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    and:<\/p>\n\n\n
    xxd ~\/pifs-meta\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    You are not looking at:<\/p>\n\n\n
    48 65 6c 6c 6f\n<\/code><\/span><\/pre>\n\n\n
    \u2014the ordinary byte representation of Hello<\/code>.<\/p>\n\n\n\n
    Instead you are looking at the indexes \u03c0fs recorded for those bytes.<\/p>\n\n\n\n
    That is \u03c0fs in action.<\/p>\n\n\n\n
    \n\n\n\n
    27. A Better Experiment<\/h1>\n\n\n\n
    Create:<\/p>\n\n\n
    printf 'AAAAAA'<\/span> > ~\/pifs-mount\/<\/span>a.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Then examine:<\/p>\n\n\n
    xxd ~\/pifs-meta\/<\/span>a.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Because the implementation always begins searching from position zero, identical input bytes should resolve to the same first matching offset.<\/p>\n\n\n\n
    Therefore repeated characters generate repeated metadata indexes.<\/p>\n\n\n\n
    Now compare with:<\/p>\n\n\n
    printf 'ABCDEF'<\/span> > ~\/pifs-mount\/<\/span>b.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    and:<\/p>\n\n\n
    xxd ~\/pifs-meta\/<\/span>b.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    This gives you a simple visual demonstration of how the representation works.<\/p>\n\n\n\n
    \n\n\n\n
    28. Verify \u03c0fs Is Really Recomputing Data<\/h1>\n\n\n\n
    Read your file:<\/p>\n\n\n
    cat ~\/pifs-mount\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    The underlying metadata file does not contain the literal string:<\/p>\n\n\n
    Hello\n<\/code><\/span><\/pre>\n\n\n
    \u03c0fs instead:<\/p>\n\n\n\n
      \n
    1. reads an index,<\/li>\n\n\n\n
    2. calls get_byte(index)<\/code>,<\/li>\n\n\n\n
    3. calculates \u03c0 digits using BBP,<\/li>\n\n\n\n
    4. reconstructs the byte,<\/li>\n\n\n\n
    5. returns it through FUSE.<\/li>\n<\/ol>\n\n\n\n
      This behavior is directly visible in pifs_read()<\/code>.<\/p>\n\n\n\n
      \n\n\n\n
      29. Create Directories<\/h1>\n\n\n\n
      Because \u03c0fs exposes normal filesystem operations, try:<\/p>\n\n\n
      mkdir ~\/pifs-mount\/<\/span>demo\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Then:<\/p>\n\n\n
      echo test > ~\/pifs-mount\/<\/span>demo\/test.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      List it:<\/p>\n\n\n
      find ~\/pifs-mount\n<\/code><\/span><\/pre>\n\n\n
      The directory structure itself is represented inside the metadata directory.<\/p>\n\n\n\n
      Inspect:<\/p>\n\n\n
      find ~\/pifs-meta\n<\/code><\/span><\/pre>\n\n\n
      This reveals another important concept:<\/p>\n\n\n\n
      \n
      \u03c0fs is not generating filenames or directory hierarchy from \u03c0.<\/p>\n<\/blockquote>\n\n\n\n
      Those are real metadata stored on your disk.<\/p>\n\n\n\n
      \n\n\n\n
      30. Unmount \u03c0fs<\/h1>\n\n\n\n
      On a FUSE 2 environment:<\/p>\n\n\n
      fusermount -u ~\/pifs-mount\n<\/code><\/span><\/pre>\n\n\n
      Alternatively:<\/p>\n\n\n
      umount ~\/pifs-mount\n<\/code><\/span><\/pre>\n\n\n
      may work depending on your environment and privileges.<\/p>\n\n\n\n
      Before deleting anything, confirm:<\/p>\n\n\n
      mount | grep pifs\n<\/code><\/span><\/pre>\n\n\n
      or:<\/p>\n\n\n
      findmnt ~\/pifs-mount\n<\/code><\/span><\/pre>\n\n\n
      \n\n\n\n
      31. Restart \u03c0fs<\/h1>\n\n\n\n
      Your metadata remains in:<\/p>\n\n\n
      ~\/pifs-meta\n<\/code><\/span><\/pre>\n\n\n
      Mount it again:<\/p>\n\n\n
      .\/src\/\u03c0fs \\\n    -o mdd=\"$HOME\/pifs-meta\"<\/span> \\\n    \"$HOME\/pifs-mount\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Then:<\/p>\n\n\n
      cat ~\/pifs-mount\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      \u03c0fs uses the stored offsets to reconstruct the file again.<\/p>\n\n\n\n
      \n\n\n\n
      32. What Happens If You Delete the Metadata?<\/h1>\n\n\n\n
      Suppose you delete:<\/p>\n\n\n
      ~\/pifs-meta\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Your byte sequence theoretically still exists somewhere in \u03c0.<\/p>\n\n\n\n
      But \u03c0fs no longer knows:<\/p>\n\n\n
      where\n<\/code><\/span><\/pre>\n\n\n
      to retrieve those bytes.<\/p>\n\n\n\n
      The project README turns this into part of the joke: your files may \u201cstill be in \u03c0,\u201d but without their positions the useful information has effectively been lost.<\/p>\n\n\n\n
      Operationally:<\/p>\n\n\n\n
      \n
      The metadata is your data.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
      Protect it exactly as you would protect the original file.<\/p>\n\n\n\n
      \n\n\n\n
      33. \u03c0fs Configuration<\/h1>\n\n\n\n
      \u03c0fs itself has almost no configuration.<\/p>\n\n\n\n
      Its principal custom option is:<\/p>\n\n\n
      mdd\n<\/code><\/span><\/pre>\n\n\n
      Example:<\/p>\n\n\n
      \u03c0fs -o mdd=\/srv\/<\/span>pifs-metadata \/mnt\/pifs\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Standard FUSE options may also be processed through libfuse.<\/p>\n\n\n\n
      Common FUSE-style execution options include:<\/p>\n\n\n
      -f\n<\/code><\/span><\/pre>\n\n\n
      foreground mode.<\/p>\n\n\n
      -d\n<\/code><\/span><\/pre>\n\n\n
      debug mode.<\/p>\n\n\n
      -s\n<\/code><\/span><\/pre>\n\n\n
      single-threaded mode.<\/p>\n\n\n\n
      A learning-oriented invocation might therefore be:<\/p>\n\n\n
      \u03c0fs \\\n    -f \\\n    -s \\\n    -o mdd=\"$HOME\/pifs-meta\"<\/span> \\\n    \"$HOME\/pifs-mount\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      \n\n\n\n
      34. allow_other<\/code><\/h1>\n\n\n\n
      FUSE normally restricts filesystem access to the user who mounted it.<\/p>\n\n\n\n
      A FUSE filesystem may support:<\/p>\n\n\n
      -o allow_other\n<\/code><\/span><\/pre>\n\n\n
      to make the mount accessible to other users.<\/p>\n\n\n\n
      For unprivileged users, libfuse requires:<\/p>\n\n\n
      user_allow_other\n<\/code><\/span><\/pre>\n\n\n
      to be enabled in:<\/p>\n\n\n
      \/etc\/fuse.conf\n<\/code><\/span><\/pre>\n\n\n
      before allow_other<\/code> can be used.<\/p>\n\n\n\n
      For \u03c0fs experimentation, there is usually no reason to enable this.<\/p>\n\n\n\n
      Keep your demo private.<\/p>\n\n\n\n
      \n\n\n\n
      35. Fedora Installation<\/h1>\n\n\n\n
      Fedora continues shipping FUSE 2 compatibility packages.<\/p>\n\n\n\n
      Install:<\/p>\n\n\n
      sudo dnf install \\\n    git \\\n    gcc \\\n    make \\\n    autoconf \\\n    automake \\\n    pkgconf-pkg-config \\\n    fuse \\\n    fuse-devel\n<\/code><\/span><\/pre>\n\n\n
      Fedora explicitly describes fuse-devel<\/code> as the development package for FUSE v2 applications\/filesystems<\/strong>.<\/p>\n\n\n\n
      Then follow the same build procedure:<\/p>\n\n\n
      git clone<\/span> https:\/\/github.com\/philipl\/pifs.git<\/span>\ncd pifs\n.\/autogen.sh\nmake\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
      \n\n\n\n
      36. macOS<\/h1>\n\n\n\n
      Modern libfuse documentation recommends macFUSE<\/strong> for macOS rather than Linux libfuse.<\/p>\n\n\n\n
      However, \u03c0fs itself was written around the Linux\/FUSE 2 environment and uses Linux-oriented APIs.<\/p>\n\n\n\n
      Therefore the easiest path for macOS users is usually:<\/p>\n\n\n
      macOS<\/span>\n   \u2193\nLinux<\/span> VM<\/span>\n   \u2193\nUbuntu<\/span> 24.04<\/span>\n   \u2193\n\u03c0fs<\/span>\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
      rather than attempting to modernize the \u03c0fs C source for macFUSE.<\/p>\n\n\n\n
      If your goal is learning \u03c0fs rather than porting old filesystem code, a small Linux VM is much less distracting.<\/p>\n\n\n\n
      \n\n\n\n
      37. Windows<\/h1>\n\n\n\n
      \u03c0fs does not provide a native Windows implementation.<\/p>\n\n\n\n
      The practical learning options are:<\/p>\n\n\n
      Linux VM\n<\/code><\/span><\/pre>\n\n\n
      or potentially a suitable Linux environment with FUSE support.<\/p>\n\n\n\n
      A conventional VM is the simpler choice because FUSE requires actual filesystem\/kernel integration.<\/p>\n\n\n\n
      \n\n\n\n
      38. Containers and \u03c0fs<\/h1>\n\n\n\n
      Running FUSE filesystems inside containers is possible but adds additional complexity.<\/p>\n\n\n\n
      A container typically needs access to:<\/p>\n\n\n
      \/dev\/fuse\n<\/code><\/span><\/pre>\n\n\n
      and additional privileges\/capabilities.<\/p>\n\n\n\n
      That means Docker is not necessarily the best first \u03c0fs environment.<\/p>\n\n\n\n
      For learning:<\/p>\n\n\n
      Linux VM > privileged container\n<\/code><\/span><\/pre>\n\n\n
      because a VM gives the filesystem normal kernel access without weakening a container security boundary.<\/p>\n\n\n\n
      \n\n\n\n
      39. Performance<\/h1>\n\n\n\n
      \u03c0fs is extremely slow compared with ordinary filesystems.<\/p>\n\n\n\n
      The project’s own README famously notes that storing a roughly 400-line text file could take minutes.<\/p>\n\n\n\n
      There are several reasons.<\/p>\n\n\n\n
      Reason 1: Byte-by-byte search<\/h2>\n\n\n\n
      Every byte is handled independently.<\/p>\n\n\n\n
      Reason 2: Search begins from zero<\/h2>\n\n\n\n
      The write implementation loops:<\/p>\n\n\n
      index = 0\nindex = 1\nindex = 2\n...\n<\/code><\/span><\/pre>\n\n\n
      until it finds the desired byte.<\/p>\n\n\n\n
      Reason 3: BBP calculation<\/h2>\n\n\n\n
      Testing each position requires mathematical computation.<\/p>\n\n\n\n
      Reason 4: Repeated work<\/h2>\n\n\n\n
      If the same byte appears repeatedly, the implementation performs the search again instead of simply consulting a persistent 256-entry mapping.<\/p>\n\n\n\n
      Reason 5: Userspace filesystem overhead<\/h2>\n\n\n\n
      Each filesystem operation also crosses the kernel\/FUSE\/userspace boundary.<\/p>\n\n\n\n
      Performance was never the actual objective.<\/p>\n\n\n\n
      \n\n\n\n
      40. Why a 256-Entry Cache Would Make \u03c0fs Much Faster<\/h1>\n\n\n\n
      Because there are only:<\/p>\n\n\n
      256\n<\/code><\/span><\/pre>\n\n\n
      possible byte values, we could compute:<\/p>\n\n\n
      byte 0x00 -> \u03c0 index\nbyte 0x01 -> \u03c0 index\n...\nbyte 0xFF -> \u03c0 index\n<\/code><\/span><\/pre>\n\n\n
      once.<\/p>\n\n\n\n
      Then writing could become:<\/p>\n\n\n
      index = lookup_table[input_byte]\n<\/code><\/span><\/pre>\n\n\n
      instead of repeatedly searching \u03c0.<\/p>\n\n\n\n
      That would make the system substantially faster.<\/p>\n\n\n\n
      But notice what happened.<\/p>\n\n\n\n
      We now have:<\/p>\n\n\n
      a lookup dictionary\n+\nan index for every byte\n<\/code><\/span><\/pre>\n\n\n
      which emphasizes even more clearly that \u03c0 is not providing magical compression.<\/p>\n\n\n\n
      The encoding still carries the information.<\/p>\n\n\n\n
      \n\n\n\n
      41. Why Not Store One Bit at a Time?<\/h1>\n\n\n\n
      There are only two possible bits:<\/p>\n\n\n
      0\n1\n<\/code><\/span><\/pre>\n\n\n
      Find one \u03c0 location containing 0<\/code> and one containing 1<\/code>.<\/p>\n\n\n\n
      Then every file could be represented as references to those two locations.<\/p>\n\n\n\n
      Wonderful!<\/p>\n\n\n\n
      Except your representation is now essentially:<\/p>\n\n\n
      0 -> reference A\n1 -> reference B\n<\/code><\/span><\/pre>\n\n\n
      which is just another representation of:<\/p>\n\n\n
      0\n1\n<\/code><\/span><\/pre>\n\n\n
      You have recreated the original information with more steps.<\/p>\n\n\n\n
      This thought experiment gets directly to the heart of why \u03c0fs is so educational.<\/p>\n\n\n\n
      \n\n\n\n
      42. Is \u03c0fs Compression?<\/h1>\n\n\n\n
      Not usefully.<\/p>\n\n\n\n
      A conventional compressor finds redundancy inside the input.<\/p>\n\n\n\n
      For example:<\/p>\n\n\n
      AAAAAAAAAAAAAAAA\n<\/code><\/span><\/pre>\n\n\n
      might become approximately:<\/p>\n\n\n
      \"16 copies of A\"<\/span>\n<\/code><\/span>Code language:<\/span> JSON \/ JSON with Comments<\/span> (<\/span>json<\/span>)<\/span><\/small><\/pre>\n\n\n
      \u03c0fs instead replaces symbols with references into a deterministic sequence.<\/p>\n\n\n\n
      If those references require as much or more information than the original symbols, nothing has been compressed.<\/p>\n\n\n\n
      \u03c0fs is better understood as:<\/p>\n\n\n
      an unusual encoding scheme\n<\/code><\/span><\/pre>\n\n\n
      rather than:<\/p>\n\n\n
      a practical compression algorithm\n<\/code><\/span><\/pre>\n\n\n
      \n\n\n\n
      43. Is \u03c0fs Deduplication?<\/h1>\n\n\n\n
      No.<\/p>\n\n\n\n
      Deduplication might transform:<\/p>\n\n\n
      Block A\nBlock B\nBlock A\nBlock A\n<\/code><\/span><\/pre>\n\n\n
      into:<\/p>\n\n\n
      Store:\nA\nB\n\nReferences:\nA B A A\n<\/code><\/span><\/pre>\n\n\n
      Repeated data avoids being stored multiple times.<\/p>\n\n\n\n
      \u03c0fs instead relies on a deterministic mathematical sequence that can regenerate values at specified positions.<\/p>\n\n\n\n
      The underlying ideas are different.<\/p>\n\n\n\n
      \n\n\n\n
      44. Is \u03c0fs Content-Addressed Storage?<\/h1>\n\n\n\n
      Not exactly.<\/p>\n\n\n\n
      Systems such as content-addressed object stores identify data using a cryptographic digest:<\/p>\n\n\n
      content -> hash\n<\/code><\/span><\/pre>\n\n\n
      and normally store the actual object somewhere.<\/p>\n\n\n\n
      \u03c0fs uses:<\/p>\n\n\n
      content byte -> \u03c0 offset\n<\/code><\/span><\/pre>\n\n\n
      and recalculates the byte from \u03c0.<\/p>\n\n\n\n
      There is no conventional backing object containing the original file data.<\/p>\n\n\n\n
      \n\n\n\n
      45. Is \u03c0fs Infinite Storage?<\/h1>\n\n\n\n
      No\u2014not in any practical engineering sense.<\/p>\n\n\n\n
      The phrase is the joke.<\/p>\n\n\n\n
      The digit expansion of \u03c0 is mathematically infinite, but \u03c0fs still needs:<\/p>\n\n\n\n
        \n
      • metadata storage,<\/li>\n\n\n\n
      • CPU,<\/li>\n\n\n\n
      • memory,<\/li>\n\n\n\n
      • FUSE infrastructure,<\/li>\n\n\n\n
      • filesystem structures,<\/li>\n\n\n\n
      • offsets,<\/li>\n\n\n\n
      • filenames,<\/li>\n\n\n\n
      • permissions,<\/li>\n\n\n\n
      • and an executable algorithm.<\/li>\n<\/ul>\n\n\n\n
        An infinite mathematical sequence is not equivalent to an infinite usable storage device.<\/p>\n\n\n\n
        \n\n\n\n
        46. Is \u03c0fs Lossless?<\/h1>\n\n\n\n
        Within the implementation’s supported operating range and assuming its metadata remains intact, the intent is deterministic byte reconstruction.<\/p>\n\n\n\n
        That makes its transformation effectively lossless for successfully encoded files.<\/p>\n\n\n\n
        But \u03c0fs is not designed with production-grade durability mechanisms such as:<\/p>\n\n\n
        checksums\nreplication\njournaling guarantees\nsnapshots\nself<\/span>-healing\ndistributed redundancy\nscrubbing\ntransactional metadata protection\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
        So \u201clossless mathematical transformation\u201d should not be confused with \u201creliable storage system.\u201d<\/p>\n\n\n\n
        \n\n\n\n
        47. Metadata Portability<\/h1>\n\n\n\n
        Another implementation detail is worth noticing.<\/p>\n\n\n\n
        \u03c0fs writes:<\/p>\n\n\n
        short\n<\/code><\/span><\/pre>\n\n\n
        values directly into backing files using the host’s native C representation.<\/p>\n\n\n\n
        There is no explicit:<\/p>\n\n\n
        portable serialization format\nnetwork byte order\nversioned metadata schema\n<\/code><\/span><\/pre>\n\n\n
        Therefore the backing representation should not be treated as a stable cross-platform storage format.<\/p>\n\n\n\n
        This is another indicator that \u03c0fs is a prototype.<\/p>\n\n\n\n
        \n\n\n\n
        48. Filesystem Semantics and Prototype Limitations<\/h1>\n\n\n\n
        The source implements many FUSE callbacks, but it should not be assumed to behave like a mature POSIX filesystem under every condition.<\/p>\n\n\n\n
        It was built as an experiment.<\/p>\n\n\n\n
        Examples of areas where production filesystems require far more engineering include:<\/p>\n\n\n
        concurrent access\ncrash consistency\natomic operations\nmetadata recovery\nlocking semantics\nrename behavior\nsecurity boundaries\nACLs\nlarge files\narchitecture portability\nfailure injection\ncorruption recovery\ndurability guarantees\n<\/code><\/span><\/pre>\n\n\n
        \u03c0fs should therefore be run on disposable test data.<\/p>\n\n\n\n
        \n\n\n\n
        49. Security<\/h1>\n\n\n\n
        Never interpret the word \u201cmetadata\u201d as meaning \u201cnon-sensitive.\u201d<\/p>\n\n\n\n
        \u03c0fs metadata is sufficient to reconstruct the logical file.<\/p>\n\n\n\n
        Therefore:<\/p>\n\n\n
        \u03c0fs metadata == sensitive file representation\n<\/code><\/span><\/pre>\n\n\n
        If someone obtains your metadata and the \u03c0fs algorithm, they can reconstruct the data.<\/p>\n\n\n\n
        \u03c0fs provides no inherent:<\/p>\n\n\n
        encryption\naccess-control architecture\nkey management\nconfidentiality mechanism\ntamper detection\n<\/code><\/span><\/pre>\n\n\n
        beyond whatever protection the underlying operating system provides.<\/p>\n\n\n\n
        Do not store confidential information in \u03c0fs experiments.<\/p>\n\n\n\n
        \n\n\n\n
        50. Backup and Disaster Recovery<\/h1>\n\n\n\n
        \u03c0fs must never be used as an excuse to avoid backup.<\/p>\n\n\n\n
        If you wanted to preserve a \u03c0fs experiment, the thing you would need to back up is:<\/p>\n\n\n
        metadata directory\n+\nsoftware\/version information\n<\/code><\/span><\/pre>\n\n\n
        But once you back up the metadata\u2014which is approximately larger than the original file\u2014you have neatly demonstrated the punchline again.<\/p>\n\n\n\n
        For real storage use technologies designed for backup.<\/p>\n\n\n\n
        \n\n\n\n
        51. Production Use<\/h1>\n\n\n\n
        Do not use \u03c0fs for:<\/p>\n\n\n\n
          \n
        • databases,<\/li>\n\n\n\n
        • Kubernetes PersistentVolumes,<\/li>\n\n\n\n
        • application state,<\/li>\n\n\n\n
        • VM disks,<\/li>\n\n\n\n
        • enterprise files,<\/li>\n\n\n\n
        • home directories,<\/li>\n\n\n\n
        • secrets,<\/li>\n\n\n\n
        • source-code repositories,<\/li>\n\n\n\n
        • backups,<\/li>\n\n\n\n
        • archives,<\/li>\n\n\n\n
        • object storage,<\/li>\n\n\n\n
        • data lakes,<\/li>\n\n\n\n
        • logs,<\/li>\n\n\n\n
        • legal records,<\/li>\n\n\n\n
        • production workloads.<\/li>\n<\/ul>\n\n\n\n
          The project is best understood as:<\/p>\n\n\n
          educational software\n+\ntechnical satire\n+\nfilesystem experiment\n+\ninformation-theory demonstration\n<\/code><\/span><\/pre>\n\n\n
          \n\n\n\n
          52. Excellent Use Cases for \u03c0fs<\/h1>\n\n\n\n
          Despite being unsuitable for production storage, \u03c0fs has some genuinely excellent uses.<\/p>\n\n\n\n
          52.1 Learning FUSE<\/h2>\n\n\n\n
          Study how applications communicate with a userspace filesystem.<\/p>\n\n\n\n
          52.2 Learning Filesystem APIs<\/h2>\n\n\n\n
          Observe operations such as:<\/p>\n\n\n
          getattr\nopen\nread\nwrite\nmkdir\nunlink\nreaddir\nfsync\nxattr\n<\/code><\/span><\/pre>\n\n\n
          52.3 Teaching Information Theory<\/h2>\n\n\n\n
          Demonstrate why arbitrary lossless 100% compression cannot exist.<\/p>\n\n\n\n
          52.4 Teaching Metadata Economics<\/h2>\n\n\n\n
          Show that representing data often moves information somewhere else rather than eliminating it.<\/p>\n\n\n\n
          52.5 Studying Mathematical Constants<\/h2>\n\n\n\n
          Explore digit extraction and BBP.<\/p>\n\n\n\n
          52.6 Teaching Encoding vs Compression<\/h2>\n\n\n\n
          \u03c0fs provides an unusually memorable example.<\/p>\n\n\n\n
          52.7 Computer Science Demonstrations<\/h2>\n\n\n\n
          A classroom can combine:<\/p>\n\n\n
          operating systems\nfilesystems\nmathematics\ncompression\nalgorithms\ndata structures\ninformation theory\n<\/code><\/span><\/pre>\n\n\n
          in one experiment.<\/p>\n\n\n\n
          52.8 Interview or Engineering Discussion<\/h2>\n\n\n\n
          Ask:<\/p>\n\n\n\n
          \n
          \u201cCould storing a file as an offset into \u03c0 provide unlimited compression?\u201d<\/p>\n<\/blockquote>\n\n\n\n
          The resulting discussion touches:<\/p>\n\n\n\n
            \n
          • entropy,<\/li>\n\n\n\n
          • address size,<\/li>\n\n\n\n
          • search complexity,<\/li>\n\n\n\n
          • deterministic sequences,<\/li>\n\n\n\n
          • algorithmic complexity,<\/li>\n\n\n\n
          • Kolmogorov complexity,<\/li>\n\n\n\n
          • FUSE,<\/li>\n\n\n\n
          • representation theory.<\/li>\n<\/ul>\n\n\n\n
            That is a surprisingly rich systems-design exercise.<\/p>\n\n\n\n
            \n\n\n\n
            53. Troubleshooting<\/h1>\n\n\n\n
            Error: FUSE development package missing<\/h2>\n\n\n\n
            Typical configure error:<\/p>\n\n\n
            Package requirements (fuse >= 2.8) were not met\n<\/code><\/span><\/pre>\n\n\n
            Check:<\/p>\n\n\n
            pkg-config --modversion fuse\n<\/code><\/span><\/pre>\n\n\n
            On Ubuntu 24.04:<\/p>\n\n\n
            sudo apt install libfuse-dev\n<\/code><\/span><\/pre>\n\n\n
            Do not substitute:<\/p>\n\n\n
            libfuse3-dev\n<\/code><\/span><\/pre>\n\n\n
            and assume it will compile unchanged.<\/p>\n\n\n\n
            \u03c0fs explicitly targets FUSE 2 APIs.<\/p>\n\n\n\n
            \n\n\n\n
            54. Metadata Directory Error<\/h1>\n\n\n\n
            If you see:<\/p>\n\n\n
            Metadata directory must be specified\n<\/code><\/span><\/pre>\n\n\n
            you forgot:<\/p>\n\n\n
            -o mdd=...\n<\/code><\/span><\/pre>\n\n\n
            Correct:<\/p>\n\n\n
            .\/src\/\u03c0fs \\\n    -o mdd=\"$HOME\/pifs-meta\"<\/span> \\\n    \"$HOME\/pifs-mount\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            The program explicitly checks for this option during startup.<\/p>\n\n\n\n
            \n\n\n\n
            55. Cannot Access Metadata Directory<\/h1>\n\n\n\n
            \u03c0fs checks the metadata directory for:<\/p>\n\n\n
            read\nwrite\nexecute\n<\/code><\/span><\/pre>\n\n\n
            access.<\/p>\n\n\n\n
            Check:<\/p>\n\n\n
            ls -ld ~\/pifs-meta\n<\/code><\/span><\/pre>\n\n\n
            Correct ownership if appropriate:<\/p>\n\n\n
            chown \"$USER\"<\/span>:\"$USER\"<\/span> ~\/pifs-meta\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
            Do not solve filesystem permission problems with:<\/p>\n\n\n
            chmod 777\n<\/code><\/span><\/pre>\n\n\n
            unless you specifically understand why it is necessary.<\/p>\n\n\n\n
            \n\n\n\n
            56. Mount Point Does Not Exist<\/h1>\n\n\n\n
            Create it:<\/p>\n\n\n
            mkdir -p ~\/pifs-mount\n<\/code><\/span><\/pre>\n\n\n
            Then mount again.<\/p>\n\n\n\n
            \n\n\n\n
            57. FUSE Device Missing<\/h1>\n\n\n\n
            Check:<\/p>\n\n\n
            ls -l \/dev\/fuse\n<\/code><\/span><\/pre>\n\n\n
            And:<\/p>\n\n\n
            lsmod | grep fuse\n<\/code><\/span><\/pre>\n\n\n
            If appropriate:<\/p>\n\n\n
            sudo modprobe fuse\n<\/code><\/span><\/pre>\n\n\n
            A restricted container or unusual virtualized environment may not expose \/dev\/fuse<\/code>.<\/p>\n\n\n\n
            \n\n\n\n
            58. Files Take Forever to Write<\/h1>\n\n\n\n
            That is expected.<\/p>\n\n\n\n
            Use tiny files:<\/p>\n\n\n
            printf A > ~\/pifs-mount\/<\/span>a\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            then:<\/p>\n\n\n
            printf Hello > ~\/pifs-mount\/<\/span>hello\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Do not start your experiment with:<\/p>\n\n\n
            cp ubuntu.iso ~\/pifs-mount\/<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            unless your objective is to develop a new appreciation for ordinary storage devices.<\/p>\n\n\n\n
            \n\n\n\n
            59. Debugging a Mount<\/h1>\n\n\n\n
            Run:<\/p>\n\n\n
            .\/src\/\u03c0fs \\\n    -d \\\n    -o mdd=\"$HOME\/pifs-meta\"<\/span> \\\n    \"$HOME\/pifs-mount\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Then from another terminal:<\/p>\n\n\n
            ls ~\/pifs-mount\n<\/code><\/span><\/pre>\n\n
            echo A > ~\/pifs-mount\/<\/span>a\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n
            cat ~\/pifs-mount\/<\/span>a\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            The FUSE request stream makes the internal behavior much easier to understand.<\/p>\n\n\n\n
            \n\n\n\n
            60. A Complete Learning Lab<\/h1>\n\n\n\n
            Here is a compact laboratory exercise.<\/p>\n\n\n\n
            Step 1 \u2014 Build<\/h3>\n\n\n
            git clone<\/span> https:\/\/github.com\/philipl\/pifs.git<\/span>\ncd pifs\n.\/autogen.sh\nmake\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
            Step 2 \u2014 Prepare directories<\/h3>\n\n\n
            mkdir -p ~\/pifs-meta\nmkdir -p ~\/pifs-mount\n<\/code><\/span><\/pre>\n\n\n
            Step 3 \u2014 Mount<\/h3>\n\n\n
            .\/src\/\u03c0fs \\\n    -f \\\n    -o mdd=\"$HOME\/pifs-meta\"<\/span> \\\n    \"$HOME\/pifs-mount\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Step 4 \u2014 In another terminal<\/h3>\n\n\n
            printf Hello > ~\/pifs-mount\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Step 5 \u2014 Verify<\/h3>\n\n\n
            cat ~\/pifs-mount\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Step 6 \u2014 Examine logical representation<\/h3>\n\n\n
            xxd ~\/pifs-mount\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Step 7 \u2014 Examine physical metadata<\/h3>\n\n\n
            xxd ~\/pifs-meta\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Step 8 \u2014 Compare sizes<\/h3>\n\n\n
            wc -c ~\/pifs-mount\/<\/span>hello.txt\nwc -c ~\/pifs-meta\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Step 9 \u2014 Create repeated data<\/h3>\n\n\n
            printf AAAAAA > ~\/pifs-mount\/<\/span>repeated.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Inspect:<\/p>\n\n\n
            xxd ~\/pifs-meta\/<\/span>repeated.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Step 10 \u2014 Unmount<\/h3>\n\n\n
            fusermount -u ~\/pifs-mount\n<\/code><\/span><\/pre>\n\n\n
            This ten-step experiment demonstrates most of \u03c0fs’s central ideas.<\/p>\n\n\n\n
            \n\n\n\n
            61. \u03c0fs vs Traditional Filesystems<\/h1>\n\n\n\n
            Property<\/th>ext4\/XFS<\/th>\u03c0fs<\/th><\/tr><\/thead>
            Stores file data<\/td>Yes<\/td>Stores indexes representing bytes<\/td><\/tr>
            Production ready<\/td>Yes<\/td>No<\/td><\/tr>
            Fast<\/td>Yes<\/td>No<\/td><\/tr>
            Kernel integration<\/td>Native filesystem<\/td>FUSE<\/td><\/tr>
            Metadata required<\/td>Yes<\/td>Yes<\/td><\/tr>
            Compression<\/td>Optional<\/td>Not practical compression<\/td><\/tr>
            Reliability mechanisms<\/td>Mature<\/td>Experimental<\/td><\/tr>
            Large files<\/td>Normal<\/td>Impractical<\/td><\/tr>
            Educational value<\/td>Moderate<\/td>Extremely high<\/td><\/tr>
            Entertainment value<\/td>Respectable<\/td>Exceptional<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
            \n\n\n\n
            62. \u03c0fs vs Compression<\/h1>\n\n\n\n
            Property<\/th>gzip\/zstd<\/th>\u03c0fs<\/th><\/tr><\/thead>
            Exploits redundancy<\/td>Yes<\/td>No<\/td><\/tr>
            Practical storage reduction<\/td>Often<\/td>No<\/td><\/tr>
            Fast decompression<\/td>Yes<\/td>Comparatively expensive<\/td><\/tr>
            Production use<\/td>Yes<\/td>No<\/td><\/tr>
            Representation<\/td>Compressed stream<\/td>\u03c0 offsets<\/td><\/tr>
            Random input compression<\/td>Usually poor<\/td>Also poor\/worse<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
            \n\n\n\n
            63. \u03c0fs vs Deduplication<\/h1>\n\n\n\n
            Property<\/th>Deduplication<\/th>\u03c0fs<\/th><\/tr><\/thead>
            Stores unique blocks<\/td>Yes<\/td>No<\/td><\/tr>
            References existing blocks<\/td>Yes<\/td>References \u03c0 positions<\/td><\/tr>
            Practical<\/td>Yes<\/td>No<\/td><\/tr>
            Works well on repeated content<\/td>Often<\/td>No storage advantage<\/td><\/tr>
            Requires metadata<\/td>Yes<\/td>Yes<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
            \n\n\n\n
            64. \u03c0fs vs Content-Addressed Storage<\/h1>\n\n\n\n
            Property<\/th>CAS<\/th>\u03c0fs<\/th><\/tr><\/thead>
            Identifier<\/td>Usually hash<\/td>\u03c0 position<\/td><\/tr>
            Actual data stored<\/td>Yes<\/td>Recomputed from \u03c0<\/td><\/tr>
            Integrity checking<\/td>Usually strong<\/td>Not fundamental<\/td><\/tr>
            Distributed usage<\/td>Common<\/td>No<\/td><\/tr>
            Production systems<\/td>Many<\/td>Experimental<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
            \n\n\n\n
            65. \u03c0fs vs \/dev\/zero<\/code><\/h1>\n\n\n\n
            There is a funny conceptual comparison.<\/p>\n\n\n\n
            \/dev\/zero<\/code> generates:<\/p>\n\n\n
            00 00 00 00 ...\n<\/code><\/span><\/pre>\n\n\n
            without storing those zero bytes anywhere.<\/p>\n\n\n\n
            \u03c0fs similarly generates values computationally rather than storing their literal values.<\/p>\n\n\n\n
            The difference is that \/dev\/zero<\/code> generates exactly one predictable sequence.<\/p>\n\n\n\n
            \u03c0fs attempts to use a deterministic sequence rich enough to contain arbitrary byte values and saves the instructions needed to select those values.<\/p>\n\n\n\n
            Again:<\/p>\n\n\n\n
            \n
            The information lives in the selection instructions.<\/p>\n<\/blockquote>\n\n\n\n
            \n\n\n\n
            66. The Information-Theory Lesson<\/h1>\n\n\n\n
            The deepest \u03c0fs lesson can be written in one sentence:<\/p>\n\n\n\n
            \n
            You cannot eliminate information merely by replacing the information with an equally informative address.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
            Consider a hypothetical library containing every possible book.<\/p>\n\n\n\n
            You no longer need to store your book.<\/p>\n\n\n\n
            Wonderful.<\/p>\n\n\n\n
            But now you must store:<\/p>\n\n\n
            building\nfloor\nroom\nshelf\nbook\npage\noffset\nlength\n<\/code><\/span><\/pre>\n\n\n
            If the library contains an astronomically large number of books, the address may itself become enormous.<\/p>\n\n\n\n
            \u03c0fs is the digital version of that paradox.<\/p>\n\n\n\n
            \n\n\n\n
            67. Kolmogorov Complexity<\/h1>\n\n\n\n
            \u03c0fs also connects naturally to Kolmogorov complexity<\/strong>.<\/p>\n\n\n\n
            Informally, the Kolmogorov complexity of a string is the size of the shortest program capable of producing it.<\/p>\n\n\n\n
            For something highly structured:<\/p>\n\n\n
            AAAAAAAAAAAAAAAAAAAAAAAAAAAA\n<\/code><\/span><\/pre>\n\n\n
            a short description exists:<\/p>\n\n\n
            print<\/span> A 28<\/span> times\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
            For sufficiently random data, the shortest description may be roughly the data itself.<\/p>\n\n\n\n
            \u03c0fs tries to describe information using:<\/p>\n\n\n
            \u03c0 algorithm + offsets\n<\/code><\/span><\/pre>\n\n\n
            but the offsets themselves carry the entropy necessary to identify arbitrary content.<\/p>\n\n\n\n
            That is why \u03c0 does not provide a universal escape hatch from compression limits.<\/p>\n\n\n\n
            \n\n\n\n
            68. What Could Be Improved Technically?<\/h1>\n\n\n\n
            If someone wanted to modernize \u03c0fs as an educational project, several improvements would be interesting.<\/p>\n\n\n\n
            FUSE 3 Port<\/h2>\n\n\n\n
            Modernize the callbacks and build system for current libfuse.<\/p>\n\n\n\n
            Byte Lookup Cache<\/h2>\n\n\n\n
            Precompute the earliest location of every possible byte.<\/p>\n\n\n
            256 entries\n<\/code><\/span><\/pre>\n\n\n
            would eliminate repeated write searches.<\/p>\n\n\n\n
            Portable Metadata Format<\/h2>\n\n\n\n
            Replace raw native short<\/code> storage with explicitly serialized integers.<\/p>\n\n\n\n
            Checksums<\/h2>\n\n\n\n
            Add integrity verification.<\/p>\n\n\n\n
            Versioned Metadata<\/h2>\n\n\n\n
            Introduce a header:<\/p>\n\n\n
            magic\nversion\nalgorithm\nendianness\nrecord size\nchecksum\n<\/code><\/span><\/pre>\n\n\n
            Tests<\/h2>\n\n\n\n
            Build unit tests around:<\/p>\n\n\n
            get_byte()\nread\/write round trip\ndirectories\ntruncate\nrename\nxattrs\nconcurrent operations\n<\/code><\/span><\/pre>\n\n\n
            Benchmarking<\/h2>\n\n\n\n
            Measure:<\/p>\n\n\n
            write latency\nread latency\nCPU usage\nmetadata expansion ratio\noperations\/sec\n<\/code><\/span><\/pre>\n\n\n
            The result still would not become a competitive filesystem\u2014but it could become an even better systems-programming laboratory.<\/p>\n\n\n\n
            \n\n\n\n
            69. A More Efficient Educational Design<\/h1>\n\n\n\n
            Because every possible byte has only 256 values, an optimized version could build:<\/p>\n\n\n
            uint16_t<\/span> byte_to_pi<\/span>[256]<\/span>;\n<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
            At startup:<\/p>\n\n\n
            scan \u03c0\nuntil all 256 byte values have been observed\n<\/code><\/span><\/pre>\n\n\n
            Then writing becomes:<\/p>\n\n\n
            byte\n \u2193\nlookup\n \u2193\nuint16 offset\n<\/code><\/span><\/pre>\n\n\n
            Reading remains:<\/p>\n\n\n
            offset\n \u2193\nBBP\n \u2193\nbyte\n<\/code><\/span><\/pre>\n\n\n
            This would be dramatically faster while retaining the educational idea.<\/p>\n\n\n\n
            And it would make the storage paradox even easier to measure:<\/p>\n\n\n
            8-bit byte\n   \u2193\n16-bit index\n<\/code><\/span><\/pre>\n\n\n
            Perfectly illustrating negative compression.<\/p>\n\n\n\n
            \n\n\n\n
            70. Why \u03c0fs Matters Even Though It Is Not Practical<\/h1>\n\n\n\n
            \u03c0fs is valuable because it compresses several important ideas\u2014not files\u2014into one memorable experiment:<\/p>\n\n\n\n
            Filesystems are abstractions.<\/h3>\n\n\n\n
            What applications see as a file does not necessarily correspond directly to physical disk blocks.<\/p>\n\n\n\n
            Data can be generated instead of stored.<\/h3>\n\n\n\n
            Virtual filesystems frequently compute their contents dynamically.<\/p>\n\n\n\n
            Metadata can become more expensive than payload.<\/h3>\n\n\n\n
            A recurring problem in real distributed systems.<\/p>\n\n\n\n
            Deterministic generation is not automatically compression.<\/h3>\n\n\n\n
            The parameters required to regenerate arbitrary information still carry information.<\/p>\n\n\n\n
            Infinite mathematical structures do not imply infinite practical resources.<\/h3>\n\n\n\n
            Computation, addressing and representation all have costs.<\/p>\n\n\n\n
            \u201cWhere is the data?\u201d is sometimes the wrong question.<\/h3>\n\n\n\n
            Often the real question is:<\/p>\n\n\n\n
            \n
            \u201cWhat information must I retain to reconstruct the data?\u201d<\/p>\n<\/blockquote>\n\n\n\n
            \n\n\n\n
            71. Current Project Status in 2026<\/h1>\n\n\n\n
            The original \u03c0fs repository remains publicly available under the GPL-3.0 family of licensing and still contains the original C\/FUSE implementation. Its README now prominently directs readers toward InferenceFS<\/strong> for the \u201clatest in data-free filesystems.\u201d<\/p>\n\n\n\n
            \u03c0fs itself remains fundamentally the original experimental concept.<\/p>\n\n\n\n
            Do not interpret renewed online interest or repository popularity as evidence of production maturity.<\/p>\n\n\n\n
            Its value lies primarily in:<\/p>\n\n\n
            education\nexperimentation\nhumor\ncomputer science\nfilesystem engineering\ninformation theory\n<\/code><\/span><\/pre>\n\n\n
            \n\n\n\n
            72. What Is InferenceFS?<\/h1>\n\n\n\n
            The same author has created a modern successor called:<\/p>\n\n\n
            InferenceFS\n<\/code><\/span><\/pre>\n\n\n
            The joke has evolved.<\/p>\n\n\n\n
            \u03c0fs says:<\/p>\n\n\n
            Your file already exists inside \u03c0.\nI only need to remember where.\n<\/code><\/span><\/pre>\n\n\n
            InferenceFS says, roughly:<\/p>\n\n\n
            Why even remember where?\nGive an LLM the filename and ask it what the file probably contained.\n<\/code><\/span><\/pre>\n\n\n
            The successor uses language-model backends and describes itself as storing essentially filenames while generating plausible contents when files are accessed.<\/p>\n\n\n\n
            The comparison is delightfully revealing:<\/p>\n\n\n\n
            Concept<\/th>\u03c0fs<\/th>InferenceFS<\/th><\/tr><\/thead>
            \u201cData source\u201d<\/td>\u03c0<\/td>LLM<\/td><\/tr>
            Persistent information<\/td>\u03c0 indexes<\/td>Primarily filenames\/metadata<\/td><\/tr>
            Reconstruction<\/td>Deterministic mathematics<\/td>Model inference<\/td><\/tr>
            Exact original content<\/td>Intended<\/td>Not generally<\/td><\/tr>
            Core joke<\/td>Infinite mathematical storage<\/td>AI as lossy memory<\/td><\/tr>
            Real lesson<\/td>Information theory<\/td>Generative models and lossy representation<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
            InferenceFS should be studied separately because its semantics are fundamentally different from lossless storage.<\/p>\n\n\n\n
            \n\n\n\n
            73. Recommended Learning Path<\/h1>\n\n\n\n
            For engineers wanting to study \u03c0fs properly:<\/p>\n\n\n\n
            Level 1 \u2014 Concept<\/h3>\n\n\n\n
            Understand:<\/p>\n\n\n
            \u03c0\nnormal numbers\nhexadecimal\nbytes\nFUSE\n<\/code><\/span><\/pre>\n\n\n
            Level 2 \u2014 Run It<\/h3>\n\n\n\n
            Build and mount \u03c0fs.<\/p>\n\n\n\n
            Level 3 \u2014 Observe It<\/h3>\n\n\n\n
            Use:<\/p>\n\n\n
            -d\nxxd\nstrace\nfindmnt\n<\/code><\/span><\/pre>\n\n\n
            to observe filesystem behavior.<\/p>\n\n\n\n
            Level 4 \u2014 Read the Source<\/h3>\n\n\n\n
            Start with:<\/p>\n\n\n
            pifs_write()\npifs_read()\nget_byte()\n<\/code><\/span><\/pre>\n\n\n
            Level 5 \u2014 Understand BBP<\/h3>\n\n\n\n
            Study arbitrary-position hexadecimal digit calculation.<\/p>\n\n\n\n
            Level 6 \u2014 Information Theory<\/h3>\n\n\n\n
            Study:<\/p>\n\n\n
            entropy\npigeonhole principle\nlossless compression limits\nKolmogorov complexity\n<\/code><\/span><\/pre>\n\n\n
            Level 7 \u2014 Modify \u03c0fs<\/h3>\n\n\n\n
            Implement:<\/p>\n\n\n
            256-byte lookup cache\nportable metadata\nmetrics\ntests\nFUSE 3 port\n<\/code><\/span><\/pre>\n\n\n
            At that point \u03c0fs turns from a joke into a very effective systems-programming exercise.<\/p>\n\n\n\n
            \n\n\n\n
            74. Useful Commands Cheat Sheet<\/h1>\n\n\n\n
            Build:<\/p>\n\n\n
            git clone<\/span> https:\/\/github.com\/philipl\/pifs.git<\/span>\ncd pifs\n.\/autogen.sh\nmake\n<\/code><\/span>Code language:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
            Prepare:<\/p>\n\n\n
            mkdir -p ~\/pifs-meta ~\/<\/span>pifs-mount\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Mount:<\/p>\n\n\n
            .\/src\/\u03c0fs \\\n    -o mdd=\"$HOME\/pifs-meta\"<\/span> \\\n    \"$HOME\/pifs-mount\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Foreground:<\/p>\n\n\n
            .\/src\/\u03c0fs \\\n    -f \\\n    -o mdd=\"$HOME\/pifs-meta\"<\/span> \\\n    \"$HOME\/pifs-mount\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Debug:<\/p>\n\n\n
            .\/src\/\u03c0fs \\\n    -d \\\n    -o mdd=\"$HOME\/pifs-meta\"<\/span> \\\n    \"$HOME\/pifs-mount\"<\/span>\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Create:<\/p>\n\n\n
            printf Hello > ~\/pifs-mount\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Read:<\/p>\n\n\n
            cat ~\/pifs-mount\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Inspect metadata:<\/p>\n\n\n
            xxd ~\/pifs-meta\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Compare:<\/p>\n\n\n
            wc -c ~\/pifs-mount\/<\/span>hello.txt\nwc -c ~\/pifs-meta\/<\/span>hello.txt\n<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Unmount:<\/p>\n\n\n
            fusermount -u ~\/pifs-mount\n<\/code><\/span><\/pre>\n\n\n
            \n\n\n\n
            75. Frequently Asked Questions<\/h1>\n\n\n\n
            Does \u03c0 contain every file ever created?<\/h2>\n\n\n\n
            That has not been mathematically proven.<\/p>\n\n\n\n
            The idea depends on \u03c0 possessing sufficiently strong digit-distribution properties, commonly discussed in terms of normality.<\/p>\n\n\n\n
            \n\n\n\n
            Does \u03c0fs really work?<\/h2>\n\n\n\n
            Yes, as an experimental FUSE implementation.<\/p>\n\n\n\n
            It maps bytes to positions generated from \u03c0 and reconstructs them during reads.<\/p>\n\n\n\n
            \n\n\n\n
            Does \u03c0fs provide infinite free storage?<\/h2>\n\n\n\n
            No.<\/p>\n\n\n\n
            It consumes metadata storage and significant computation.<\/p>\n\n\n\n
            \n\n\n\n
            Does \u03c0fs actually compress files?<\/h2>\n\n\n\n
            Not practically.<\/p>\n\n\n\n
            The original implementation typically stores a two-byte position for every one-byte input value.<\/p>\n\n\n\n
            \n\n\n\n
            Does \u03c0fs store the original byte?<\/h2>\n\n\n\n
            Not directly in its metadata representation.<\/p>\n\n\n\n
            It stores a position used to regenerate that byte from \u03c0.<\/p>\n\n\n\n
            \n\n\n\n
            What happens if metadata is lost?<\/h2>\n\n\n\n
            The logical file is effectively lost because its selected \u03c0 locations are no longer known.<\/p>\n\n\n\n
            \n\n\n\n
            Is BBP a search algorithm?<\/h2>\n\n\n\n
            No.<\/p>\n\n\n\n
            BBP allows digits near a specified position to be calculated efficiently relative to generating every preceding digit.<\/p>\n\n\n\n
            Finding where arbitrary content occurs remains a separate problem.<\/p>\n\n\n\n
            \n\n\n\n
            Is \u03c0fs production ready?<\/h2>\n\n\n\n
            No.<\/p>\n\n\n\n
            It is an experimental and educational project.<\/p>\n\n\n\n
            \n\n\n\n
            Can I store terabytes in \u03c0fs?<\/h2>\n\n\n\n
            In theory you can ask many strange things of computers.<\/p>\n\n\n\n
            In practice, do not do this.<\/p>\n\n\n\n
            \n\n\n\n
            Can I use \u03c0fs for backups?<\/h2>\n\n\n\n
            Absolutely not.<\/p>\n\n\n\n
            The metadata is effectively an encoding of your data and itself must be protected.<\/p>\n\n\n\n
            \n\n\n\n
            Why use \u03c0fs at all?<\/h2>\n\n\n\n
            Because few projects teach so many concepts simultaneously while being this entertaining.<\/p>\n\n\n\n
            \n\n\n\n
            76. Final Takeaway<\/h1>\n\n\n\n
            \u03c0fs begins with an irresistible proposition:<\/p>\n\n\n\n
            \n
            If every finite sequence exists somewhere inside \u03c0, why store data at all?<\/p>\n<\/blockquote>\n\n\n\n
            Then reality arrives.<\/p>\n\n\n\n
            You need to discover where the data occurs.<\/p>\n\n\n\n
            You need to remember those locations.<\/p>\n\n\n\n
            Those locations themselves contain information.<\/p>\n\n\n\n
            Searching costs computation.<\/p>\n\n\n\n
            The metadata consumes storage.<\/p>\n\n\n\n
            And in the original implementation, representing one byte typically requires about two bytes of stored position information.<\/p>\n\n\n\n
            The supposedly \u201cdata-free\u201d filesystem therefore teaches something much more valuable than a storage trick:<\/p>\n\n\n\n
            \n
            Information cannot be wished away.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
            You may compress it.<\/p>\n\n\n\n
            You may encode it.<\/p>\n\n\n\n
            You may reference it.<\/p>\n\n\n\n
            You may derive it.<\/p>\n\n\n\n
            You may regenerate it.<\/p>\n\n\n\n
            You may move it from payload into metadata.<\/p>\n\n\n\n
            But for arbitrary lossless information, somewhere in the system enough information must still exist to distinguish the original data from every other possible data set.<\/p>\n\n\n\n
            That makes \u03c0fs more than an April-Fools-style filesystem.<\/p>\n\n\n\n
            It is a compact laboratory for understanding:<\/p>\n\n\n\n
              \n
            • filesystems,<\/li>\n\n\n\n
            • FUSE,<\/li>\n\n\n\n
            • hexadecimal representation,<\/li>\n\n\n\n
            • mathematical constants,<\/li>\n\n\n\n
            • random access algorithms,<\/li>\n\n\n\n
            • metadata,<\/li>\n\n\n\n
            • compression,<\/li>\n\n\n\n
            • entropy,<\/li>\n\n\n\n
            • information theory,<\/li>\n\n\n\n
            • and the difference between a clever representation and genuinely reduced information.<\/li>\n<\/ul>\n\n\n\n
              And that is why, more than a decade after it appeared, \u03c0fs remains one of the most memorable filesystem experiments you can compile.<\/p>\n\n\n\n
              References and Further Study<\/h2>\n\n\n\n
              The authoritative starting point is the original philipl\/pifs<\/strong> repository and its source implementation.<\/p>\n\n\n\n
              For understanding the userspace filesystem architecture underlying \u03c0fs, refer to the current libfuse<\/strong> project and API documentation.<\/p>\n\n\n\n
              For modern Linux packaging, Ubuntu continues to publish the FUSE 2 development libraries while modern libfuse itself is firmly in the FUSE 3 generation.<\/p>\n\n\n\n
              For the project’s modern spiritual successor, see InferenceFS<\/strong>, which takes the \u201cdata-free filesystem\u201d joke into the LLM era.<\/p>\n","protected":false},"excerpt":{"rendered":"
              What Is \u03c0fs, Why Does It Exist, How Does It Work, and What Can It Teach Us? Updated: September 2026 \u03c0fs\u2014pronounced \u201cPi FS\u201d and commonly represented by… <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_joinchat":[],"footnotes":""},"categories":[11138],"tags":[],"class_list":["post-78587","post","type-post","status-publish","format-standard","hentry","category-best-tools"],"_links":{"self":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/78587","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/comments?post=78587"}],"version-history":[{"count":1,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/78587\/revisions"}],"predecessor-version":[{"id":78588,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/posts\/78587\/revisions\/78588"}],"wp:attachment":[{"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/media?parent=78587"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/categories?post=78587"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devopsschool.com\/blog\/wp-json\/wp\/v2\/tags?post=78587"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}