spacewave

Lightning-fast local-first workspaces with peer-to-peer sync

Combining the flexibility of cloud apps with the freedom of open-source.
Full-stack for plugins and apps with Go, TypeScript, React, WebAssembly.

Overview

Spacewave is a full-stack for local-first apps with Go and WebAssembly.

The Spacewave app is a cross-platform workspace with multiplayer p2p sync. It can run fully offline in the web browser or desktop app and optionally uses the cloud for storage and networking with end-to-end encryption.

In practical terms: Spacewave enables you to store and collaborate on your data with fully open-source software. It combines the convenience of cloud apps with the flexibility and freedom of desktop apps.

Features:

• Workspaces: Work together seamlessly with live sync
• Local-First: Works offline, sync when online
• End-to-End Encrypted: Private and secure

Spacewave brings several advantages compared to server/client apps:

• Pluggable Storage: Store data in any storage backend
• Self-Hosted: No servers or configuration required
• Cross-Platform: One codebase runs everywhere

Plugin Ecosystem: Extend workspaces with community plugins:

• File, database, code, and document collaboration
• Chat, communications, forums, and messaging
• Remote command and control of your devices
• SkiffOS for running and managing Linux hosts
• ...and more!

Most collaborative apps store your data in someone else's database, limiting what you can do with it. Spacewave runs the database and applications locally, giving you true data ownership and snappier performance.

Getting Started

Where would you like to start?

• I want to use or self-host Spacewave: Open Spacewave to get started!
• I want to modify Spacewave or build my own plugins: see running from source
• I want to develop my own app with Spacewave Stack: see Bldr

You can try Spacewave instantly in your web browser, just click here.

Running from source

To start the Spacewave app:

# Install dependencies
bun install

# Start the desktop app
bun run start:desktop

# Start the web app
bun run start:web

# Start the WASM web app
bun run start:web:wasm

To run the test suite:

# All tests
bun run test

# Go tests only
bun run test:go

# Lint
bun run lint

# Typecheck
bun run typecheck

Spacewave uses Protobuf for message encoding.

You should re-generate the protobufs after changing any .proto file:

# generate the protobufs
bun run gen

Why Spacewave?

Traditional web-apps store and process data on servers and cloud infrastructure. Developers write API calls to access the user data, and the frontend just displays the response. Recent trends towards server-side rendering have increased dependence on servers and the cloud even more.

This works great for static websites and services that require an internet connection. But what if we want apps that work offline, are open-source, or use features traditionally expensive to scale like multiplayer sync?

Imagine if every video game you played was rendered fully server-side. That game would be way too laggy to play smoothly, right? This is how our modern web apps are designed and built. But it doesn't have to be this way.

Modern web browsers come with WebAssembly, WebWorkers, ServiceWorkers, SharedWorkers, IndexedDB, and WebRTC. These features enable building fully self-sufficient apps running fully on the client side.

Spacewave utilizes these features to provide resources to apps with an abstraction layer smoothing the differences between platforms. For example, an app can allocate a SQL database and store it in Redis, BadgerDB, or IndexedDB, all without changing a single line of code when switching backends.

We look forward to building a new generation of apps that are both open-source and cloud-enabled, without requiring users to jump through hoops to self-host and manage their own servers.

Architecture

The goal is to build software that runs anywhere with any storage backend.

Spacewave runs the app logic in WebWorkers/SharedWorkers in the web browser and as native processes on desktop. This brings the entire Go ecosystem to the browser while enabling true local-first apps.

Components:

• Bifrost - Network over any transport

  • Cross-platform peer-to-peer communication
  • Encrypted transport protocols with stream multiplexing
  • Supports WebRTC and WebSocket in the web browser

• Hydra - Store data anywhere w/ p2p sync

  • Many supported data structures: SQL, K/V, GraphDB, ...
  • Pluggable storage backends: BadgerDB, Redis, S3, ...
  • Supports IndexedDB in the web browser

• Bldr - Build and run on any OS or browser

  • Build system and development environment
  • Hot reload and fast JS bundling with esbuild and vite
  • Cross-platform build and release

• SkiffOS - Build and run on any device (w/ Linux)

  • Supports 40+ device types
  • Cross-compiles to target any architecture
  • Minimal with modular configuration

• Forge - Continuous integration and automation

  • Distributed job scheduler
  • CI/CD pipeline automation
  • Workflow orchestration

• Auth - Authentication methods and credential flows

  • Password and PEM-based authentication primitives
  • Shared auth building blocks for provider and session flows

• Identity - Identity and domain primitives

  • Identity records and domain-backed configuration
  • Supporting types for account and provider workflows

All components are designed to be used in multiple ways:

• As an application: each component has its own CLI
• As a library: all Go packages are documented as libraries
• As part of Spacewave: controller configuration with YAML/JSON

Spacewave can be extended with custom plugins or modifications to the client, and custom apps can use the libraries to directly access the data stored in your workspaces.

The current repository is a monorepo. The root app layer sits alongside the component directories:

• net/ - Bifrost
• db/ - Hydra
• bldr/ - Bldr
• forge/ - Forge
• auth/ - Auth
• identity/ - Identity
• app/, core/, sdk/, web/, cmd/ - the Spacewave application layer

Space: The Final Frontier

Let's take a moment to look far into the future. We're sending the first people to Mars. What OS are they using on their laptops and phones? What apps are they using to share files, collaborate, and communicate?

The latency of a one-way message from Mars to Earth varies between 2 to 24 minutes. HTTPs does not work with this much latency, and even begins to break with round-trip times over one second, let alone two minutes. Our existing internet apps would not work in this environment.

Spacewave solves this problem with a local-first p2p architecture. Regardless of internet latency or equipment failure, users can access their workspaces and apps, without the need for cloud, servers, or on-call engineers.

License

Spacewave is licensed under the permissive Apache-2.0 license.

All dependencies are verified to be equally permissive, one of:

• 0BSD
• Apache-2.0
• Apache-2.0 OR MIT
• BSD-2-Clause
• BSD-3-Clause
• CC0-1.0
• ISC
• MIT
• MPL-2.0

All of these licenses support commercial use, modification, and redistribution with attribution.

Support and Community

Spacewave is a community project to build the most powerful collaborative workspace and self-hosting tool.

We welcome contributions in the form of GitHub issues and pull requests.

Please open a GitHub issue with any questions / issues / suggestions.

... or feel free to reach out via Email or Discord!