tsbin

In an era where data moves faster than attention spans and security threats evolve by the week, building reliable and privacy-first file-sharing tools has become more important than ever. tsbin is my attempt to reimagine this problem from the ground up. It’s a secure, modular platform designed to make encrypted file sharing simple for users and flexible for developers.

tsbin began as a small personal experiment and has grown into a multi-layered project consisting of a Rust core, a WebAssembly build for browser performance, a TypeScript/React interface, and a backend built for scalability. What follows is an overview of the ideas, architecture, and motivations that shaped it.

The Problem tsbin Solves #

Traditional file-sharing systems often rely on server-side trust: files are uploaded, processed, and stored in forms that the backend can access. For personal projects or small teams, this is acceptable. For sensitive data, it’s not.

tsbin takes a different approach. It emphasizes:

• Client-side encryption – Files never leave the user’s environment unencrypted.
• Chunk-based uploads – Large files move smoothly and resiliently.
• Minimal server knowledge – The backend treats encrypted blobs as opaque data, reducing risk.
• WASM-accelerated operations – Cryptographic operations run quickly and safely in the browser.

The result is a system where users stay in control of their data, and developers gain a clear, modular pipeline to extend or integrate.

The Tech Behind tsbin #

Rust Core + WebAssembly #

At the heart of tsbin is a Rust library that handles encryption, chunking, and file processing. Rust’s memory safety guarantees give confidence for sensitive operations, while WebAssembly allows these same operations to run inside the browser with near-native performance.

This dual design (native Rust for CLI/server + WASM for browser) lets tsbin live comfortably in both environments.

React Frontend #

The UI is built with React and TypeScript, offering a smooth user experience for uploading, tracking, viewing, and managing files. The frontend communicates with the WASM module to encrypt everything before it ever leaves the device.

Backend Optimized for Simplicity #

The server is intentionally unaware of what is inside the encrypted chunks. Its job is limited to:

• Receiving encrypted chunks
• Keeping track of upload sessions
• Returning download references
• Handling deletion and expiry

This design allows tsbin to be hosted in many environments and reduces complexity on the server side.

Monorepo Architecture with Turborepo #

To keep things organized, tsbin is structured as a monorepo containing:

• apps/ – frontend, backend, CLI
• packages/ – shared TypeScript packages
• crates/ – Rust and WASM libraries

Turborepo ensures efficient builds, caching, and consistent development workflows across the whole system.

What Makes tsbin Unique #

Privacy by Design #

There is no mode where files are uploaded without encryption. The system is incapable of seeing raw data, which eliminates an entire category of risk and system complexity.

Performance-Oriented #

Chunking, streaming, and WASM-accelerated crypto allow tsbin to handle large files without dragging the browser to a halt.

Extensible #

tsbin isn’t just a web app — it’s a platform. Developers can build:

• A CLI for scripting
• A desktop app for offline-first workflows
• Server plugins for custom storage
• Integrations with existing file management systems

The architecture welcomes growth rather than resisting it.

The Vision #

tsbin aims to become a versatile, open, privacy-first tool for anyone dealing with file transfers — whether it’s developers shipping builds, teams sharing internal assets, or individuals sending personal files securely.

Over time, I plan to extend it with:

• Zero-knowledge metadata hiding
• Peer-to-peer transfers
• Offline-ready desktop clients
• Integrations with cloud storage
• Public API for external developers

tsbin is still evolving, but the foundation is built with long-term stability and flexibility in mind.

Conclusion #

Building tsbin has been an exploration of modern web capabilities: safety through Rust, speed through WebAssembly, clarity through TypeScript, and structure through a unified monorepo. It demonstrates how a single project can combine performance, security, and developer experience without sacrificing usability.

If the future of the web leans toward privacy and resilience, tsbin aims to stand firmly in that future.

Here’s a simpler, cleaner section you can plug right into your article:

Resources #

If you want to explore tsbin, here are the main places to start:

[Demo]((https://www.tsbin.tech/) – Try out the file-sharing experience in the browser.
GitHub – View the code, architecture, and ongoing development.

Priyanshu Verma