WIMP: Windows, icons, menus, pointer. This is the interface paradigm we’ve been accustomed to since personal computing began. It was initially developed at Xerox PARC in the 1970s and made popular with the introduction of the Macintosh in 1984.

The first item in the acronym, “windows,” is defined as such:

A window runs a self-contained program, isolated from other programs that […] run at the same time in other windows.

From: Wikipedia

In developing the concepts for the operating system of the future, my work unintentionally — yet regularly — upends this notion of “windows running self-contained programs”.

Our lives are filled with digital “things” that are important to us:

Notes, tasks, lists, articles, events, emails, reminders, bookmarks, images, and so on…

These things all relate to each other in different ways. Yet they remain siloed in their own respective apps (one for notes, one for events, and so on).

But what if these things could be pulled out of the “window” that contains them and be brought somewhere else? What if you could move data items, with views provided by their hosting applications, around system and application views? What if we could bring together a series of things that all relate, even if they are of different types, and are from different apps or windows? What if you could browse your things in one fluid interface, without regard for their differing data types?

This is the first major principle in the operating system of the future that I’ve been researching and designing: Universal data portability.

All digital things are universally movable throughout the system. They may begin within a hosting application — a podcast episode within a podcasts app, a single charge within a bank statement, a note within a journal — but they can be pulled wherever the user wants them.

When you pull an item into some other place, it is still rendered by its hosting application. Hosting applications provide the view components for rendering data items in different situations or sizes. It can be thought of much like a widget in today’s operating systems: the system defines what the data item is and what size it should take up, then it relies on the data item’s hosting application to provide the view component that renders it.

Any data item in your system could be used anywhere you wanted.

Consider: you could pull an episode of a podcast into the top of your note as you jot down thoughts and ideas while you listen. You could pause and play the episode from right within that note because it isn’t a link to the podcast episode; it’s the episode itself, rendered by your podcast player of choice, within your note.

Or: say you are working on an email draft, but you need to put it away for a few hours to clear your thoughts, and you plan to return to it later in the day. You could pull that email draft right into your to do list for the day. Clicking it would immediately open the draft back up so you could continue your work.

Or: you could create a canvas upon which you arrange all of the resources you’ll need for a video conference during which your screen will be broadcast to all. Rather than fumbling through many different apps and windows for each resource, you’ll be able to organize the things you’ll need perfectly for the presentation, and you’ll be able to open each one inline — regardless of what data type it is (PDF, website, to do list, note, etc.).

With universal data portability, our operating system of the future becomes – in a sense – inverted, compared to today’s OS: the operating system makes use of interface components provided by the apps you choose to install. It allows you to use these components wherever you want to, creating a satisfyingly open and flexible environment for you to reflect your thinking and your workflows perfectly.

Increasingly, many of our things live in our computers. Universal data portability assists us by breaking our things out of their rigid containers.