Runable v1.0.0-alpha.20
Why Runable? Docs Modules Work with AI Blog About Changelog
  • 01Why Runable?
  • 02Docs
  • 03Modules
  • 04Work with AI
  • 05Blog
  • 06About
  • 07Changelog
Vue without a fixed server runtime.
Getting Started Structure Integrations Guide MCP API
  • Getting Started Structure Integrations Guide MCP API
  • Why Runable
  • Installation
  • Quick Start
  • Runable vs Nuxt
  • Configuration
  • Concepts

Runable vs Nuxt

Compare Runable and Nuxt by server runtime, backend integration, Vue conventions, and ecosystem maturity.

Runable and Nuxt both provide a structured Vue experience. Their main difference is who owns the server.

The difference in one sentence

Nuxt provides a complete application around Nitro. Runable adds a Vue application to a backend that you choose and operate yourself.

Nuxt                          Runable
┌──────────────────────┐      ┌───────────────────────────────┐
│ Vue application      │      │ Your backend                  │
│ Nuxt                 │      │ Express, Fastify, Hono…       │
│ Nitro                │      │ └─ Runable ─ Vue application  │
└──────────────────────┘      └───────────────────────────────┘

Quick comparison

TopicNuxtRunable
Server runtimeNitroYour HTTP server
File-based pagesYesYes
LayoutsYesYes
Auto-importsYesYes
Route middlewareYesYes
SSR and hydrationYesYes
Data loadinguseAsyncData()useAsyncData()
Modules and pluginsNuxt ecosystemRunable's own systems
Documented deploymentsMany Nitro presetsDepends on your backend
MaturityEstablished ecosystemAlpha project

Features with the same name do not guarantee identical APIs. Always check the Runable reference before reusing Nuxt code.

Choose Nuxt

Choose Nuxt when you want an integrated solution and Nitro fits your architecture.

Nuxt is generally a better fit when:

you are starting a new project without runtime constraints;
you want a mature, extensive ecosystem;
you prefer integrated deployment presets;
your team already knows Nuxt conventions.

Choose Runable

Choose Runable when the backend is a foundational decision that must not be replaced.

Runable is generally a better fit when:

Express, Fastify, NestJS, AdonisJS, Koa, or Hono already hosts your application logic;
you must keep an IoC container, middleware stack, or specific server lifecycle;
you want to serve the API and interface from the same application;
your infrastructure directly depends on the selected runtime.

What changes in server code

With Runable, you own the HTTP entry point:

// server.ts
import Express from "express";
import { express } from "runable/adapters/express";

const server = Express();

server.get("/api/users", usersController);
server.use(express());

server.listen(3000);

You decide middleware order, API routes, observability, and server startup. The adapter initializes Runable and handles requests that reach it.

What remains familiar

A Nuxt developer will recognize several conventions:

NuxtRunable
pages/app/pages/
layouts/app/layouts/
components/app/components/
composables/app/composables/
plugins/app/plugins/
middleware/app/middlewares/
definePageMeta()definePageMeta()
useAsyncData()useAsyncData()
defineNuxtPlugin()defineVuePlugin()
defineNuxtModule()defineModule()
Not a drop-in replacement

Runable adopts useful conventions, not all of Nuxt. Nuxt modules, Nitro APIs, and Nitro deployment presets are not directly compatible.

Decide quickly

QuestionIf the answer is yes
Does Nitro meet your server needs?Evaluate Nuxt first
Must an existing backend remain in control of the server?Evaluate Runable
Do you only need a lightweight SPA?Vue and Vite may be enough
Is production stability more important than runtime freedom?Account for Runable's alpha status
Next step

Customize directories, SSR, and Vite in Configuration.

Report an issue Edit this page
Quick Start

Create a Runable application with two pages, a layout, an API route, and server-rendered data.

Configuration

Configure directories, SSR, metadata, aliases, modules, and Vite options for your application.

On this page

  • 1The difference in one sentence
  • 2Quick comparison
  • 3Choose Nuxt
  • 4Choose Runable
  • 5What changes in server code
  • 6What remains familiar
  • 7Decide quickly
Runable

The Vue framework that brings productive conventions to any backend.

Product

  • Why Runable
  • Documentation
  • Installation
  • Integrations

Project

  • About
  • Blog
  • Changelog
  • Sponsor

Community

  • GitHub
  • Issues
  • Discussions
  • Bluesky

© 2026 Runable. Released under the MIT License.

Open source Built with Vue and Runable