This is an attempt to converge on terminology and extreme divergence we've had during today's 2026-11-12: Tech Sync. It's related to Seed App Environment.

After thinking about it for a while this is what I propose. These are very rough notes, so don't be too picky when asking questions :)

Terms

App Definition

This is a resource that describes an app. It specifies schemas necessary for its configuration, remote services if any, needing for it to work, views with their assets needed to display the state, schemas for the state it works with, and anything else we want to define.

It's a resource. It's a definition. It's almost like a schema, but rather a whole bundle of schemas and other associated resources.

It's a bit handwavy, because I don't know how much complexity it could have, but I think we already have something that's basically this thing.

The point is that this is very flexible. This is declaring all the things necessary for the app to work, some of which may be optional — some apps would need a remote service they talk to, some apps just display static HTML assets talking to local daemon for data. Some apps are very local-first, some apps are less local-first, some apps are purely client-server. It could all fit under the same idea I hope.

App Instance

This is a configured app definition, installed in some space (what Eric calls mounting). Installing an app into a space means providing the required configuration, like specifying URLs of a remote service (if it's needed), and maybe other things. I don't know how complex this is going to get, but the point is that App Definition is an app with some "holes" that you need to fill in. The instance fills them in.

I'm not sure if maybe for simple apps the definition and instance could be combined, especially if you'll never want anybody else installing your app.

We could still use the word "mount", meaning to display the app installation in the sidebar of the space.

When you open an app instance by clicking on its entry in the Space's sidebar, the app does what it needs to do — shows views, talks to services, and does whatever it need.

Another analogy is the regular web — web apps are running on our devices in our browsers, they may or may not talk to some remote services for doing the work, but they are served by some host as HTML, JS and so on. In our case the app is served by the space where it's installed.

Service

A separately addressable component that handles requests or performs work. It can run locally, or remotely, via P2P or public internet, depending on the app definition.

View

HTML resources and other assets necessary for the app to display its data.

Views could be static assets distributed as part of the definition, and it could also be a part of the service or implicitly embedded in the runtime of the actual Seed node.

Again, a bit handwavy but you get the idea. It's the thing you look at when you open an installed app, and it shows some data.

State

The data that the app needs. Views could also be considered a state probably. But there's some inherent state also that needs to be displayed in the view.

Just like views, state can be replicable, or it can live in a service — all depends on each specific app definition.

The Food Inventory Example

For the example we discussed in the call (I'll frame it for restaurants instead of war food provisioning like we discussed 😄):

    App is the overarching thing for managing food. There's some app definition for this kind of apps, but every restaurant has their own instance.

    They have one server (or it can be a regular peer in their basement) that is acting as an inventory management service for this app. It needs credentials, it has a large database, it maybe sends emails and whatnot.

    This service happens to publish some replicable state. Every peer syncs their state according to their permissions.

    This app also has some views, which are HTML files that are also synced.

    The chef opens the Seed Desktop App, goes to their restaurant's space, and opens their installed inventory management app. This is its local app instance. Everybody has their own.

    This app instance talks to the service, syncs some data, presents some views to the user, and does what it needs to do.

On Actor Model

I don't know which of these above things are actors. And honestly I don't care. Simply saying that something is an actor tells very little until we specify concrete boundaries and rules.

We can partition all the above things in many ways, and call them actors with different levels of granularity, but I don't think it's going to buy us much clarity. In a way calling something an actor without specifying some very concrete details makes things more vague than clear.

The whole idea of the actor model is pretty abstract: it's a thing, with an identity, that has some private state, takes messages into a mailbox, and handles them sequentially. It leaves so many details aside.

Depending on what you read and who you follow, you could come up with several concrete definitions of what an actor is. And these concrete definitions could be totally conflicting, while still complying with the abstract idea of what the actor model means.

Because of this polarization, I think we should stop arguing about actors, and talk about specific components and their roles in our concrete system — about rules, constraints, behaviors, protocols, and so on. We can totally use techniques of some specific implementation of the actor model when we are implement stuff, and we can even formalize over time which parts of our system behave like actors. But more importantly, you don't need to call something an actor for it to behave like one.

Do you like what you are reading? Subscribe to receive updates.

Unsubscribe anytime