Composable Software: Why I'm Building CoCube

Every tool I used made me choose between flexibility and reliability. Emacs gave me flexibility and broke constantly. Notion gave me reliability and held my data hostage. CoCube exists because I refused to keep choosing.

What composable software means

Composable software is built from independent pieces you can take apart, rearrange, and combine into something new. Instead of a fixed application with a fixed set of features, you get building blocks. Each block does one thing, and you connect them however you want.

Most software doesn't work this way. You get a product with a specific set of capabilities, and if what you need falls outside that set, you're stuck. You file a feature request, wait, and switch to a competitor in the meantime.

Composable software flips this. You don't wait for features, you build them. You take something someone else built and modify it to fit your situation. The system adapts to how you think, not the other way around.

CoCube is built from the ground up around this idea. Every component can be deconstructed, modified, and recombined. A button is a tree of reactive nodes with cells that define its width, color, and behavior. Don't like how it works? Change the cells. Want something that doesn't exist yet? Compose it from the pieces that do.

The principles behind composable tools

Building composable software isn't about modularity alone. It's about getting the foundations right so that flexibility doesn't come at the cost of stability.

The user owns the data. Your data is always stored locally and can be painlessly exported. CoCube is built local-first, meaning your device is the source of truth, not a server. If CoCube disappeared tomorrow, your data would still be on your machine.

Soundness over cleverness. Functional programming, declarative definitions, and strong type systems make composable systems reliable. When you modify a component, you shouldn't feel anxious about breaking something. The system tells you when something doesn't fit.

A high skill ceiling. CoCube should feel like an instrument, not a toy. Editing, traversing, building, and viewing data should require little more than thinking of what you want to do next. A Steinway, not a kazoo.

Performance that induces flow. Composable software falls apart if interactions feel sluggish. Every action in CoCube targets 10ms or less, with full keyboard navigation and zero loading screens. The goal is to eliminate the time it takes to "get in position to think."

Fundamentally searchable. Finding what you've done before is as important as producing the next thing. Building CoCube to be local-first means all your data lives on your device, which opens the door to extremely fast search.

Always collaborative. Composable components are meant to be shared. CoCube uses CRDTs for conflict-free real-time collaboration, so anything you build can be used and modified by the people you work with.

Who needs composable software

If any of these sound familiar, composable software is worth your attention.

• You've tried popular platforms but felt limited by their inflexibility.
• You value local-first design but want a modern UI with it.
• You've tried niche or open-source solutions but spent too much time maintaining your system.
• You want to invest in creating personalized tools but don't have time to build from scratch.
• You don't want to deal with HTML, CSS, or JS.
• You want your system to work when you need to share and collaborate.
• You have a capable computer with a GPU that sits idle all day, and you're tired of slow web-based tools.

This is a small group, and CoCube is being built for them specifically. The goal isn't to compete with general productivity tools. It's to create a medium where people who care about their tools can build something that fits their work perfectly and share it with the people around them.

What's next

CoCube is focused on making the reactive cell and node system feel right for building collaborative knowledge bases. Rich text editing, custom component types, and local-first data sync. If any of this resonates, give it a try.