Stop Wasting Cloud Storage! ezshare Lets You Ditch Google Drive on LAN

What if I told you that every time you upload a photo to Google Drive just to send it to someone in the same room, you're burning money, bandwidth, and privacy for absolutely no reason?

Here's the painful truth developers and tech-savvy users face daily: sharing files between devices on the same network shouldn't require routing through Silicon Valley servers. Yet we do it constantly—uploading multi-gigabyte video projects to Dropbox, waiting for Google Drive to sync, burning through mobile data for local transfers. The latency is absurd. The privacy implications are worse. And when the internet hiccups? You're dead in the water.

But what if there was a way to create an instant, self-hosted file server that works entirely on your local network? No accounts. No subscriptions. No data caps. Just pure, peer-to-peer file sharing with a modern web interface that anyone can use.

Enter ezshare—the open-source secret that top developers are quietly deploying to eliminate cloud dependency for local transfers. Built by the prolific Norwegian developer Mikael Finstad, this lightweight tool transforms any folder into a Google Drive-like experience that lives entirely on your LAN. And the best part? It takes literally seconds to spin up.

In this deep dive, I'll expose exactly how ezshare works under the hood, why it's displacing cloud solutions for local workflows, and how you can deploy it in under 60 seconds. Whether you're a developer managing media assets, a photographer delivering client proofs, or just someone tired of AirDrop's mysterious failures, this guide will change how you think about file sharing forever.

What is ezshare? The Self-Hosted Google Drive Killer

ezshare is a lightweight, open-source file server that enables seamless two-way file and clipboard sharing over local networks without any internet connection. Created by Mikael Finstad and available at github.com/mifi/ezshare, it solves a deceptively simple problem with elegant execution: making local file transfers as effortless as cloud storage, but without the cloud.

At its core, ezshare starts an HTTP server that lists all files and directories from its launch directory. Anyone on the same network can connect via browser to download individual files, auto-generated ZIP archives of entire directories, or upload files back to the server. It even supports bidirectional clipboard sharing—copy on one device, paste on another. A generated QR code eliminates the friction of typing IP addresses on mobile devices.

Why is ezshare trending now? The answer lies in converging frustrations:

Privacy paranoia post-Snowden has users questioning why family photos need Google's analysis
Remote work created LAN-heavy households where four people share one connection
Cloud storage costs spiraled while local network speeds hit gigabit+ territory
Developer tooling matured around Docker^{↗ Bright Coding Blog} and npm, making self-hosting trivial

Unlike bloated NAS solutions or finicky SMB configurations, ezshare requires zero infrastructure knowledge. It's a single command that "just works"—the holy grail of developer tools. The project has gained significant traction precisely because it occupies the sweet spot between simplicity and capability that tools like Python^{↗ Bright Coding Blog}'s http.server miss (no upload support, no UI) while avoiding the complexity of Nextcloud or Seafile.

Key Features That Make ezshare Irresistible

Let's dissect what separates ezshare from half-baked alternatives:

True Two-Way Local Transfers

Most "simple" file servers are read-only. ezshare enables both uploads and downloads without data ever leaving your network perimeter. This matters for:

Legal compliance: HIPAA, GDPR, and corporate policies often prohibit cloud processing
Speed: Gigabit LAN transfers at ~125 MB/s versus cloud upload bottlenecks
Reliability: Works during internet outages, on airplanes, in bunkers

Handles Massive Files and Directories Effortlessly

The auto-ZIP generation is particularly clever. When a user requests a directory download, ezshare streams a ZIP archive on-the-fly without creating temporary files. This means:

No disk space explosions on the server for large directories
Immediate download start—no waiting for packaging to complete
Theoretical unlimited directory sizes limited only by network and storage

Cross-Platform Web Client with Mobile-First Design

The server requires Mac/Windows/Linux, but clients can be anything with a modern browser—iOS, Android, ChromeOS, even smart TVs. The QR code generation eliminates the classic pain point of typing 192.168.1.47:8080 on phone keyboards.

Bidirectional Clipboard Sync

This feature is genuinely underappreciated. Copy a URL from your laptop, paste it into your phone's browser instantly. Or transfer OTP codes, configuration snippets, or long passwords without Telegram-ing yourself. The clipboard sharing works both ways—not the crippled one-direction implementations found in most alternatives.

Media Processing Pipeline

With ffmpeg integration (especially in Docker deployments), ezshare supports video/image playback and slideshows directly in the browser. For photographers and videographers, this means clients can preview deliverables before downloading multi-gigabyte masters.

Real-World Use Cases Where ezshare Dominates

1. Creative Studio Asset Delivery

A video editor finishes a 4GB project export. Instead of WeTransfer's 2GB limit or Dropbox's upload queue, they run ezshare in the project folder. The client scans a QR code, previews the video in-browser, and downloads the master—all while the editor's internet connection sits idle.

2. Conference and Event File Distribution

Speakers at tech meetups need to share slides, datasets, and code samples. ezshare on the presenter's laptop creates an instant distribution network. Attendees download materials during the talk without congesting venue WiFi with cloud sync traffic.

3. AirDrop-Deficient Workflows

Android-to-iPhone transfers are notoriously painful. ezshare neutralizes ecosystem lock-in. A developer with a Linux workstation, iPhone test device, and Android tablet can shuffle builds, screenshots, and logs seamlessly.

4. Secure Corporate Environments

Banks, government contractors, and healthcare organizations often operate air-gapped or restricted networks. ezshare provides sanctioned file movement without violating compliance rules—no third-party servers, no data residency questions, complete auditability.

5. Developing World and Connectivity-Challenged Locations

In regions with expensive or unreliable internet, local sharing is essential. A teacher with a laptop loaded with educational videos can distribute content to 30 student tablets simultaneously via ezshare, with zero bandwidth costs.

Step-by-Step Installation & Setup Guide

Method 1: npm Installation (Recommended for Developers)

First, ensure Node.js is installed (version 18+ recommended):

# Verify Node.js installation
node --version

# Install ezshare globally
npm install -g @ezshare/cli

Basic usage:

# Navigate to your target directory
cd /path/to/your/shared/folder

# Start the server (uses default port)
ezshare

The terminal will display a local URL like http://192.168.1.5:8080 and a QR code. Scan with any mobile device to connect instantly.

Advanced path specification:

# Share a specific folder without cd-ing into it
ezshare /your/shared/folder

View all options:

ezshare --help

Method 2: Docker Deployment (Production-Ready)

Docker ensures ffmpeg and xvfb dependencies are properly configured. This is the recommended approach for consistent deployments.

Prerequisites:

Docker Desktop or Docker Engine

Option A: Docker Compose (Easiest)

# Clone or create a directory with the provided docker-compose.yml
git clone https://github.com/mifi/ezshare.git
cd ezshare

# Build and start the container
docker compose up --build

Access at http://localhost:3003. The ./my-shared-data folder is created automatically in your project root—place files here to share them.

Option B: Manual Docker CLI

# Build the image from the repository Dockerfile
docker build -t ezshare .

# Run with proper port mapping and volume mount
# $(pwd)/my-shared-data creates a persistent storage location on your host
docker run -p 3003:3003 -v $(pwd)/my-shared-data:/shared ezshare

Critical: Fix Volume Permissions on Linux/Mac

The container runs as UID 1000 (node). If you encounter Permission Denied errors:

# Create the directory if it doesn't exist
mkdir -p ./my-shared-data

# Change ownership to match container user
chown -R 1000:1000 ./my-shared-data

Method 3: Standalone Electron Executable

For non-technical users avoiding command lines entirely, download pre-built executables from the GitHub Releases page. Double-click to run—no Node.js installation required.

Migrating from v1 to v2

If you previously installed the legacy ezshare package:

# Remove old global package
npm uninstall -g ezshare

# Install new scoped package
npm i -g @ezshare/cli

REAL Code Examples: Inside ezshare's Implementation

Let's examine actual patterns from the repository to understand how ezshare operates and how you can extend it.

Example 1: Core Server Initialization Pattern

While the exact server code isn't exposed in the README, the CLI entry point reveals the architecture. The ezshare command with optional path argument demonstrates clean argument parsing:

# The simplest possible invocation—shares current directory
ezshare

# Explicit path sharing—useful in scripts and aliases
ezshare /your/shared/folder

This pattern enables powerful automation. Create a shell alias for instant sharing:

# Add to ~/.bashrc or ~/.zshrc
alias share='ezshare $(pwd)'

# Now simply type 'share' in any directory

Example 2: Docker Compose Configuration

The recommended Docker deployment uses this compose structure (implied by documentation):

# docker-compose.yml - inferred from documentation
version: '3.8'

services:
  ezshare:
    build: .
    ports:
      - "3003:3003"  # Map host port to container port
    volumes:
      - ./my-shared-data:/shared  # Persistent storage mount
    environment:
      - NODE_ENV=production
    # Container runs as node user (UID 1000) for security

Key technical insights:

Port 3003 is the application default—change the left side for host conflicts
Volume mount at /shared is mandatory; the application expects this path
node:20-slim base image keeps the container lightweight while including essential runtime tools

Example 3: Development Workflow Commands

For contributors or those customizing ezshare, the monorepo structure uses Yarn workspaces:

# Run CLI in development mode with hot reloading
yarn dev:cli

# Run Electron wrapper in development mode
yarn dev:electron

# Build all packages and create distributable Electron app
yarn build && yarn workspace @ezshare/electron package

This reveals ezshare's architecture: a monorepo with separate packages for web UI (@ezshare/web), shared library (@ezshare/lib), CLI (@ezshare/cli), and Electron wrapper (@ezshare/electron). The separation enables targeted updates and multiple distribution channels.

Example 4: Release and Publishing Pipeline

The documented release process shows enterprise-grade CI/CD practices:

# Version bump changed packages individually
yarn workspace @ezshare/web version patch
yarn workspace @ezshare/lib version patch
yarn workspace @ezshare/cli version patch
yarn workspace @ezshare/electron version patch

# Stage version changes
git add packages/*/package.json
git commit -m Release

# Build and publish to npm registry
yarn build
yarn workspace @ezshare/web npm publish
yarn workspace @ezshare/lib npm publish
yarn workspace @ezshare/cli npm publish

# Push version tags
git push

# Trigger GitHub Actions for Electron builds via workflow dispatch
# Artifacts automatically attach to draft release

Why this matters: Independent versioning per package means @ezshare/cli can ship bug fixes without forcing @ezshare/web updates. The workflow dispatch pattern for Electron builds prevents npm publish failures from corrupting desktop releases.

Example 5: Internet Exposure via Tunneling

For the rare cases when LAN isn't sufficient, ezshare documents secure tunneling patterns:

# Using Ngrok for temporary public URLs
ngrok http http://ip.of.ezshare:8080/

# Using Cloudflare Tunnel for more permanent solutions
cloudflared tunnel --url http://ip.of.ezshare:8080/ --no-autoupdate

Security note: These expose your local server to the public internet. Use only when necessary, and prefer Cloudflare's authenticated tunnels over Ngrok's open URLs for sensitive data.

Advanced Usage & Best Practices

Network Optimization

Bind to specific interfaces if multi-homed: Research Node.js server.listen() options for interface selection
Reverse proxy with Nginx for custom domains and SSL termination on LAN (useful for corporate deployments)
Firewall rules: Restrict port 3003/8080 to LAN subnet (192.168.0.0/16, 10.0.0.0/8)

Automation Patterns

Create systemd services for always-on sharing stations:

# /etc/systemd/system/ezshare.service
[Unit]
Description=ezshare file server
After=network.target

[Service]
Type=simple
User=shareuser
WorkingDirectory=/var/share
ExecStart=/usr/bin/ezshare
Restart=on-failure

[Install]
WantedBy=multi-user.target

Clipboard Security

The bidirectional clipboard is convenient but potentially dangerous in shared environments. Consider:

Running separate ezshare instances per project with different ports
Using firewall rules to restrict clipboard-enabled instances to trusted devices
Clearing clipboard history after sensitive operations

Performance Tuning

For massive file collections (10,000+ files):

Organize into subdirectories—ezshare's directory listing performs better with hierarchy
Use SSD storage for the shared volume to prevent I/O bottlenecks
Monitor with docker stats or htop during heavy transfers

Comparison with Alternatives: Why ezshare Wins

Feature	ezshare	Python `http.server`	`python -m http.server` + upload hacks	Nextcloud	Snapdrop	LocalSend
Setup complexity	One command	Built-in	Complex scripts	Database + config	Browser-based	App install
Upload support	✅ Native	❌ None	⚠️ Fragile	✅ Yes	✅ Yes	✅ Yes
Clipboard sharing	✅ Bidirectional	❌ No	❌ No	❌ No	⚠️ One-way	❌ No
Auto ZIP directories	✅ Streaming	❌ No	❌ No	✅ Yes	❌ No	❌ No
QR code generation	✅ Built-in	❌ No	❌ No	⚠️ Plugins	✅ Yes	⚠️ Partial
Mobile browser client	✅ Full-featured	⚠️ Read-only	⚠️ Fragile	✅ Yes	✅ Yes	⚠️ App required
No internet required	✅ Yes	✅ Yes	✅ Yes	⚠️ Often phones home	⚠️ STUN servers	✅ Yes
Docker deployment	✅ Official	❌ Manual	❌ Manual	✅ Yes	⚠️ Community	❌ No
Media playback	✅ ffmpeg-integrated	❌ No	❌ No	✅ Yes	❌ No	⚠️ Basic

The verdict: ezshare occupies a unique position—more capable than minimal servers, simpler than full NAS solutions, and more privacy-respecting than browser-dependent tools that leak metadata through STUN/TURN servers.

FAQ: Your Burning Questions Answered

Is ezshare completely free?

Yes, MIT-licensed open source. No feature gates, no subscriptions, no tracking. The only cost is your own hardware and electricity.

Can I use ezshare without installing Node.js?

Absolutely. Download standalone Electron executables from GitHub Releases, or use the official Docker image which bundles all dependencies.

How secure is ezshare for sensitive files?

By default, ezshare operates on your local network with no encryption. For sensitive data: run behind a VPN, use SSH tunneling, or place behind an Nginx reverse proxy with SSL. The traffic never leaves your network, eliminating cloud breach risks but requiring standard LAN security practices.

Does ezshare work between different WiFi networks?

No—devices must share the same local network segment. For cross-network sharing, use the documented Ngrok or Cloudflare tunnel patterns, or establish VPN connectivity between sites.

What's the maximum file size limit?

Technically none—limited by your filesystem and available storage. The streaming ZIP generation means even terabyte-scale directories can be downloaded without server-side temp space explosion.

Can multiple people upload simultaneously?

Yes, the server handles concurrent connections. For heavy concurrent use, deploy via Docker with appropriate resource limits and consider SSD-backed storage.

Why does the Docker container need ffmpeg and xvfb?

ffmpeg enables server-side media processing for browser playback and thumbnail generation. xvfb provides a virtual framebuffer for headless environments where graphical operations are required by dependencies.

Conclusion: Take Back Control of Your Local Transfers

We've exposed a critical inefficiency in modern workflows: routing local file transfers through distant cloud servers is technically absurd, economically wasteful, and privacy-hostile. ezshare demolishes this anti-pattern with a tool that's simultaneously simpler than cloud uploads and more capable than basic HTTP servers.

From its streaming ZIP generation to bidirectional clipboard magic, from QR-code convenience to Docker deployment maturity, ezshare represents the pinnacle of "just enough infrastructure" philosophy. It doesn't solve every file-sharing problem—but for the 80% of transfers that happen between devices in the same building, it's categorically superior to cloud-dependent alternatives.

My recommendation? Install it today. Create that shell alias. Stop feeding your family's photos into Google's analysis pipeline when they're sitting ten feet away. The GitHub repository awaits your star, your contributions, and most importantly—your adoption.

Ready to go cloudless for local sharing? npm install -g @ezshare/cli takes 30 seconds. Your future self will thank you every time a multi-gigabyte transfer completes before a cloud upload would have finished its "preparing..." animation.

Made with ❤️ in 🇳🇴—follow Mikael Finstad for more tools that respect your time and privacy.