Every enterprise Java team that touches more than one storage protocol ends up running more than one library. One SDK for SMB. A different one for NFS. A third, fourth, and fifth as cloud object storage, SharePoint, or a legacy NAS interface enters the picture. Each comes with its own authentication model, its own connection semantics, its own release cadence, and its own maintenance burden. None of them talk to each other, and none of them were designed to.
This is protocol fragmentation, and for integration platforms, managed file transfer (MFT) software, and hybrid cloud/on-premise storage vendors, it is not a minor inconvenience. It is a standing tax on engineering time, paid every time a protocol updates its authentication requirements, a dependency falls behind on security patches, or a new customer environment requires yet another connector the team has never built before.
The SMB vs NFS Problem, in Miniature
SMB and NFS make a useful starting point because the mismatch between them is so direct. SMB (Server Message Block) is the dominant file-sharing protocol across Windows environments and increasingly common in mixed-OS enterprise networks. NFS (Network File System) is the standard for Unix and Linux file sharing, with its own versioning history, its own locking semantics, and its own authentication conventions.
A Java team that needs to support both today typically reaches for two separate libraries, often from different sources: one commercial or in-house SMB implementation, one open-source or vendor-supplied NFS client. The application code that calls into each library looks nothing alike. Error handling differs. Connection pooling differs. Testing one protocol tells you nothing about the reliability of the other. The team is not maintaining one integration; it is maintaining two, in parallel, indefinitely.
The Pattern Repeats: Cloud, SharePoint, and Beyond
SMB vs NFS is just the first fork. The same fragmentation reappears as soon as an MFT platform, a data governance tool, or a hybrid storage vendor needs to reach cloud object storage such as Amazon S3, Azure Blob Storage, or Google Cloud Storage. Each of those has its own SDK, its own credential model, and its own API conventions that share almost nothing with SMB or NFS. Add enterprise repositories like SharePoint, and the list of protocol-specific dependencies keeps growing. Every new connector is a new library to vet, a new authentication flow to implement, and a new maintenance commitment layered on top of the ones that came before it.
For integration platforms and MFT vendors in particular, this compounds directly into product roadmap risk. Customer environments are heterogeneous by default: file servers running SMB or NFS, cloud storage for backup and archival, SharePoint for document management, and increasingly a long tail of industry-specific repositories. Supporting that breadth today means supporting a breadth of unrelated codebases internally, each with its own failure modes under production loads.
Java Already Solved This Once: The JDBC Precedent
Java has been here before. Before JDBC, connecting to a database meant writing to that database’s proprietary API. Oracle, Sybase, and every other vendor had their own interface, and application code was locked to whichever database it was written against. JDBC changed that by defining one API contract that any compliant driver could implement underneath.
Application developers wrote against JDBC once; the driver handled the vendor-specific detail. Switching databases, or supporting several at once, stopped requiring a rewrite.
File access protocols have never had a JDBC moment that stuck. A common layer has been attempted – Java’s own NIO.2 filesystem SPI, Apache Commons VFS – but none paired a stable contract with production-grade, commercially supported implementations across the protocols enterprises actually run. So in practice, SMB, NFS, S3-compatible object storage, SharePoint, and FTP/FTPS still require developers to learn and implement a separate library each, with no shared contract underneath. A unified file access API applies the same logic JDBC applied to databases: one interface for the application layer, with protocol-specific implementation handled underneath it. As with JDBC, the unification is entirely client-side – each connector still speaks the real native protocol on the wire, so an SMB server sees ordinary SMB2 and nothing new is introduced on the network.
A Unified File Access API for Multi-Protocol Environments
This is the architecture behind jMount, a modular Java connectivity suite from Visuality Systems.
Instead of a separate SDK per protocol, jMount exposes one Java API across multiple protocols and connectors. The stated purpose, in the company’s own terms, is “enabling developers to integrate multiple protocols through a unified API, eliminating the need to learn and implement separate libraries and reducing integration complexity.”
Visuality Systems has spent close to 30 years focused on the SMB protocol specifically, building YNQ for embedded and C environments and jNQ, a commercial-grade Java SMB implementation positioned as the premier Java JCIFS alternative. jMount extends that same protocol expertise into a broader, multi-protocol API rather than starting from scratch. Native network file system support is built in from the ground up, with SMB and NFS fully supported out of the box. Socket-level file transfer protocols – including FTP, FTPS, and SFTP – provide broad wire-level protocol coverage. Beyond traditional wire protocols, connectors for cloud object storage (Amazon S3, Azure Blob Storage, and Google Cloud Storage) and enterprise collaboration repositories (such as SharePoint and OneDrive) represent the core expansion path, with additional connectors introduced as customer-validated demand confirms them.
This is a roadmap built from what customers are asking for, not a speculative feature list.
Modular Adoption: Start with One Protocol, Add More Without Re-Architecting
A unified API only holds value if adopting it doesn’t require ripping out what already works. jMount’s adoption model is explicitly incremental. A team can start with just the SMB connector, or just NFS, and add further protocols later without a forced migration and without lock-in. Each connector is adopted independently, on its own timeline, against its own use case.
For an MFT platform or hybrid storage vendor, this matters in practice. It means the SMB connector can go into production this quarter while the NFS or S3 connector is still being evaluated, without either decision blocking the other. It means build-vs-buy decisions can be made protocol by protocol rather than as a single all-or-nothing bet on a new architecture.
Where This Matters Most
The teams most exposed to protocol fragmentation are the ones building the infrastructure other companies depend on: integration platforms, MFT software, hybrid cloud/on-premise storage vendors, and data governance and compliance platforms that need reliable, auditable access across heterogeneous storage backends. For these teams, a unified file access API is not a convenience feature. It’s the difference between adding a new protocol in weeks versus committing another engineering team to a multi-quarter integration project.
Visuality Systems positions itself as the network protocol experts, and jMount is the next iteration of that focus, applied to the fragmentation problem enterprise Java teams face today. Existing jNQ customers already familiar with Visuality’s commercial-grade SMB support have a natural path to evaluate the broader suite.
Next step: Evaluate jMount alongside existing SMB deployments, or engage with Visuality Systems engineers to discuss roadmap alignment for the protocols your platform needs next.
Lilia Wasserman, VP R&D, Visuality Systems





