Apps vs. engines
Apps vs. execution engines
The two extension types compared — what each is for, how users invoke them, and how to choose.
Verentis has two extension types (a third, agents, is planned). They share a manifest envelope and a security model but solve different problems.
At a glance
App (kind: Application) | Execution engine (kind: ExecutionEngine) | |
|---|---|---|
| What it is | A package of installed files — optionally a UI surface | A code runtime that executes files |
| Where it runs | A sandboxed <iframe>, and/or files installed into the workspace | Docker container (server) or WebAssembly (server/browser) |
| How users invoke it | Open a file (iframe apps); or its installed files run by type — schedule, trigger, or manual run | Run a file; on a schedule; or on a file-change trigger |
| Resolved by | The file's MIME type (iframe) or type (installed scripts/triggers) | The file's type/extension |
| Typical output | An interactive experience, or seeded/scheduled files and side-effects | Structured data, written files, side-effects, or streamed logs |
| Manifest file | *.app.yaml | *.engine.yaml |
| SDK | @verentis/sdk (TypeScript, via postMessage bridge) | Language SDK (e.g. Python) inside the runtime |
Choose an app when…
- You want to show or edit content (an image viewer, a Monaco-based editor, a chart dashboard).
- You want to ship a collection of files into a workspace — scripts, schedules, triggers, seed data — that an execution engine then runs. The app is the installable package; the engine does the compute.
- The value is in the interface the user sees, or in the files the app installs.
- You'll render HTML/JS and talk to the platform from the browser, or ship a headless file bundle.
Apps resolve by MIME type. For example, an image viewer claims image/*; a smart editor claims
application/json, application/yaml, text/*, and so on. The workspace picks the best-matching app
when a user opens a file.
Choose an execution engine when…
- You want to run code against files (execute a Python script, transform a dataset, render a model).
- The value is in the computation, not a UI.
- You need server-side sandboxing, scheduling, or event-driven triggers.
Engines resolve by file type/extension (e.g. .py → a Python engine) and can run in several modes:
on-demand request/response, long-running with streamed output, scheduled (cron), or event-driven
(file-change triggers).
You can ship both
Many integrations pair an engine with an app — for example, an engine that runs notebooks plus an app that displays their results. Because they share the manifest envelope, discovery, and token model, a combined extension is natural.