Software at human scale

The app as we know it has always been a fixed destination. You open it, scroll through, and browse around. You like, comment, subscribe and engage. But the design and shape of the app, the surface presented to you, was always something a group of strangers decided on well before you arrived. The app was this finished thing. You met it on its terms.

To some degree, the promise of vibe coding has changed these terms. Now, you can type a sentence into a prompt box and get something delivered back on command. The interface, the data structure, the design language, all of it generated for you, and all of it converging, increasingly, into one a single homogenized aesthetic. The output is fine. But none of it quite feels like your own.

What if building an app could feel less like vibe coding, and more like creating?

What if your app could feel like handing someone a drawing?

What if your app could bring your group chat together IRL?

Today, apps can be small things that you make for the people you already know, things that would never have justified their own production budget, the things that—until very recently—had no medium at all. As we move into an era of personal software, the shape and feel of apps is changing from things made for us into things we make for ourselves.

Our VP of engineering, Stalgia, put it this way:

Software has always been relational: components, data, models, interfaces, networks of dependencies, systems talking to other systems. But historically, that web of relationships has been hidden away behind tooling, setup, and technical overhead.

The interface for creating software has evolved from the chat window, or command line, to a prompt box where a request goes in and a neatly finished product comes out.

With Fuser Apps, we wanted to change that process.

The canvas is the work

We started Fuser because we wanted to make a tool that doesn’t just generate outputs, but becomes a space for exploration, a collaborator in the creative process. The relationships that have always existed in software, the way images feed into models, the way data flows from one component to another, the way one workflow becomes the input for the next, are all visible on the canvas.

This matters most at the moment of making an app, because an app is the place where all of those relationships come to converge. The image generation, the layout, the data, the model calls, the workflow logic. The image you generated yesterday becomes part of the app you’re prompting today. The workflow you built last week becomes the spine of a new app you fork from it. The relations stay visible, stay editable, and yours.

When the relations between software’s parts become visible, the shape of the app itself changes. From Stalgia again:

The app stops being a monolith. It starts to feel more like a living system, something that can branch, mutate, hybridize, and bloom.

This is what we mean by software at human scale. Not just that the audience is small (your group chat, your community, your five people). The shape itself is small, light, branching, generative.

An app on Fuser can be a sketch, a draft, a one-evening experiment. It can also be the seed of something that grows over time, forked into new versions for new occasions, remixed by your friends, recombined with their work. Apps stop being objects with users. They become things that move between people, the way a zine or a mixtape or a hand-written card has always moved.

The practical version of this is that, on Fuser, the app and the media it uses are made in the same place. You can describe the app you want and watch it materialize. You can also moodboard first: generate the images, write the copy, build the workflows on the canvas, then prompt the app into shape around them. Bring your own specificity instead of stock photos. Iterate on every piece. Compose new versions. Fork and remix.

Apps go live the moment they’re done. To you. To your group chat. To the whole internet.

And after they go live, your apps remain malleable. You can keep working on the canvas, swap out what doesn’t fit, fork your own work into a new version for a different friend or a different occasion. Apps on Fuser share data and remix on the canvas. One dataset, many frontends. The work you do in one app becomes the starting point for the next.

Apps that branch and bloom

An app no longer has to be a fixed destination. It can be a gesture. A gift. A bedtime routine you and your partner take turns running. A reading shelf you keep updated for one friend. An app for your dog. The relations between things, finally visible, finally yours, finally something you can pick up and put down and share with the people in your life.

This is the future we have been building toward. Software that lives the way the rest of culture has always lived: in fragments, in conversations, in things made for one person that one person will treasure. Software that branches and blooms.

Apps in Fuser are live now.

If the app you want to see in the world doesn’t exist yet, now you can make it.

Go make something new.

fusers.studio