Roomy Chat Alpha 2
The roomy.chat demo is back online!
Roomy is an Open Source group chat app that integrates with Bluesky and the AT Protocol. You can join our Roomy chat space to come say hi, or you can even make your own chat space.
For a quick video intro to Roomy, check out zeu's talk "Message Gardening in the Atmosphere", performed a week ago at the epic ATmosphere Conference!
Further reading:
In today's post I'm going cover the state of Roomy: what it's doing right now, how it's working, and some of the ideas we've got for next steps.
Features
Themes
The first obvious new feature we've got is themes! @zeu.dev hooked up a theme system from Daisy UI so now we have a bunch of built-in themes you can select from.
On top of that, Daisy has a theme creator that you'll be able to use to create your own themes soon.
Rich Text Input
We've also gotten a first pass on the rich text input field. This allows us to do things like render @mentions and #channel references.
That said we still have some work to do on the rich text editor, and we lost features like links & images in the refactor, so we'll be re-adding those as soon as we can.
Space Domains
You can now setup a custom handle for spaces by using domains, just like you do if you have a custom BlueSky handle!
In short this lets you go from:
- Before:
https://roomy.chat/leaf:3gv98mf2b4psk6183cx3yv9p4gh62pgx6thesmnhx3gjq8w7dm70 - After:
https://roomy.chat/-/example.com
(Wiki) Pages
We also added a first pass on "Wiki pages", though in a subsequent iteration they'll be relabeled as just "Pages". Alongside our index and sidebar, the design for pages in Roomy is going to evolve quite a bit, but for now we have a simple setup where anybody can create an edit pages.
These pages are not "collaborative" in real-time, and if two people are editing the page at one time, it won't merge their changes: whoever saves last will overwrite the other persons edits. This is something we will improve in the future and eventually you'll be able to see each-other's edits in realtime.
General UI Improvements
There have also been lots of little UI improvements, as well as underlying improvements to the way things are organized so that it's easier for us to continue working on new features in the UI.
Removed Direct Messages
We have also removed direct messages for now. Direct messages were an early feature we made to test our our synchronization since syncing with only one other person made it easier to work on at first.
Now that we've gotten going, though, direct messages are really not the feature we are prioritizing for Roomy; public, forum-like community spaces is our first goal, and Bluesky already has working direct messages and is working with the community to figure out E2EE alongside pioneers like Germ Network.
Removing direct messages makes it easier for us to focus on other features and lets us move faster.
Invisible Changes
On top of the UI improvements, there has been a lot changing under-the-hood for Roomy. We now have our very own Roomy SDK, we're using a different CRDT, and we have an extremely useful new data model.
Here I'll go over some tech details. Feel free to skip to Summary of Current State & Next Plans if you aren't as interested in this bit.
Loro CRDT
The first change is that we are now using the Loro CRDT instead of Automerge.
The first reason was while doing some benchmarking we found that Loro could load a large document storing many IDs much faster than Automerge ( for now ). Loro is able to store the latest state of the document and then lazily load the history if you need it, which fits our future CRDT to webpage rendering needs very well.
Loro also has some useful features like movable lists and trees which we will have use for in Roomy.
To be clear, Automerge and the people who make it are awesome! They are also making tons of performance improvements on Automerge right now. We are designing things to be relatively CRDT agnostic, and we aren't totally bought into anything specific yet so things could change in the future.
Leaf SDK
On top of Loro we finished our first pass for the Leaf SDK.
Leaf, or the "Leaf Protocol", is an idea that we've had in mind for a while now as we've worked on Weird. Leaf is an opinionated framework for building offline-capable apps with great sharing and collaboration features. It's the foundational "database" that we are building Roomy on top of.
Our ideas for Leaf have evolved quite a bit recently and giving an overview of it is going to take its own blog post which I'll have to write later.
For now it's good enough to understand that Leaf is our "database" and is used to store and sync Roomy data.
This first version of Leaf doesn't have the solid permissions and capability system that we have planned for it. That will be powered by Keyhive, an awesome new library by the Automerge (Ink & Switch) folks. Keyhive isn't ready to use just yet so we're continuing on with partial features until that is ready for us to integrate with Leaf.
Roomy SDK
On top of our new Leaf SDK we built the Roomy SDK!
The Roomy SDK is like the library version of Roomy. It's a way to interact with all of the Roomy data through code, without the UI. The UI uses the Roomy SDK to do everything that it does.
This is super great because it means that other people will be able to make their own apps that integrate with Roomy. They could even make their own Roomy UI. Maybe someone could make a terminal UI for Roomy? 👀
The New Data Model
The major importance of the new SDKs is that it allows us to finally start using the Entity-Component data model that we've been looking forward to.
This data model was something that I started thinking about for building inter-operable web apps 10 months ago in A Web of Data. The hope is to provide a very fluid, but still structured, data model that we can use to allow apps to read and write data while still being incrementally compatible with each-other.
The Entity-Component model says that everything, no matter what it is, is an entity with its own ID, and all of that entity's data is stored in components. These components are standardized similar to ATProto Lexicons, but because an entity can have multiple of them, it allows multiple different apps to attach their own data to the same entity. It also allows apps to partially understand an entity, and interact with it even if it doesn't understand all of its components.
This concept is so powerful for enabling Roomy's content gardening and fluidity features.
It's because of this Entity-Component model that you are going to be able to convert threads to channels and vice-versa seamlessly. It can allow you to do things like attach a Roomy thread to a wiki page or anything else so that you can chat about it.
Things like wiki pages, notes, chat spaces, threads, they are all just another entity, and they actually share a lot in common. All of them have names and possibly an icon / profile image, or a description. Both channels and threads have a timeline of chat messages. These common components act as interfaces that make it very easy to interact entities in code.
These entities can also be linked to each-other to create a rich web of information that doesn't impose a pre-defined structure, limiting the data and isolating it to wherever you put it first.
With the new model, we will be able to very easily implement "federated channels", i.e. a channel that exists simultaneously in two different chat spaces! All it takes is two chat spaces that link to the same channel entity.
Summary of Current State & Next Plans
So at this point we've got improved UI and a new data backend, but we've still got a ton of work to do!
Roomy is still in Alpha. That means that basically anything might be critically broken. Also, all data is completely public. Don't put anything in there you don't want the whole world to see. Roomy is relatively insecure while we wait for the Keyhive capability system that we are planning on using to get to a testable state.
That said, we are doing our best now to keep the chat spaces you create up and we have some best-effort backups to protect against data loss.
There are lots rough edges to polish and we'll be tackling that bit by bit.
Some of the things that we're thinking about working on soon:
- Stress testing to make sure that we can handle 10s of thousands of messages in channels.
- Experimenting with Discord bridging.
- Making chat rooms and pages web indexable.
- Letting you use your own domain to access Roomy, so you can allow people to chat directly under your own website, like
chat.example.org. - Publishing websites from your Roomy wiki pages.
I'm super excited for what's coming up!
If you got any questions feel free to ping me @zicklag.dev on Bluesky!