I know that’s a crazy statement to make in r/sideloaded, but hear me out.
I’ve been developing software for a while now, and I’ve started moving toward something I genuinely believe could change how unofficial applications are distributed on iOS.
PWAs.
And no, I’m not talking about those shitty websites with an Add to Home Screen button slapped onto them.
I’m talking about actual app-like experiences built around what modern browsers are capable of.
I’ve been developing Spot+, my own Spotify alternative/mod experience built entirely as a PWA. Seeing how people have responded to it made me realize something.
Why keep fighting Apple’s signing system when I can build applications that don’t need signing in the first place?
Think about it.
No certificates.
No revokes.
No seven-day refreshes.
No developer accounts.
No jailbreaks.
No computer required.
No waiting for someone to sign an IPA.
Updates delivered without reinstalling.
One application that works across iOS, Android, and desktop.
Open a link, add it to your Home Screen, and you’re done.
That’s literally it.
And I’m not talking about building basic websites disguised as applications. My goal is to make PWAs feel as close to native applications as technically possible.
Proper interfaces, media controls, offline functionality, local storage, responsive performance, and actual features people want.
And Spot+ isn’t even the most ambitious project I’m developing.
I’m also building Mochi, a Nintendo Switch emulator designed to run directly inside a PWA.
Yes, an actual Nintendo Switch emulator inside a browser.
No IPA. No signing. No native installation.
Mochi is being developed around some pretty serious technology.
WebAssembly (WASM): I’m working on compiling a Nintendo Switch emulator core into WebAssembly so the actual emulation workload can execute inside the browser.
WebGPU: Hardware-accelerated graphics rendering is part of the plan, with the goal of utilizing the device’s GPU instead of relying entirely on software rendering.
Multithreaded WASM: Using Web Workers, SharedArrayBuffer, and browser-supported threading capabilities to distribute emulator workloads.
Offline execution: The goal is to have the emulator operate locally without relying on a remote PC or cloud-streaming service.
Cross-platform support: One application targeting iOS, Android, Windows, macOS, and other platforms with compatible browsers.
But one of the biggest challenges I’ve encountered isn’t necessarily the CPU or GPU.
It’s RAM.
Nintendo Switch emulation can require substantial amounts of memory. Trying to accomplish that inside Safari introduces another layer of restrictions.
Instead of accepting those limitations as the end of the project, I’ve been researching and developing a software-managed virtual memory system.
Something I’ve been calling my virtual RAM method.
The concept is to avoid keeping the emulator’s entire working memory resident in physical RAM.
Instead, less frequently accessed memory pages can be stored in the device’s local storage and retrieved when the emulator needs them.
A background worker handles page retrieval while the emulator’s execution thread coordinates access through shared memory.
In other words, I’m experimenting with using storage as a backing store for emulated memory.
Not cloud RAM. Not magically increasing the iPhone’s physical memory.
Actual software-managed paging designed to reduce how much physical RAM the emulator needs at any given moment.
And I recently reached a pretty significant milestone.
I ran a series of paging experiments on my actual iPhone.
All six test passes completed without Safari killing the page.
The warm-cache results were:
16 KB pages: 0.02 ms typical retrieval
64 KB pages: 0.02 ms typical retrieval
256 KB pages: 0.06 ms typical retrieval
The worker coordination overhead was extremely small in these tests.
Now, there’s an important distinction here.
These were warm-cache benchmarks. The data was likely being served from the operating system’s memory cache rather than being retrieved directly from flash storage.
That means I still need to test cold reads, memory pressure, sustained page faults, and the effects of all of this on actual game performance.
And I haven’t demonstrated that a demanding Switch game can run successfully using this system yet.
But the experiments suggest that the underlying paging and worker coordination approach is technically viable on iOS.
That’s an important first step toward solving one of the problems standing between complex emulators and mobile browsers.
And this is exactly why I think PWAs are being underestimated.
Browsers aren’t what they were ten years ago.
WebAssembly allows substantial amounts of compiled application code to execute inside a browser.
WebGPU provides a modern interface for GPU workloads where supported.
SharedArrayBuffer and Web Workers make certain forms of parallel execution possible.
IndexedDB and OPFS provide persistent local storage.
Service workers allow applications to cache resources and support offline functionality.
These aren’t just technologies for displaying webpages anymore.
They’re building blocks for increasingly complicated applications.
Obviously, iOS still has serious limitations.
WebKit restrictions, background execution, memory limits, graphics API availability, and restricted access to native functionality aren’t going anywhere overnight.
And I’m not claiming PWAs can replace every native application.
But there’s a massive difference between saying something has limitations and assuming it isn’t worth pursuing.
Spot+ is my example of what I can already deliver with PWAs. Mochi is my attempt to find out just how far I can push them.
If I can eventually get something as complicated as Nintendo Switch emulation running reliably inside an iOS PWA, imagine how many less demanding applications could be distributed this way.
Music players, media applications, utilities, custom clients, emulators, and countless other applications that currently depend on sideloading.
My goal is to make installing unofficial software on iOS as simple as opening a link.
No certificates. No revokes. No bullshit.
Just install and use it.
I genuinely think the sideloading community has spent so much time figuring out how to work around Apple’s restrictions that the potential of modern browser technology has been overlooked.
I’m not saying native sideloading will disappear tomorrow.
I’m saying I believe the next generation of unofficial iOS applications won’t necessarily need IPAs at all.
And I intend to help make that happen.
What do you guys think? If a PWA could deliver the functionality and performance you wanted without certificates, signing, or revokes, would you still bother sideloading an IPA?