StudyTime – A Decentralized MOOC Platform

In 2016, Coursera, one of the leading providers of massive open online courses (MOOC), decided to remove several less popular courses from their site because they weren’t profitable enough to maintain. One of my core beliefs is education should be open and free; anyone that has the passion to learn should be able to regardless of their income, background or location. Unfortunately, when education meets capitalism, those with capital decide what courses live and die while those with a passion for learning miss out.

When Coursera announced they were taking these courses offline I started looking around for a MOOC platform that would host them instead. While many of these courses found their way onto, and other less legitimate places, these are zips of individual PDF’s and videos, not all-encompassing experiences like Coursera’s classes.

Instead of a centralized service that can increase prices or delete courses at any time, what if we built a decentralized app that anyone can use to explore license-free MOOC’s? They’d never have to worry about a course being taken down or censored, because it can be streamed from anyone else on the network.

Let’s explore the design of a hypothetical application – StudyTime – to illustrate this idea. This is a design document for an application that doesn’t yet exist, but is possible to build.

StudyTime Design Document

StudyTime is an application for viewing and interacting with MOOC’s that runs on Secure Scuttlebutt (SSB). It works by streaming all metadata for courses from the SSB network via SSB Feeds. All non-text content is loaded via SSB blobs, though it can also be made available on other distributed systems such as Sia or Torrents. Because all data is stored locally and mirrored to other clients, the network is self-sustaining as long as it has users.

The application creates its own private SSB key and feed upon first load. Anything that needs to be persisted, such as enrolled courses, course progress, personal notes, friends, etc., is stored in this feed. More interaction between students, such as forums or comparing results between a class, could be added over time using the same back-end and user feeds. Implementing these features would require a lot of thought around moderation and handling spam or trolls and, as such, is out of scope for this design.

User Interface

Upon opening StudyTime you are presented with a list of possible subjects to choose from, grouped into major categories with the most popular subjects given higher priority. This could look similar to the homepage for Class Central:

Screenshot from Class Central Homepage – select subject section.

After selecting a category you’re taken to a search page where you can explore all courses tagged with this category. All searching and filtering is done client side.

Screenshot from Class Central – Select Course page

When selecting a course, you’re taken to a course overview page that consists of the course description, estimated duration, a button to start that course, etc.. 

Screenshot from Class Central – Course Overview page

Most of this front-end design can be based off existing MOOC sites. It’s the back-end of this application that is really interesting.

Back-end Implementation

First, there is one or more course list feeds. Each course in the feed has the type studytime_course. Each course item includes a name, description, keywords, and feed ID. One course list feed ID is hard-coded into the application and is downloaded or updated upon opening the application. Because the course list feed is the primary data source and only one person can add items to the feed, having a hard coded feed creates centralization. The application should not be centralized in any way, so to fix this users will be able to change the course list feed to one created by someone else. Users can load multiple course list feeds (perhaps MOOC providers could release their own StudyTime feeds), and the application will load the courses listed in each. If a course exists in multiple feeds it will be de-duplicated by feed_id and the metadata for the first version found will be displayed in the app. 

Here’s what an item in a course list feed looks like:

    author: '@masterfeed.ed25519',
    content: {
        type: 'studytime_course',
        name: 'Python Essentials',
        image: '%c7ZAvQRoEP/zXnXgTnkGafP1JSEV29V8G/+Hhk8lSWU=.sha256', 
        description: '',
        keywords: ['python', 'beginners programming', 'computer science'],
        feed_id: 'Pyth0NEsential5.ed25519' // Scuttlebutt feed containing the course's lessons, videos, etc

While the user is browsing, StudyTime downloads the course feeds in the background, so there is little delay when opening a course. The courses will be grouped into categories client-side. Users can search, sort, and filter client-side using the name, description and keywords. 

Each course has its own feed, where the author_id is the feed_id in the master feed. Each course feed contains the course content; the lessons and tests it contains, as well as hashes of all the images and videos in the course. When you view an image or video, StudyTime will request it from the SSB network then stream it from other peers who have a local copy. After an image or video is downloaded, the client will automatically share it with other peers to keep the network highly available. Here’s what a course feed looks like:

    author: '@Pyth0NEsential5.ed25519',
    content: {
        type: 'studytime_course_lesson',
        lesson_number: 1,
        name: 'Week 1 - How to install python',
        description: 'This lesson will teach you how to setup Python on your PC',
        lesson_content: 'In this lesson we will learn about installing python...'
    author: '@Pyth0NEsential5.ed25519',
    content: {
        type: 'studytime_course_lesson_video,
        lesson_number: 1
        name: 'Week 1 Video 1',
        description: 'How to install Python',
        sources: [
    author: '@Pyth0NEsential5.ed25519',
    content: {
        type: 'studytime_course_lesson',
        lesson_number: 2,
        name: 'Week 2 - Hello World',
        description: 'This lesson will teach you the basics of python programming',
        lesson_content: 'First lets run ipython with the following command:\n`ipython`...'

The front-end uses these feeds to render the course contents and lesson pages, downloading required non-text content as users progress. It pre-fetches all course content in the background after starting a course, so users don’t have to pause at the beginning of each lesson. While browsing through courses, users can navigate quickly as the application is only rendering local data from the feeds.

Updating and Improving Courses

Over time courses may become out-of-date and need to be improved, edited or deprecated. SSB feeds are immutable append-only feeds, so the only way to make changes is via adding messages. A message type studytime_course_update is used to make these updates. Here’s an example of how the Python Essentials course above can be updated:

    author: '@masterfeed.ed25519',
    content: {
        type: 'studytime_course_update',
        feed_id: 'Pyth0NEsential5.ed25519'
        name: 'Python 2.7 Essentials',
        keywords: [],
        deprecated: true,

This update renames the course to Python 2.7 Essentials, and sets a deprecated flag. StudyTime hides all deprecated courses by default, but could have a “Show Deprecated” option for users that want to see them.

Similarly, course lessons can be updated with a studytime_course_lesson_update message, which contains a new name, description or lesson_content. The lessons will use the latest content when rendering.

Why build this on Scuttlebutt?

Scuttlebutt has a few advantages over building a traditional application with servers:

  • The creator doesn’t need to raise money or take down “unprofitable” content to keep the application running, because the community runs it with their collective computing and networking power. 
  • Provided there are enough users, the application should never go offline, as users are constantly sharing feed data with each other.  Because the content is being mirrored so many times, you will always be able to find a feed. Exceptions include images and video, which are harder to keep constantly mirrored, as they are only downloaded by the people that take a course. As a remedy, these images and videos could be mirrored to a service such as Sia or even S3 as a fallback. 
  • Content cannot be censored or deleted by authorities.

These rules apply to any decentralized application built on Scuttlebutt. I am particularly excited about the first, because there are so many free websites I’ve loved that have closed down over the years simply due to lack of money. If the community supported them with bandwidth and computing power instead, they would last as long as they still have fans.

What are the drawbacks of using Scuttlebutt?

The downsides to using Scuttlebutt rather than centralized servers are mostly constrained to the initial release of the application:

  • If there are very few users online it may take a while to find and stream lesson content.
  • The developers of StudyTime may need to mirror most of the content until at least a few people have taken every course and are actively seeding the content. 
  • SSB feeds cannot be changed, so there is no way to remove content once it’s been added. While it can be marked as deprecated/deleted so the application can hide it client-side, users will always have the information. 

I hope someone either takes this idea and runs with it or becomes inspired by the potential this network brings. There are so many similar problems in many industries that could be saved with a decentralized back-end like Scuttlebutt.


A Decentralized Platform for Innovation

In what is scuttlebutt I discussed why Scuttlebutt can be a better social network than anything else out there. However, it can be so much more. It can be a decentralized platform that any application can be built on top of and immediately become peer-to-peer.

Under the hood, Scuttlebutt messages are just JSON data. Here’s what a normal text post looks like (simplified, additional metadata omitted for clarity):

    author: '@Py8stqMfjhdc4Ln92R4Lg+3jITszP94G3P5BNuH+lWY=.ed25519',
    content: {
        type: 'post',
        channel: 'new-people',
        text: 'Hello World!'

And here’s what a vote looks like:

    author: '@Py8stqMfjhdc4Ln92R4Lg+3jITszP94G3P5BNuH+lWY=.ed25519',
    content: {
        type: 'vote',
        vote: {
            link: '%c7ZAvQXoDP/zXnXgTnkGatP1JSAV29V8G/+Hhk8lSWU=.sha256',
            value: 1,
            expression: 'Like'

Notice how the content sections of the post and vote are different? The only thing that is similar is the “type”, meaning the content section can be filled with anything you like. Different applications can send their own messages with their own ‘type’ and information, and clients that understand that type can display the information in a way that makes sense. 

For example, you could build a chess application which sends content like:

    author: '@Py8stqMfjhdc4Ln92R4Lg+3jITszP94G3P5BNuH+lWY=.ed25519',
    content: {
        type: 'chess_move',
        game: '%c7ZAvQXoRP/zXnXgTnkGatP1JSAV29V8G/+Hhk8lSWU=.sha256',
        move: 'Qe4'

This data is then sent along the Scuttlebutt network where any of your friends who have a chess client that can read the type “chess_move” can see that you’ve made the move “Qe4” which in Portable Game Notation means you moved a queen to e4. You could even play games of chess with people with other chess applications, as long as they can process this “chess_move” type. In fact someone has already built a ssb-chess backend that runs on Scuttlebutt and you can play it today

Because everything is open source and you don’t need permission to join the network, you’re free to innovate as your heart desires. You can build any kind of application using Scuttlebutt as a network layer, and it’ll be decentralized and usable by anyone else on the network right out of the box. 

For instance, someone could build an Instagram-like application that connects to Scuttlebutt, and shows all content of type ‘image’. Someone else could build a Twitter-like application that only displays text posts of less than 280 characters. These applications will talk on the same network as Patchwork, Manyverse, Patchfox, etc., and you can interact with friends using different applications seamlessly. 

This means that you are free to choose the social application you use while still being able to connect to your friends on the same network. What if the developers of Patchwork do something you hate, like add sponsored content, rearrange the feed order, or make it neon orange and green for a real 90’s flair? Instead of being forced to “deal with it” like you are with Facebook or Twitter, you can simply download an alternative application like Manyverse or Patchfox and continue talking to all your friends with the same content. If you’re a programmer, you can even fork Patchwork, or create your own client from scratch just the way you like it. The application you use to view the world may constantly change, but the underlying data always remains the same. 

This would allow Scuttlebutt to live on for decades or even centuries. Social clients may evolve and change over time just as they do now. People will build applications which will grow and die on it. But the underlying data remains the same, and you’ll never need to take your entire social world with you when switching clients again. 

That’s what I love about the potential of Scuttlebutt. It’s not just freedom from corporate control, it’s freedom from anyone telling you what to do and how to interact with your friends. It’s freedom form the invisible hand nudging you to do things others want you to do, like clicking on ads or using their new live streaming product. 

Remember AOL versus the Internet back in the 90’s? Initially everyone loved AOL as it was this beautiful walled garden that gave them news and information and games. But then the internet came along with infinite possibilities; a decentralized world where anyone can create and share and build what they like! It provided so much more utility and freedom that everyone flocked to it. That’s how I see Scuttlebutt today, the free alternative to the social media companies that only seem to be tightening their grip on their user-base, building a bigger wall around their garden every day. 


What is Scuttlebutt?

As mentioned in Why Decentralization, a big focus of this site is the technologies that will make a decentralized world possible. Scuttlebutt is one I’m most excited about because it has a usable social network, and more applications can be built on it for free, without permission, by anyone. 

Scuttlebutt solves multiple problems plaguing the social networking world:

  • One company having control over and access to everything people do and say on the network
  • AI algorithms sorting your timeline to decide what you should read, taking control away from you
  • Ads and the ability for companies to purchase attention, shoving themselves into your personal social timeline
  • That people have to have one profile tied to their real self 

Technically Scuttlebutt isn’t a social network, it’s a system for building any kind of decentralized application, but explaining it in the context of a social network helps. Later I’ll be explaining how it has the potential to be so much more than this.

Scuttlebutt – the social network

Decentralized, open-source social networks have been tried before, the two most well known are Diaspora and Mastadon. With these services there are still servers that people gather around, so if you want an account you have to find a server and register for it. There is still moderation, there is still federation (you have to register an account, and you can get banned) and there are a few central points of failure (the servers themselves). While these networks are a great first step away from centralized corporate-controlled networks (I like them and will be exploring them in more depth soon), Scuttlebutt is how I believe the social web should function in the future.  

Scuttlebutt’s fundamental difference is it is fully decentralized. Scuttlebutt is completely peer to peer, meaning there are no central servers that you connect to, and no one manages or controls the network. You don’t use a website to view Scuttlebutt, instead you download a client to your computer. When you use a client, like Patchwork, it talks directly to your friends over the internet. When you make a post it gets sent to all your friends, so they have a local copy of it. If a friend comes online while you’re offline, their client will automatically download your post/s from your mutual friends. Messages can spread between people constantly without everyone always needing to be online, just like the real world. 

Patchwork Screenshot
Patchwork – A Scuttlebutt client

When you download Patchwork and run it on your PC it’s initially empty, because you don’t know anyone and don’t know how to connect to anyone. You’ll notice you only need to enter a name, picture and description, there is no signup form. Why? Because Scuttlebutt has no central service to register with. You can be anyone you like, and no one can tell you otherwise. Instead of having a registration service Scuttlebutt creates a private key on your computer. This key is used to prove you are who you say you are to your friends, so that no one can impersonate you, and it’s controlled by you alone. 

To begin you should connect to a “pub” with an invite code. A “pub” is a super-friend on the Scuttlebutt network who makes friends with everyone. Pubs are just like normal users except that they’re almost always online, identify as pubs, and will friend you automatically when you redeem an invite code. After you redeem an invite you become friends and can start downloading information about its other friends, their friends, and those people’s friends (3 degrees of separation). These pub servers are mostly run by Scuttlebutt developers. Connecting to a pub doesn’t restrict your network in any way, as they are just super-friends, not central servers. 

While connecting to a pub isn’t required, until you have a few friends it’s worthwhile friending one. For one, pubs are almost always online, so whenever you come online you get all the latest gossip, instead of having to wait for friends to login. Second, pubs can help you discover more people, as you can communicate with anyone up to 6 degrees of separation away (3 degrees in each direction), and pubs are connected to other pubs, so they connect you to the whole Scuttlebutt universe.

Once you’ve downloaded the local gossip from the pub, you’ll see you now have a social feed in Patchwork. This feed is comprised of everything your friends are up to (of which you have 1 right now, the pub) and everything their friends are up to (2 degrees out). Though your client has information about people 3 degrees out for network redundancy purposes, you don’t see them in your feed by default. You can see them under the “extended network” menu option in Patchwork. So now you are connected to all these random people, what do you do? First I’d recommend checking out some of the hashtags/topics which you can see on the left, and subscribe to some that you find interesting. Once you’re subscribed to some topics you’ll see every post from everyone you know about that includes that hashtag.

 You can then follow others who have similar interests to you and post anything you like to the network. Have fun out there! If you want to follow me my ID is: @Py8stqMfjhdc4Ln92R4Lg+3jITszP94G3P5BNuH+lWY=.ed25519