Local-First Software is the Completion of the PC Revolution

Apple’s Promise

On January 22th, 1984, during Super Bowl XVIII, Apple made a promise to the world: that by introducing the Macintosh personal computer, “1984 won’t be like ‘1984’”.

Directed by Ridley Scott of Alien and Blade Runner fame, humans in this film are stripped of any sense of individuality, heads shaved, draped in oversized prison uniforms designed to never fit, existing in an artificial megastructure where the sun never reaches and no distinction can exist between light and darkness. Marching like ants to gather for communal indoctrination, the familiar face of Big Brother is projected onto the bare concrete of the far wall, larger even than the edges of the screen, to remind everyone of the superiority of collectivism, the benefits of strictly scheduled, lock-step coordination, and the ease of life that comes without needing to think for oneself.

Amidst the toxic fumes and virtually colorless surroundings appears our heroine, sprinting towards the theater, an Olympian holding a sledge hammer, clad in form-fitting red shorts and a bright white tank-top that displays a large, mysterious, hand-drawn emblem. With a squad of fully-armored riot police in close pursuit, she enters the theater and begins to spin in place, gathering momentum quickly, while Big Brother continues his speech reminding everyone of the enemies that lie behind every corner and the need to remain united in “one resolve, one cause”, and in other words “one mind”.

As the riot police arrive it is too late, the hammer is already flying through the air as if thrown by Thor himself, demolishing the screen and wall behind it, causing everything to explode into light. Like the opening of a window for the mind, a look of astonishment sweeps across the crowd of thought-prisoners for the first time, rays of hope shining and the winds of inspiration blowing away the darkness and fog of the previous paradigm.

A Brief History

Most American homes in 1984 still did not own any kind of computer, and most computing was provided by institutional resources such as in corporate offices or on university campuses. Computing terminals were usually text-based, providing only a keyboard, a disk slot for portable storage, and a network connection to access time-shared resources such as scheduled processing or persistent network storage through a centralized server. In many ways the pre-PC era was very similar to how cloud computing works today, with all of the same restrictions: software is delivered as a service over a network connection, processing happens remotely “out there”, and your data lives on someone else’s computer where privacy is an afterthought at best.

But just as in the days before the launch of the Macintosh, today’s computer users are familiar with the total costs of impersonal computing controlled by 3rd-parties:

• Managing passwords and proving identity are a hassle, most users just want to launch their apps without obstacles, while their ideas are fresh.

• Lack of Data Privacy: Any data uploaded to the cloud can never be proven to remain private (unless it uses client-side encryption). Even worse, it gets used for surveillance advertising, sold to 3rd-parties, and fed to machine learning models to be shared with the world or used to target you without asking.

• Remotely-hosted programs struggle to provide real-time responsiveness. Just ask any player of online video games: nothing is as infuriating as lag, and this only gets worse when using wireless networks, cordless peripherals, or mobile connectivity.

• Since centrally-hosted software requires sharing resources among all users, the more popular cloud software becomes, the more difficult it becomes to scale the resources needed to host it. As Moore’s 2nd Law begins to increase in relevance, there will always be countervailing forces attempting to minimize costs-per-user for hosts while clients expect ever-improving performance, leading to a permanent tension between these forces and a gradual reduction of quality for end-users.

Everything Old is New Again

Just like at the dawn of the PC revolution, we now have the opportunity to take back control of our own data and computing capabilities for ourselves, but this time without giving up the advantages the cloud provided, by using and developing local-first software combined with distributed networking. This is software that meets, at minimum, the following properties:

• Local-first software should perform as fast as a locally-installed application, and user input should never lag because of the state of the network. Don’t send keystrokes to remote servers and wait for a reply before updating the program state on the screen.

• Secure and Private by Default. Local-first software should be trustworthy for data at rest, and for data in motion, by using encryption and secure design.

• Software that runs with or without a network connection at all times. Features dependent on the network resume when connectivity resumes.

• Data and state synchronization features are eventually-consistent, and can be distributed across multiple devices as needed.

• End-user Data Sovereignty. No tracking, no leaking, no surveillance, and certainly no selling of user data. Privacy needs to be respected at all times.

• Compatible Data Formats. It should be easy to understand, easy to extend, and easy to maintain local-first data formats.

• Design for collaboration. Multiple updates to a shared object need to resolve in a predictable manner, and not lead to deadlocks.

How Rana Fulfills the PC Revolution Promise

While technically there is no strong requirement for local-first software to use web technologies, there are many advantages to doing so, and so we have chosen to build the Rana ecosystem using the latest web standards as a way to make our software universally available across all platforms and device types. Built as a Progressive Web Application (PWA) on the LoVGUN Stack, here is how the Rana ecosystem supports local-first principles:

• RanaEngine runs completely locally on the browser of your choice, on both desktop and mobile, regardless of the operating system. If WebGPU support is detected along with sufficient video RAM, then the node can operate as an AI/ML compute node in a user’s Rana Cluster.

• All persistent data is encrypted and stored locally in browser storage, and can be synchronized to any other Rana Node that a user controls automatically. It is never transferred to the Rana Cloud unless requested by a user, and will remain encrypted at all times to protect both parties.

• All data is stored using JSON formats, for ease of compatibility and integration with other software and to ensure legibility for the future.

• RanaEngine uses peer-to-peer (P2P) networking in order to send data between nodes, and only relies on relay servers to perform initial handshake connections. No data is transferred through relay servers, and all end-user data remains private and encrypted.

• Rana’s Cloud features are optional, and non-cloud features will continue to function regardless of connectivity status.

All of this allows us to provide a first-class experience while also respecting the privacy of end-users as well. Anonymous users are welcome to use Rana on their own devices for non-commercial purposes, and to create clusters of any size with any number of nodes to make the most of local AI, democratizing the power of AI supercomputing for all users, for free, on the hardware they already own.

Conclusion

It has been said of traditional cloud software that “if you aren’t paying for the product, you are the product” but local-first software flips this claim around: “local-first software ensures that you and your data are never the product”. By designing software to respect end-user data sovereignty and adhere to local-first principles, developers can fulfill the promises of the PC revolution while also ensuring universal compatibility of their software for the future across all platforms and devices. I hope you will join us in building a better future for software, one the fulfills its potential and promises, by building local-first PWAs using open protocols and standards.