Start with a picture, shake to discover an effect, then shape it directly. I wanted to find out whether the interaction we built in 2013 could feel even better as a modern web app.
In 2013, a few months after we founded our company, I started building an iOS prototype around a simple idea: combine art, movement and direct touch in an image application that did not need much explanation.
The prototype was made for a competitive pitch presentation to Fondation Beyeler. I was ill and could not attend the presentation myself, but the neko team won the project. That prototype became ArtShaker, our first iOS app.
I coded the prototype and the complete released iOS application myself. neko created the visual design, graphics and icons. The app launched on 25 September 2013 and, one month later, was recorded at number 3 among Photography apps in the Swiss iPhone App Store. I ported it to Android the following year. That version brought a different set of challenges, especially the much wider range of mobile GPUs at the time.
The central idea was never a conventional effects browser. ArtShaker opened with an image already visible. You could leave it unchanged, shake the device to discover an effect, or choose one yourself. Horizontal, vertical and diagonal gestures adjusted three carefully tuned parameters directly on the picture. The canvas was the interface.
That simplicity was the result of a lot of detailed work. Shake had its own short collapse-and-return transition. Gesture direction locked after a small movement so it could not jump while someone was adjusting an image. Motion, touch feedback and transitions made the result feel physical. Camera, photo library, paste, crop, combine, undo, compare, save and share all supported the same flow instead of competing with it.
I kept ArtShaker on my phone after the store listing disappeared and opened it from time to time, often with my children or family. I always knew the concept was good, and it was still fun to use.
It was not only me. App Store Connect’s opt-in analytics reports 1,525 sessions between 1 January 2020 and 1 August 2026, with sessions in every one of the 80 monthly rows. Even in 2026, the completed months shown each recorded between 8 and 15 sessions. Because this metric includes only users who opted in to sharing analytics, the real session count is higher. Apple does not expose the missing total in this view, so 1,525 is a documented lower bound rather than an estimate of all use.
I had wanted to revisit the idea for a long time. Art Filters is my director’s cut of that interaction concept: the original flow rebuilt for the web with the benefit of everything we have learned since.
It is not a relaunch of the ArtShaker brand or its former content. The new app uses an independent open-access gallery and contains no Fondation Beyeler artwork, sponsor material or other customer content. The old source code and our detailed specifications served as the behavioural reference. The interface and rendering were ported to the browser platform.
Rebuilding it was less about translating Objective-C than preserving the behavior people could feel: the timing, gesture response, filter ranges, composition and freedom to stop without applying any effect. Making those details reliable across current browsers and GPUs required the same kind of fine tuning as the native apps.
The current interface is built with React and TypeScript, while WebGL2 renders the effects. Where supported, the renderer runs in a worker with OffscreenCanvas; other browsers use a main-thread fallback. React owns interface state and history, but it does not schedule every interactive GPU frame.
One performance problem demonstrated why that separation matters. On Firefox for Windows with an older NVIDIA GTX 980, compiling the large shader took about 40 milliseconds, but linking it took approximately 3.7 seconds. The interface could appear frozen even though the JavaScript work itself was small.
The solution was to split the effects into six shader families that link only when needed and remain cached in one retained WebGL context. The visible image, effect previews, combinations and exported image share that renderer instead of creating duplicate contexts and programs.
The renderer also follows the normal lifecycle of an installed web app, including suspension and resumption on iOS. It recreates GPU resources when necessary and restores the current image and filter state. Web apps remove the need for separate platform implementations here, but they do not remove platform differences.
An installed web app also has to remember where someone left it. Art Filters stores the current gallery or local image, the complete filter stack with its exact parameters, random mode and a bounded undo history in the browser’s local database. It restores that state after the app is reloaded or restarted, while a normal website launch deliberately starts fresh. The image and editing state stay on the device; they are not uploaded or synchronized.
The same experience that required separate native iOS and Android apps in 2013 now runs as one installable web app. It can use the camera, touch, motion sensors, GPU rendering and native sharing on a phone, while remaining fully usable with gestures and a Shake button on a desktop computer.
That does not mean native apps are no longer needed. Deep platform integration, background execution and device-specific capabilities can still make them the right choice. But for this application, the default has changed. The modern web platform covers almost the complete experience and gives desktop users the same application without a separate port.
What matters most to me is that the original interaction survived the transition. You still start with an image. You can shake, explore, adjust and stop whenever the result feels right. The technology changed completely, but the reason I kept opening the old app did not.
Try Art Filters in the appamics Playground.
If you try it on an unusual browser, older GPU or mobile device, I am interested in how the interaction feels there.