✩ Let's Take Back The Net! ✩
Spritely is building the next generation of decentralized networking technology.
We deserve social networks which respect our agency and autonomy. Communities deserve the right to organize, govern, and protect and enrich their members. All of these are natural outgrowths of applying the principles of fundamental human rights to networked systems.
Spritely builds on our experience co-authoring ActivityPub, the largest decentralized social network on the web to date, while applying powerful ideas from object capability security research.
Better worlds await, because better worlds are possible. Let's build a healthier and safer network together!
Follow us: [fediverse] [bluesky]
IRC chat: #spritely on libera.chat
✩ About Our Tech ✩
It's hard to build the kind of vision Spritely is envisioning on top of contemporary tech. Because of this, Spritely is taking a multi-layer approach!
Goblins: distributed programming made fun
Goblins is the foundation of the rest of Spritely's tech and makes building distributed and capability-secure programs easy and fun:
- Easy and secure networked programming: Programs you write in Goblins automatically are ready to work over the network and Goblins' security model looks like ordinary programming.
- Automatic persistence: Goblins comes with a persistence framework so you can focus on writing out your programs; most of the time, Goblins can take care of the rest of saving data to storage for you!
- Transactions: Goblins is fully and automatically locally transactional: state changes are rolled back automatically upon error at no extra cost.
- Time traveling debugger: Goblins' time traveling debugger lets you debug your program in the state that it was in when the error occured, and can even create visualizations of what created the problem! Only keep as much history as you need: Goblins is happy to clean up any state not needed for debugging!
- And much more! Goblins supports distributed garbage collection, promise pipelining for efficient networked communication, a standard library of common actor types, and much more!
Hoot: Scheme to WebAssembly
Hoot is Spritely's Scheme-to-WebAssembly compiler and all-around WebAssembly toolkit. Hoot was designed to allow Spritely's tools to run in the browser and reach a wider audience. However Hoot is generally powerful and useful for building Scheme projects on the web.
But that's not all! In addition to being a Scheme-to-WebAssembly compiler, Hoot also features WebAssembly assembler and disassembler tools... and even a WebAssembly interpreter for developers! If you're thinking of making your own custom WebAssembly language or even just want to learn how WebAssembly works, Hoot might be just what you want!
OCapN: the Object Capability Network
OCapN, the Object Capability Network, is the suite of protocols that gives Goblins its networked programming superpowers. OCapN's CapTP gives fine-grained capability programming over the network, distributed garbage collection, promise pipelining to avoid extra network round-trips, and introductions and smooth communication between peers as appropriate. OCapN's netlayers allow layering OCapN to run on top of a variety of network substrates including Tor Onion Services, libp2p, TCP+TLS, and perhaps some day carrier pigeons wearing encrypted microsd card backpacks.
OCapN's proto-standardization efforts are a joint project between multiple groups such as Spritely, Agoric, Metamask, and Sandstorm. Spritely took leadership in drafting the first versions of OCapN's specifications, extrapolating first from Goblins' implementation of the protocol, then working to bridge across the protocol needs of the participants of the group. OCapN builds on a long history of networked capability research, most prominently from the E programming language.
✩ Read our Whitepapers ✩
The Spritely Institute is a 501(c)(3) nonprofit and research institution built to develop new technologies for the decentralized web. All code we release is free and open source software and all papers we write are open access under free cultural licenses.
- A Scheme Primer
A primer for the Scheme family of programming lanuages. It was originally written to aid newcomers to technology being developed at The Spritely Institute, but it is designed to be general enough to be readable by anyone who is interested in Scheme.
Formats: html | pdf | org - The Heart of Spritely: Distributed Objects and Capability Security
This paper details the core technical toolbox provided by Spritely Goblins and how it supplies the necessary features to make building peer-to-peer applications as natural as any other programming model.
Formats: html | scheme pdf | wisp pdf | org - Petnames: A humane approach to secure, decentralized naming
Names must be human-readable in order to be widely used. Unfortunately, while DIDs and Tor .onion addresses are decentralized and globally unique, they are not human readable. How can we build user interfaces that real users might actually use? In this paper we provide an overview of petname systems, a way of mapping human readable names to cryptographically secure names.
Formats: html | pdf | org - Implementation of a Petnames System in an existing chat application
In this paper, which builds off of the Petnames paper, we present our experiences from implementing a petname system for an existing chat application. We introduce the necessary mechanisms to retroactively introduce a petname system, the solutions provided, and future expected work.
Formats: html | pdf | org - Content Addressed Descriptors and Interfaces
This paper presents an example implementation of a way for programs to describe themselves to each other and to users in a decentralized system. Making use of a simple petname system, content-addressed descriptors and interfaces can allow multiple parties to agree on what a particular term means without prior context. This understanding can be distributed without a centralized naming authority. This paper also describes some of the necessary design considerations when using CADs in a mutually suspicious network.
Formats: html | pdf | org
✩ News! ✩
Functional hash tables explained
Prologue: The quest for a functional hash table for Goblins
For those of us that use the Lisp family of programming languages, we have much appreciation for the humble pair. Using pairs, we can construct singly-linked lists and key/value mappings called association lists. Lists built from pairs have the pleasant property of being immutable (if you abstain from using setters!) and persistent: extending a list with a new element creates a new list that shares all the data from the original list. Adding to a list is a constant time operation, but lookup is linear time. Thus, lists are not appropriate when we need constant time lookup. For that, we need hash tables.
Hoot 0.6.1 released!
Announcing Spritely Oaken
Successful supporter drive supplements Spritely's story
The Spritely team is overjoyed by the support we've received in our first ever supporter drive. More than just donations, these are individual voices which inspire us to deliver on our promise of a more secure future.
Spritely Goblins v0.15.1 released!
We are happy to announce the release of Goblins 0.15.1! This patch release includes many bug fixes, documentation fixes, and quality-of-life improvements made since the 0.15.0 release back in January.
Spritely Goblins v0.15.0: Goblins in the browser!
Guile Hoot 0.6.0 released!
Spritely is going to Guix Days and FOSDEM
Later this month, the entire development team at Spritely will be heading to Brussels to attend Guix Days and FOSDEM! We are all excited to take part in these conferences. They are a great opportunity for networking and sharing ideas, and I fully expect it will be a lovely time as well.
Supporter drive goal complete! Time for a stretch goal!
Over the weekend Spritely marked a major milestone: we reached our goal for our very first supporter drive! With your help we managed to surpass our $80,000 USD goal with three weeks to go!