How It Works
One FRAME. Run it anywhere. It behaves the same everywhere.
A FRAME is a single, self-contained instance you control, and you can run it in whatever way fits your setup:
- Open it directly in a web browser
- Run it as a native desktop application
- Launch it from the command line
- Package it as an executable
- Deploy it in a container
- Boot it directly on bare metal
Regardless of where it runs, it behaves the same way, because every FRAME uses the same kernel and protocols.
Apps Connect, They Don't Own
Applications connect to your FRAME instead of owning your data.
Applications (dApps) don't own your data.
Instead, they connect to your FRAME, request capabilities, and operate on the same shared foundation.
Portable by Design
Copy it, clone it, sync it, or host it yourself.
A FRAME can be copied, backed up, cloned, synchronized with other trusted FRAME instances, or hosted entirely on your own hardware.
That lets everything from a personal laptop to a distributed, user-owned cloud run the exact same software, without changing how applications are built.
What You Can Do
One foundation, countless capabilities, in plain terms.
Host Your Own Cloud
Run your own cloud on hardware you control.
Host Your Own AI
Run AI models locally, right on your FRAME.
Passwordless Authentication
Sign in with secure capabilities instead of passwords.
One Identity Across Every App
The same identity works in every application.
Custom dApp Accounts & Profiles
Apps add their own profiles on top of your identity.
Composable dApps
Apps build on each other and share the same data.
Browser, Desktop, or Bare Metal
The same FRAME runs wherever you need it.
User-Owned Decentralized Cloud
A cloud made of many user-owned FRAME nodes.
Clone Your Entire FRAME
Duplicate your whole setup in a single step.
Distributed Compute
Share processing power across trusted FRAMEs.
Shared Storage
Pool storage across your FRAME nodes.
Digital Twins
Keep a live digital copy of real-world things.
Spatial Computing
Work with 3D space and real locations.
Real-Time Collaboration
Work together live on the same data.
IoT & Robotics
Connect devices and robots to your FRAME.
Local-First Synchronization
Works offline and syncs when you reconnect.
One Search Across Everything
Search all your apps and data at once.
Capability-Based Security
Apps get only the exact access you grant.
Verifiable Source Code
Anyone can inspect and confirm the code.
Cryptographically Verified Apps
Apps are proven authentic with cryptography.
Signed & Reproducible Builds
Builds are signed and can be rebuilt to match.
Safe, Verifiable Updates
Verify updates before you trust them.
Shared Reality Across Apps
Every app sees the same underlying truth.
Build Once, Run Anywhere
Write an app once; it runs everywhere.
Universal Data Between Apps
Data flows freely between all your apps.
Multiple Views of One Reality
See the same data in many different ways.
AI That Understands Your FRAME
AI can reason over everything in your FRAME.
Open Protocols
Open, documented protocols anyone can use.
Open Source Kernel
The core is fully open source.
Peer-to-Peer Networking
FRAMEs connect directly to each other.
Versioned Data
Every change is tracked and reversible.
Content-Addressed Storage
Data is found by its content, not its location.
Extensible Kernel
Extend the core with new capabilities.
No Vendor Lock-In
Leave anytime; your data always stays yours.
Seamless Device Migration
Move between devices without friction.
Modular by Design
Built from clean, swappable parts.
Pi to Datacenter Scale
Runs on tiny devices or huge servers.
Transparent Permissions
Always see exactly what apps can access.
Reproducible Execution
The same inputs always give the same result.
Build the Internet You Control
Own and shape your corner of the internet.