A while back, I published this diagram to describe the different levels in the implementation of the CloudOS and show the relationship between the construction of a traditional OS and the CloudOS. This is more than an analogy; there is real parallelism.
Two open source projects, KRE and XDI, make up the kernel. Anyone can run them. (Note: for now, it's probably easier to just sign up for a free account on the service hosted by Kynetx. At this point the open source projects are not easy to set up—but it is possible. We're actively working on fixing this with more than one partner.) We are building out the required services and some basic applications. They are not yet available but alpha version should be usable by November. I'll be blogging about the services as we go.
The preceding diagram led to a question from a friend: "Where does the kernel run?" The flippant answer is "in the cloud." But that's a mighty big place. For example, does every personal cloud implement this entire stack from top to bottom? Is there an instance of the kernel for every personal cloud? Or is the kernel running centrally somewhere (say Kynetx) and everyone just uses that.
The answer is that neither of these two scenarios is correct. The real architecture is somewhere in the middle. The confusion comes from conflating the idea of a personal cloud with it's implementation.
A personal cloud is an extremely lightweight virtual machine. So lightweight that we can afford trillions of them—and in my plans we'll need trillions because we'll want every person, place, or thing to have one. Not just one personal cloud for each type of thing, but for each instance. Each person will control dozens, maybe hundreds. A large business might have control of many thousands and relationships will millions of personal clouds.
Because they're lightweight, virtual machines, there is a hosting level, where the infrastructure to run them lives and also a virtual level, that we think of as the personal clouds. The following diagram shows this:
In the hosting space are computers that run the software—the kernel—that implements the personal clouds for a hosting company, other institutions like banks and telcos, and even a self-hosted instance. Any given instance of the kernel can support many, many personal clouds. Institutions in the diagram are offering personal clouds to their customers. They may offer custom services or applications that make their distro of the CloudOS unique just as different Linux distros are unique and fit different needs even as they sit on an common kernel.
In the cloud space are the personal clouds that run on each host. A person might control personal clouds from many different providers, just like we have Websites in different places today. The fact that personal clouds are hosted in different places doesn't affect their ability to link to each other.
Note that the relationships are between personal clouds and not the hosts. Suppose you and your friend want to link your personal clouds. There's no need to your bank and your friend's hosting company to cooperate for that to happen.
As I envision them, personal clouds mirror exactly the architecture of the Web on which they're based. They are decentralized and independent. Even so, they linkable through an open standard. This idea is critical because it gets us out of the world that Web 2.0 built, where customers are given great functionality, but in Web-hosted applications that are very unlike the Web. Web 2.0 applications cannot be linked by users and don't generally work together. APIs aren't enough, as companies like IFTTT have found out in dealing with Twitter.
For now, Kynetx is hosting an instance of the kernel upon which personal clouds can be hosted and the CloudOS can be run. We are working with two partners on getting other instances of the multi-homed kernel running. The hearty can host their own. And each of the clouds hosted on these various instances will be completely able to work with each other. The deployment strategy for personal clouds, aligns with the architecture of the Web: decentralized and open.