Date: December 2, 2025
Version: 1.0
Status: Strategic Planning Document
ElastOS is a Web3 desktop operating system that runs entirely in your browser, connecting to your personal server (Raspberry Pi, laptop, or VPS) that you own and control. Login with your blockchain wallet from anywhere in the world, and access your files, apps, and services stored on YOUR hardware via decentralized protocols (IPFS, DID). Extend functionality through a DApp store that lets you install additional services (blockchain nodes, media servers, AI models) on your personal server. Enable tokenized digital rights management where content is encrypted on IPFS and access is controlled by NFTs. True data sovereignty: your keys, your data, your hardware.
Meet Alice - A freelance designer who wants true digital sovereignty
Alice's Reality:
- Files on Google Drive (Google owns/reads them)
- Photos on iCloud (Apple controls access)
- Email on Gmail (Google scans for ads)
- Documents on Microsoft 365 (Microsoft sets terms)
- Apps via App Store (Apple's 30% tax)
- Identity via passwords (12 different passwords, 2FA nightmare)
Problems:
❌ Pays $30/month for subscriptions (forever)
❌ No control over data (companies can read/delete/lock)
❌ Privacy theater (companies track everything)
❌ Vendor lock-in (can't switch easily)
❌ Account bans (one wrong move = lose everything)
❌ Censorship (platforms decide what's allowed)
Alice's New Reality:
- Buys Raspberry Pi 5 for $150 (one time)
- Plugs it into router at home
- 5-minute setup wizard:
1. Connect to WiFi
2. Connect MetaMask wallet
3. Create DID (automatic)
4. Done ✅
From anywhere in world:
1. Opens browser → elastos.app
2. Clicks "Connect Wallet"
3. MetaMask pops up → Signs
4. Desktop loads (her files, her apps, her data)
All data on HER Pi at home:
✅ Files encrypted on IPFS node (her hardware)
✅ Apps installed on Pi (her choice)
✅ Blockchain wallet = her identity (no passwords)
✅ Access from any device (phone, laptop, tablet)
✅ $2/month electricity cost (vs $30/month subscriptions)
✅ Can't be banned, censored, or locked out
✅ Can switch to different frontend anytime
✅ Can migrate to bigger hardware as needed
What: Desktop UI that runs in browser
Hosted: IPFS (decentralized) + elastos.eth (ENS domain)
Purpose: Provides the interface, does NOT store any data
Same for: ALL users (one frontend, like Google.com homepage)
User types: elastos.app
↓
DNS resolves to: IPFS gateway + ENS
↓
Downloads: Static HTML/CSS/JS bundle
↓
Runs in: User's browser (Chrome, Firefox, Safari)
↓
Shows: Login screen + wallet connect button
What: Node.js backend + IPFS node + SQLite database
Runs on: User's hardware (Pi, laptop, VPS - they choose)
Purpose: Serves THAT user's desktop, files, apps
Unique per: Each user (1 user = 1 personal server)
ElastOS Core Package includes:
├── Backend Server (Node.js/Puter)
│ - API endpoints
│ - File operations
│ - App management
│ - User authentication
│
├── IPFS Node (Kubo)
│ - File storage
│ - Content addressing
│ - P2P distribution
│
├── SQLite Database
│ - User metadata
│ - File paths → CID mapping
│ - App configurations
│
├── Service Manager
│ - Docker/Podman runtime
│ - App lifecycle management
│ - Resource monitoring
│
└── Discovery Service
- DID registration
- Endpoint announcement
- Health monitoring
What: Maps wallet → personal server URL
Protocol: Elastos DID (blockchain-based)
Purpose: Browser finds user's server automatically
Login Flow:
1. User connects wallet → 0x123ABC...
2. Frontend queries: "What DID owns this wallet?"
→ did:elastos:abc123
3. Frontend resolves DID document:
→ serviceEndpoint: "https://alice-pi.elastos.net"
4. Frontend connects to Alice's personal server
5. Server validates signature, returns desktop state
What: Marketplace of services users can install on their server
Format: Docker containers with metadata
Installed on: User's personal server (not centralized)
Available Apps:
- Core Apps (pre-installed):
├── File Manager
├── Text Editor
├── Media Player
├── Terminal
└── Settings
- DApp Store (installable):
├── Blockchain Nodes:
│ ├── Ethereum Full Node
│ ├── Bitcoin Node
│ ├── Elastos Mainchain
│ └── IPFS Cluster (multi-node)
│
├── Media Services:
│ ├── Plex Media Server
│ ├── Jellyfin
│ ├── Photoprism (photo management)
│ └── Navidrome (music streaming)
│
├── Productivity:
│ ├── Nextcloud Files
│ ├── Calibre (ebook library)
│ ├── Paperless-ngx (document management)
│ └── Memos (notes)
│
├── AI/ML:
│ ├── Ollama (local LLM)
│ ├── Stable Diffusion
│ └── Whisper (speech-to-text)
│
└── Web3 Services:
├── ENS Resolver
├── IPFS Gateway
├── Blockchain Explorer
└── NFT Gallery
What: NFT-based content encryption/licensing
Protocol: Smart contracts on Elastos/ETH
Purpose: Buy/sell/license encrypted content
Content Creator Flow:
1. Upload movie to IPFS (encrypted)
2. Create NFT representing license
3. Smart contract stores decryption key
4. List NFT for sale ($10)
Content Buyer Flow:
1. Buy NFT (sends $10 to creator)
2. NFT transferred to buyer's wallet
3. ElastOS detects NFT ownership
4. Retrieves decryption key from smart contract
5. Downloads encrypted file from IPFS
6. Decrypts in WASM sandbox
7. Plays in media player
8. Can resell NFT to someone else
Benefits:
- Creator gets paid directly
- No middleman (no Netflix/Spotify)
- Resellable (can sell license later)
- Portable (works on any device)
- Uncensorable (on IPFS)
Answer: ElastOS Core as INSTALLABLE SOFTWARE (like Docker, Node.js)
Users can run it on ANY of these:
What User Gets:
DIY Approach:
1. Buy Raspberry Pi 5 (8GB) - $80
2. Buy SD card (128GB) - $20
3. Buy case + power - $30
Total: ~$130
Download:
- ElastOS Pi Image (.img file)
- Flash to SD card
- Boot Pi
- 5-minute setup wizard
Pre-Built Approach (for less technical users):
ElastOS Home Server Kit - $249
Includes:
- Raspberry Pi 5 (8GB)
- 256GB SD card (ElastOS pre-installed)
- Official case + cooling
- Power supply
- Ethernet cable
- Quick start guide
- Priority support (3 months)
Arrives:
- Plug into router
- Plug into power
- Open browser → elastos.app/setup
- Follow wizard
- Done in 5 minutes
What User Does:
Requirements:
- Any computer (2014+)
- 4GB+ RAM
- 50GB+ storage
- Linux, Windows, or macOS
Install:
# Option A: Docker (easiest)
curl -fsSL https://get.elastos.app | sh
docker-compose up -d
# Option B: Native (more control)
git clone https://github.com/Elacity/elastos-core
cd elastos-core
npm install
npm start
# Option C: Snap/Flatpak (Linux)
snap install elastos-core
Benefits:
- Free hardware (repurpose old laptop)
- More powerful than Pi
- Larger storage capacity
- Can run 24/7 in closet
What User Does:
Cloud Providers:
- Linode: $12/month (4GB RAM, 80GB SSD)
- DigitalOcean: $12/month
- Hetzner: €4.51/month (cheaper in Europe)
- Vultr: $12/month
Setup:
1. Create VPS with Ubuntu 22.04
2. SSH into server
3. Run install script:
curl -fsSL https://get.elastos.app | sh
4. Setup wizard configures everything
5. Get server URL (e.g., https://123.45.67.89:4100)
Benefits:
- No hardware management
- Professional uptime (99.9%+)
- Fast internet connection
- Can upgrade specs easily
- Access even if home internet down
Tradeoffs:
- Monthly cost (not one-time)
- Trust VPS provider (less sovereign)
- Data stored on their hardware
What We Sell (future product):
ElastOS Station Pro - $399
Hardware:
- Intel N100 mini PC (4 cores, 12GB RAM)
- 512GB NVMe SSD
- Gigabit Ethernet
- WiFi 6
- Silent fanless design
Software:
- ElastOS Core (pre-installed)
- IPFS node (pre-configured)
- Automatic updates
- Remote management
Setup:
1. Unbox
2. Plug into router + power
3. Scan QR code with phone
4. Connect wallet
5. Done (under 2 minutes)
Includes:
- 1 year warranty
- 24/7 support
- Automatic backups to cloud (encrypted)
- Migration tool (move from Pi)
Target Market: Non-technical users who want plug-and-play
Format: Open-source repository + installation packages
elastos-core/
├── Installation Methods:
│ ├── Docker image (elastos/core:latest)
│ ├── npm package (@elastos/core)
│ ├── Raspberry Pi image (.img)
│ ├── Snap package (Linux)
│ ├── Homebrew formula (macOS)
│ └── Install script (curl | sh)
│
├── Included Components:
│ ├── Puter backend (Node.js)
│ ├── IPFS Kubo node
│ ├── SQLite database
│ ├── Docker runtime (for DApps)
│ ├── Tailscale agent (networking)
│ └── Setup wizard (web UI)
│
└── Documentation:
├── Installation guides (per platform)
├── Configuration reference
├── Troubleshooting
└── API documentation
Purpose: First-run configuration (guides user through setup)
Wizard Steps:
Step 1: Welcome
- Explain what ElastOS is
- System requirements check
- Continue button
Step 2: Network Setup
- Auto-detect local IP
- Install Tailscale (one click)
- Test connectivity
- Generate access URLs:
- Local: http://192.168.1.100:4100
- Remote: https://my-elastos.tailscale.com
Step 3: Wallet Connection
- Show QR code
- Or MetaMask popup (if on same device)
- Sign message to prove ownership
- Derive DID from wallet
Step 4: DID Registration
- Create DID document
- Register on Elastos DID chain
- Set serviceEndpoint to Tailscale URL
- Publish (1-2 minute wait)
Step 5: Security
- Set admin PIN (for local access)
- Enable HTTPS (Let's Encrypt if public)
- Configure firewall
- Enable automatic updates (optional)
Step 6: Complete
- Show access instructions
- QR code to bookmark
- Test connection link
- "Open Desktop" button
Purpose: The UI that users see in browser
Features (Phase 1):
- Window management (drag, resize, minimize, maximize)
- Taskbar (open apps, notifications)
- File browser (navigate folders)
- System apps:
- File Manager (browse, upload, download)
- Text Editor (edit files)
- Image Viewer (view photos)
- Settings (configure ElastOS)
- Terminal (SSH to server)
- Login flow:
- Connect wallet button
- DID auto-discovery
- Or manual server URL entry
- Right-click context menus
- Keyboard shortcuts
- Multi-window support
- Drag & drop file upload
Guides for Each Platform:
docs/installation/
├── raspberry-pi.md
│ - Hardware requirements
│ - Image download links
│ - Flashing instructions
│ - First boot setup
│ - Troubleshooting
│
├── docker.md
│ - Docker install
│ - docker-compose.yml
│ - Environment variables
│ - Volume configuration
│ - Updating
│
├── vps.md
│ - Provider recommendations
│ - Server specs
│ - Ubuntu setup
│ - Security hardening
│ - Domain configuration
│
├── linux.md
│ - Snap install
│ - Native install
│ - Systemd service
│ - Firewall config
│
├── macos.md
│ - Homebrew install
│ - Native install
│ - LaunchAgent setup
│
└── windows.md
- WSL2 setup
- Docker Desktop
- Windows Service
Demo Instance (for testing/showcase):
https://demo.elastos.app
- Pre-configured demo account
- Read-only mode (can explore, can't modify)
- Shows all features
- Performance benchmark
- Load testing
Purpose:
- Users can try before installing
- Developers can test integration
- Screenshots for marketing
- QA testing environment
- ElastOS Core installs in <5 minutes on Pi
- Setup wizard completes in <5 minutes
- Desktop loads in <3 seconds after login
- File upload/download works reliably
- Works on Pi 4, Pi 5, and x86 Linux
- Automatic DID discovery works 95%+ of time
- Tailscale connection success rate >99%
- No data loss (files persist across restarts)
- Non-technical user can set up Pi solo (with video guide)
- Login from different device works first try
- No confusing error messages
- Settings are clear and documented
- Help documentation is comprehensive
- Community forum exists for support
- Every installation method has step-by-step guide
- Video tutorials for common tasks
- FAQ covers 90% of support questions
- API documentation is complete
- Troubleshooting guide covers common issues
What to Build:
1. Docker Development Stack
- ElastOS backend container
- IPFS container
- PostgreSQL container (for testing multi-user)
- Nginx reverse proxy
2. Development Scripts
- npm run dev (start all services)
- npm run test (run test suite)
- npm run build (create production build)
3. CI/CD Pipeline
- GitHub Actions
- Automatic testing on PR
- Docker image build
- Raspberry Pi image build
What to Build:
1. Authentication System
- Wallet signature verification
- Session management
- DID integration
2. File Operations API
- Upload/download
- Directory listing
- File metadata
- IPFS integration
3. Desktop State API
- Window positions
- Open apps
- User preferences
- Sync across devices
What to Build:
1. IPFS Node Management
- Auto-start on boot
- Pin management
- Storage monitoring
- Garbage collection
2. File Storage
- Upload to IPFS (encrypted)
- Download from IPFS
- CID → path mapping
- Public folder (unencrypted)
What to Build:
1. Web-Based Setup Wizard
- Network configuration
- Wallet connection
- DID registration
- Security settings
2. Installation Packages
- Docker image
- Raspberry Pi image
- npm package
- Install scripts
3. Documentation
- Installation guides
- User manual
- API reference
- Video tutorials
Raspberry Pi:
- Model: Pi 4 (4GB) or Pi 5 (4GB+)
- Storage: 64GB microSD (128GB recommended)
- Network: Ethernet (WiFi works but slower)
- Power: Official power supply (3A)
- Cooling: Heatsink or fan (recommended)
PC/Laptop:
- CPU: Intel Core i3 (2014+) or AMD equivalent
- RAM: 4GB minimum, 8GB recommended
- Storage: 50GB free space
- OS: Ubuntu 22.04, Windows 10+, macOS 12+
VPS:
- vCPU: 2 cores
- RAM: 4GB
- Storage: 50GB SSD
- Bandwidth: Unmetered (or >1TB/month)
- OS: Ubuntu 22.04 LTS
Operating System Layer:
- Linux kernel 5.15+
- systemd (service management)
- iptables/nftables (firewall)
Application Layer:
- Node.js 20 LTS
- IPFS Kubo 0.24+
- SQLite 3.40+
- Docker 24+ (for DApps)
Networking Layer:
- Tailscale (VPN/NAT traversal)
- Caddy (reverse proxy, HTTPS)
- mDNS/Avahi (local discovery)
Security Layer:
- Let's Encrypt (HTTPS certificates)
- fail2ban (intrusion prevention)
- AppArmor/SELinux (sandboxing)
Components:
├── Desktop
│ - Wallpaper
│ - Icons (shortcuts to apps/folders)
│ - Right-click context menu
│
├── Taskbar (bottom)
│ - Start menu / app launcher
│ - Open windows (taskbar items)
│ - System tray (network, updates, etc.)
│ - Clock
│ - User menu (settings, logout)
│
├── Windows
│ - Title bar (minimize, maximize, close)
│ - Draggable
│ - Resizable
│ - Focus/Z-index management
│
└── File Browser
- Tree view (folders)
- List view (files)
- Icon view (thumbnails)
- Breadcrumb navigation
- Upload/download buttons
- Right-click → Share (for Public folder)
1. File Manager
- Browse folders
- Upload/download
- Cut/copy/paste
- Rename/delete
- File properties
- Search
2. Text Editor
- Syntax highlighting
- Auto-save
- Line numbers
- Find/replace
- Themes
3. Settings
- Network (Tailscale status)
- Storage (IPFS stats)
- Security (DID, backup)
- Appearance (theme, wallpaper)
- Apps (installed DApps)
- About (version, support)
4. Terminal (SSH)
- Connect to server via SSH
- Run commands
- View logs
- System monitoring
5. Media Viewer
- View images
- Play audio/video (basic)
- Gallery mode
Primary: Blockchain Wallet
- User signs message with private key
- Server verifies signature against wallet address
- Session token issued (expires in 24 hours)
- No passwords (phishing-resistant)
Fallback: Admin PIN (local access only)
- 6-digit PIN for local network access
- If wallet unavailable
- Can't be used remotely (security)
Files:
- Private folders: AES-256-GCM
- Key derived from wallet signature
- IV generated per file
- Public folder: No encryption
Database:
- SQLite with SQLCipher
- Encrypted at rest
- Key derived from wallet
Network:
- HTTPS (Let's Encrypt)
- Tailscale (WireGuard VPN)
- No plaintext transmission
File Permissions:
- Owner: Full control (read, write, delete)
- Public folder: Read-only via IPFS gateway
- No multi-user in Phase 1 (single user per server)
API Authentication:
- Bearer token (JWT)
- Wallet signature verification
- Rate limiting (prevent abuse)
- IP whitelist (optional)
DAY 0: Ordering
→ User visits elastos.app
→ Clicks "Get Started"
→ Options:
• Buy Pi kit ($249) → Amazon/official store
• DIY guide (download image for free)
→ Ships within 24 hours
DAY 3: Arrives
→ Unbox Pi kit
→ Read quick start card:
1. Plug Pi into router (Ethernet)
2. Plug Pi into power
3. Wait 2 minutes (boot + setup)
4. Open browser → elastos.app/setup
→ Browser shows:
"Looking for your ElastOS server..."
[Found! Click to continue]
→ Setup wizard opens:
Step 1: Connect your wallet
[Show QR code] [Or click if on same device]
→ User scans QR with MetaMask mobile
→ Signs message
Step 2: Creating your identity...
→ DID creation (automatic)
→ Registering on blockchain (30 seconds)
✅ Done! Your identity: did:elastos:abc123
Step 3: Securing your server...
→ Tailscale setup (automatic)
→ HTTPS certificate (automatic)
✅ Your server: https://alice-pi.elastos.net
Step 4: Ready!
→ Desktop loads
→ Welcome tutorial (optional)
TOTAL TIME: 3-4 minutes
Alice in Tokyo (Pi is in NYC):
Morning:
1. Opens laptop
2. Goes to elastos.app
3. Clicks "Connect Wallet"
4. MetaMask pops up → Signs
5. Desktop loads (her files from NYC Pi)
6. Opens "Work/Project-X/design.fig"
7. Edits in Figma (via ElastOS browser)
8. Saves (uploads to Pi IPFS node)
Afternoon:
1. Phone dies (no MetaMask access)
2. Borrows friend's laptop
3. Goes to elastos.app
4. Enters server manually: alice-pi.elastos.net
5. Enters admin PIN (6 digits)
6. Access granted (read-only mode without wallet)
7. Downloads file needed
8. Logs out
Evening:
1. Back home
2. Desktop computer (third device)
3. elastos.app → Connect Wallet
4. All same files, same desktop state
5. Installs "Plex Media Server" from DApp store
6. Watches movies stored on Pi's IPFS
EXPERIENCE: Seamless across all devices
As a user, I can:
- Install ElastOS on my Pi/laptop/VPS in <10 minutes
- Login with my wallet from any device
- Upload files (encrypted automatically)
- Download files from anywhere
- Share files via Public folder (IPFS links)
- Access my desktop from phone, laptop, tablet
- See my files even if I switch browsers
- Use basic apps (file manager, text editor, etc.)
- Configure settings (wallpaper, theme, etc.)
- View IPFS storage stats
- Backup to external drive
- Migrate to bigger hardware
These come in later phases:
- Install DApps from store (Phase 4)
- Run blockchain nodes (Phase 4)
- Multi-device sync (Phase 3 - works but manual)
- Collaborative editing (Phase 5+)
- Mobile app (Phase 5+)
- Offline mode (Phase 5+)
- Multi-user (not planned - one user per server)
Option A: DIY Raspberry Pi
One-Time:
- Pi 5 (8GB): $80
- 128GB SD: $20
- Case + PSU: $30
Total: $130
Monthly:
- Electricity: $2 (10W @ $0.12/kWh)
- Internet: $0 (home connection)
Total: $2/month
Year 1: $154
Year 2+: $24/year
Option B: Pre-Built Kit
One-Time:
- ElastOS Kit: $249
Monthly:
- Electricity: $2
Total: $2/month
Year 1: $273
Year 2+: $24/year
Option C: VPS
One-Time: $0
Monthly:
- Linode 4GB: $12
Total: $12/month
Year 1: $144
Year 2+: $144/year
Comparison to Google Drive:
Google One (2TB):
- $10/month
- Year 1: $120
- Year 2+: $120/year
- Forever: Rent (no ownership)
ElastOS (Pi):
- Year 1: $154 ($130 + $24)
- Year 2+: $24/year
- Forever: Own hardware
ROI: ElastOS breaks even after 15 months, then saves $96/year
Optimistic:
- 1,000 active installations
- 500 Pi kits sold
- 100 VPS deployments
- 400 DIY installations
Realistic:
- 100 active installations
- 50 Pi kits sold
- 20 VPS deployments
- 30 DIY installations
Minimum Viable:
- 10 active installations
- 5 Pi kits sold
- Good documentation
- No critical bugs
Technical:
- Uptime: >99% (self-reported by users)
- Setup success rate: >90%
- Average setup time: <10 minutes
- File upload/download success: >99.9%
- DID discovery success: >95%
User Satisfaction:
- NPS (Net Promoter Score): >50
- Setup difficulty: <3/10
- Documentation quality: >8/10
- Would recommend: >70%
Phase 1 is: PORTABLE SOFTWARE that users can install on THEIR CHOICE of hardware
Specifically:
We Build:
✅ ElastOS Core (open-source software)
✅ Installation packages (Docker, Pi image, npm, etc.)
✅ Setup wizard (web UI for configuration)
✅ Desktop frontend (runs in browser)
✅ Documentation (guides for each platform)
We DO NOT Build (Phase 1):
❌ Specific hardware (users bring their own)
❌ Centralized hosting (each user hosts themselves)
❌ DApp store (Phase 4)
❌ Mobile app (later)
Users Can Choose:
Hardware Options:
1. Raspberry Pi (consumer-friendly, $130-250)
2. Old laptop (free, repurpose existing)
3. VPS (cloud-based, $12/month)
4. Mini PC (powerful, $200-400)
5. NAS (advanced, $300-600)
Installation Methods:
1. Download Pi image → Flash → Boot (easiest for Pi)
2. Docker Compose (easiest for servers)
3. npm install (for developers)
4. Snap/Flatpak (for Linux users)
5. Pre-built kit (for non-technical)
Why This Approach?:
✅ User choice (not locked to one vendor)
✅ Start small, upgrade later (Pi → server)
✅ No vendor lock-in (can migrate)
✅ Lower barrier to entry (use what you have)
✅ Sustainable (not subsidizing hardware)
✅ Open source (audit & contribute)
- Set up development environment
- Docker compose for local dev
- Basic backend server (Puter fork)
- IPFS node integration
- SQLite database schema
- Wallet signature verification
- DID creation flow
- Session management
- Discovery system (DID → server URL)
- Upload to IPFS (encrypted)
- Download from IPFS
- File browser API
- Public folder (unencrypted sharing)
- Create Docker image
- Create Pi image
- Setup wizard UI
- Installation guides
- Video tutorials
Deliverable: Working ElastOS that users can install and use on their own hardware
This is what Phase 1 IS: Installable software, user's choice of hardware, true personal server architecture.
Ready to build? 🚀