← Back to stories
Company Logo

Silicon Graphics

// Created: 2014

SGI CXFS Resurrection: The Unicode Truth Engine

SGI / Cray Division – 2014

(Acquired by HPE) Role: Consulting Principal Engineer

  • Rewrote Clustered-XFS filesystem for macOS and Windows NT clients to overcome 10 years of deferred maintenance
  • Added complete support for 64-bit builds and runtime environments
  • Built out test infrastructure and resolved high profile reported bugs, including longstanding cluster-scope race conditions
  • Delivered modern kernel binary interface (KBI) support across NT, Vista, and macOS platforms
  • Was offered a paid long-term maintainer role for Clustered-XFS macOS and Windows clients

Intro: After the Oscars

SGI didn’t bring me in to innovate. They brought me in because NetApp was eating their lunch.

After Rackable acquired SGI in 2009, the soul drained out of the engineering org. The company that once won Academy Awards for technical achievement, powered render farms across Hollywood, and was synonymous with high-performance parallelism — that company no longer existed in anything but logo and liability.

By 2014, the Clustered-XFS client codebase for Windows and macOS had been abandoned, unmaintained, and completely unbuildable on any modern system. Their most visible media & entertainment clients were walking. NetApp was offering cross-platform NFS with Windows compatibility and actual file fidelity.

SGI's remaining sales reps — particularly in M&E — were losing accounts because files created on one client wouldn't even show up on another. They brought me in as a consulting principal engineer. Term contract. Specific deliverables.

The ask was simple:

Get the CXFS clients working again. macOS and Windows. Doesn't matter how.

What they didn’t know is that I wouldn’t just make it work — I’d make it tell the truth.

Phase 1: The Resurrection (First 3 Months)

The code hadn’t been touched in years.

  • It didn’t compile.
  • It had kernel hooks that no longer existed.
  • Interface headers were misaligned.
  • Preprocessor spaghetti made each attempt to update a risk to the entire tree.

I rebuilt the 32-bit macOS and Windows CXFS clients from the dank crypt of source control rot. This wasn’t debugging — this was necromancy.

I stood the entire client infrastructure up.

  • Rewrote kernel entry points for modern OS loads
  • Reverse-engineered broken assumptions about shared memory and IPC
  • Updated driver build systems to survive modern compilers

By the end of Month 3: QA had working binaries on both platforms.

Phase 2: The 64-bit Transition (Next 3 Months)

What came next was harder.

CXFS on macOS and Windows was never built for a 64-bit world. And this wasn’t just ABI. This was KBI — kernel binary interface — on multiple operating systems.

On macOS, I dealt with:

  • New module loading protocols
  • ISA-specific alignment bugs
  • Changed expectations around reference counting and locking primitives

On Windows NT and Vista, I:

  • Retrofitted modern I/O stack behaviors into legacy CXFS interfaces
  • Matched symbol resolution across the new kernel trust boundaries
  • Adapted code to Windows Driver Model updates that broke implicit assumptions about memory safety and IRPs

I delivered clean, working 64-bit builds for both macOS and Windows within six months.

Contract met. Expectations exceeded.

I could’ve walked away. But something still smelled wrong.

Phase 3: Canonical Ghosts

I started asking around:

What’s still broken?

The answer kept coming back the same: “Some files just don’t show up.”

Digging deeper, I discovered the true failure: Unicode canonical equivalence.

  • Windows clients used UTF-16 with no normalization.
  • macOS enforced UTF-8 with NFD.
  • Linux did nothing — raw bytes in, raw bytes out.
  • CXFS? It accepted whatever it was handed, no questions asked.

That meant filenames could look the same and act completely differently.

  • Files vanished from view depending on the client.
  • Directories appeared inconsistent.
  • Ghosts haunted the filesystem.

This wasn’t corruption. It was something worse: semantic divergence.

I decided to fix it.

Not just patch it — rebuild it from first principles.

Phase 4: The Unicode Truth Engine

I built a system that enforced Unicode truth, across all clients, all time.

Here’s how it worked:

Step 1: Preserve the syscall

  • Whatever the client passed in — slashes, bytes, edge-case characters — I captured it exactly.

Step 2: Convert to UTF-16 immediately

  • UTF-16 was ISA-endian-aware and consistent for internal use.
  • Conversion was mandatory and deterministic.

Step 3: PUA tagging before normalization

  • I used Private Use Area (PUA) codepoints to tag canonical and compatibility variants.
  • This was before applying NFD or NFKD transforms.

Step 4: Escape pre-existing PUA

  • If the syscall input already contained PUA characters (yes, some clients sent them), I mapped them into a reserved PUA band under my control.

Step 5: Normalize to UTF16_NFD_PUA

  • All internal representations used this type.
  • It was endian-specific, normalized, and tagged for reversibility.
  • It added and maintained the unicode byte-order-mark (BOM) which Windows never had.

Step 6: Compile-time enforcement

  • Every encoding stage had a unique C type:

    • UTF8_RAW
    • UTF16_MIXED
    • UTF16_NFD_PUA
    • UTF8_NFD_PUA
    • UTF16_NFKD (comparison only)

  • The compiler prevented incorrect comparisons or implicit conversions.

  • There was no way to mix types without an explicit transform.

Step 7: On-disk as UTF8_NFD_PUA

  • All names stored in UTF-8, NFD-normalized, with PUA markers preserved.
  • Fully reversible.

Step 8: Sort/compare via locale-aware NFKD

  • Before sorting or matching, PUA was stripped.
  • Normalized to NFKD.
  • Passed through locale collation rules.

Step 9: Round-trip safety

  • Every syscall could be reconstructed byte-for-byte.
  • No lossy transforms.
  • No silent collapses.

This was more than correctness.

Not just working code — truthful code.

And yes, even PUA inside PUA was round-trippable.

Phase 5: Locking the World

Cross-platform file locking didn’t just differ — it conflicted.

  • Windows and macOS clients locked from 0 to omega. Always.
  • Linux clients used byte-range locks. Correct, cooperative, cluster-aware.

I implemented a translation shim that honored intent:

  • Treated full-file locks as byte-range spanning the entire inode.
  • Mapped ranges cleanly across clients.
  • Prevented false negatives and spurious collisions.

Locking now worked. Everywhere.

The Quiet Mic Drop

Here’s what nobody at SGI ever knew:

They thought I was working 40+ hours a week. They were exceptionally happy with my productivity.

In reality, I was working 10 hours a week, from beach cafés, on a results-only contract.

  • Every milestone hit.
  • Every regression closed.
  • Every test passed.

Not because I sprinted. But because I never wasted motion.

What Happened Next

  • 🔧 SGI asked me to stay on as long-term maintainer for CXFS clients
  • ❌ I declined — the system was clean, testable, and correct. My job was done
  • 🧊 SGI was acquired by HPE
  • 👤 A single engineer — someone I had worked alongside — was left to keep CXFS breathing
  • 🛰️ That code still runs — in military systems, post houses, maybe even in orbit
  • 🧟‍♂️ But CXFS was never open-sourced
  • ⏳ Ten years later, it's still a ghost — still running, still relevant, still closed

Final Thoughts

I didn’t just get it working, because this wasn’t a salvage job. This was a resurrection. I rebuilt a broken system, stitched its encoding back together, and gave it something it never had:

I gave it back its semantic integrity. Not just working code—truthful code.

I built a layer that told the truth.

Legacy isn’t rot. Legacy is leverage — if you know where to cut.

👟 And yes, I wore toe shoes.