.
For creative teams, shared storage has always been a compromise. Local NAS appliances deliver performance but make remote collaboration difficult. Cloud object storage scales almost infinitely but often feels slow and awkward when working with large media files. Streaming solutions have proven that editors don't need to download an entire file before getting to work—but many of those platforms come with recurring subscription costs, proprietary infrastructure, and vendor lock-in.
What if the streaming experience wasn't tied to a specific cloud service?
What if your existing storage—whether that's an AWS S3 bucket, a TrueNAS server, a Ceph cluster, or a MinIO deployment—could provide the same instant-access workflow while remaining entirely under your control?
That's the problem HuskHoard was built to solve.
Streaming Without the Lock-In
Modern video production increasingly depends on object storage. It's reliable, inexpensive, and scales far beyond traditional filesystems. Unfortunately, most operating systems weren't designed to edit directly from object storage.
Traditional FUSE-based filesystems such as s3fs or generic cloud mounts translate object storage into a POSIX filesystem, but they struggle with the random-access workloads common in post-production. Video editing software constantly jumps between different parts of a file as editors scrub timelines, preview clips, or render effects. Those small, unpredictable reads generate an enormous number of requests that traditional FUSE implementations handle inefficiently.
Many solutions attempt to force cloud storage to behave like a local block device, which inevitably leads to latency and caching bottlenecks.
HuskHoard takes a fundamentally different approach, operating as a true Hierarchical Storage Management (HSM) engine combined with an intelligent sidecar for media workflows.
Storage Becomes an Implementation Detail
One of HuskHoard's core design principles is that storage should be interchangeable.
Rather than being tightly coupled to a single cloud provider or appliance, HuskHoard treats object storage as a generic backend. The software doesn't particularly care whether your objects live in an AWS S3 bucket, an on-premises MinIO cluster, a TrueNAS deployment exposing S3-compatible storage, or a distributed Ceph object store.
From the user's perspective, the workflow remains identical.
That flexibility allows organizations to build storage infrastructure around their own requirements instead of adapting their workflows to a vendor's ecosystem. Need low-latency editing inside the office? Point HuskHoard at your local object storage. Want globally distributed collaboration? Connect the same workflow to cloud storage.
The software stays the same. Only the storage endpoint changes.
Instant Browsing Without Waiting
Large media repositories often contain millions of files.
Simply listing directories can become painfully slow when every metadata lookup requires a network request. This is especially noticeable with traditional cloud mounts, where browsing folders sometimes feels slower than actually downloading files.
HuskHoard avoids this bottleneck through a local SQLite catalog.
Instead of querying remote storage every time the operating system requests directory contents, HuskHoard maintains an indexed catalog locally. Directory listings become effectively instantaneous because they're serviced from the local database rather than remote object storage.
For editors, this means browsing enormous media libraries feels just like navigating a local filesystem. Folder trees expand immediately. Search operations remain responsive. Media organization doesn't incur network latency.
The catalog provides the filesystem metadata, while the actual media remains safely stored in object storage until it's genuinely needed.
Streaming the Bytes That Matter
Proxies for Speed, Stubs for Storage
The real innovation appears in how HuskHoard bridges the gap between active editing and cold storage.
Instead of trying to force high-latency object storage to serve random-access NLE reads, HuskHoard utilizes a dedicated media sidecar. When high-res assets are tiered off your expensive NVMe drives to cloud or tape, the sidecar intercepts the PRE_ARCHIVE event and automatically spawns ffmpeg to generate a lightweight, 720p H.264 proxy file.
The massive original files are replaced on your local disk by transparent, zero-byte "stubs."
For the editor, the workflow is seamless. They scrub their timelines using the lightweight proxies, experiencing zero network latency. When it is time to color grade or render the final conform, the NLE reconnects to the high-res file paths.
This is where HuskHoard's kernel-level integration shines. Using Linux's fanotify subsystem, HuskHoard intercepts the POSIX read request to the stubbed file, temporarily blocks the application, and instantly issues a WAKE_VOLUME command. The high-res data is automatically recalled from the cloud bucket or LTO tape, rehydrated back to the primary disk, and the render continues seamlessly.
For VFX pipelines and final conforms, recalling entire large master files is often a waste of time and space. To solve this, the sidecar features an API-driven PRE_RESTORE hook. Pipeline engineers can pass a specific timecode request to the sidecar, which dynamically provisions a Linux named pipe (mkfifo). As HuskHoard streams the raw data out of the cold archive, an automated ffmpeg process transcodes and extracts only the requested subclip on the fly—saving hours of transfer time during final conform.
The Grid Mesh: Distributed Workflows Without SMB Lag
The implications are significant for distributed teams. Traditionally, giving remote editors access to a central archive meant forcing them over an SMB share via a VPN—a notoriously laggy experience where simply opening a large directory can take minutes.
HuskHoard bypasses this entirely using its Zero Trust Grid Mesh.
Instead of mapping network drives, remote locations run their own lightweight HuskHoard nodes. When a file is archived on the primary on-premises TrueNAS server, the sidecar broadcasts a mesh update. The remote nodes instantly materialize a 0-byte "Ghost Stub" on their local storage arrays.
Remote editors browse their local filesystem at native NVMe speeds. When they access a proxy or trigger a high-res recall, the local HuskHoard node handles the secure mTLS tunnel, requesting a remote read from the master archive—whether that master sits in an S3 bucket or an on-premises LTO tape library.
Applications don't need to be reconfigured for remote workflows, and users never have to suffer through WAN-latency directory listings. The infrastructure simply synchronizes the stubs, while the payloads remain safely vaulted until needed.
Data Sovereignty Matters
For many organizations, performance isn't the only concern.
Creative agencies, broadcasters, research institutions, and enterprise IT departments increasingly care about where their data resides and who controls access to it.
Subscription-based SaaS platforms inevitably place critical infrastructure under someone else's operational control. Pricing models change. Features move behind higher licensing tiers. Vendor priorities evolve over time.
HuskHoard takes a different philosophy.
Your storage remains your storage.
By default, HuskHoard packs cold data into Zstandard-compressed chunks for efficient archiving, though administrators can easily whitelist native video formats (like .braw or .mxf) to store them unmodified. And because the backend is entirely agnostic, if you already own a TrueNAS server, Ceph cluster, MinIO deployment—or even a physical LTO tape library managed by a robotic arm—you can continue using it. If your organization mandates that data never leave your own infrastructure, HuskHoard supports robust, air-gapped workflows natively.
Likewise, if cloud storage makes sense for certain projects, HuskHoard supports that equally well without requiring migration into a proprietary ecosystem.
The software enables the workflow rather than dictating the infrastructure.
A Different Way to Think About Storage
For years, organizations have been told they must choose between performance, flexibility, and ownership.
Fast editing meant expensive SAN hardware.
Cloud collaboration meant subscription services.
Object storage meant sacrificing interactive performance.
HuskHoard challenges those assumptions.
By combining a locally indexed metadata catalog, transparent file stubbing, and automated proxy generation, it bridges the gap between active daily editing and long-term cold archiving. It preserves the absolute performance of local NVMe storage for NLE timelines, while leveraging the infinite scalability (and low cost) of S3 buckets and LTO tape for the heavy lifting.
Whether the underlying master file sits in an LTO tape library down the hall, or an AWS region thousands of miles away, the OS handles the logistics.
The editor simply scrubs the proxy, hits render, and lets the infrastructure retrieve the data.
That's perhaps HuskHoard's biggest contribution: it brings enterprise-grade HSM (Hierarchical Storage Management) and automated Media Asset Management out of the proprietary, subscription-only enterprise space.
You don't need to rent your workflow.
With HuskHoard, a true hybrid storage pipeline becomes something you can build yourself, deploy on your own infrastructure, and scale using the storage systems you already trust.
Top comments (0)