Packages

vuejs/core is a pnpm monorepo. Each public package under packages/ ships independently to npm, can be consumed standalone (e.g., @vue/reactivity outside Vue), and follows the import rules in patterns and conventions. Private packages under packages-private/ are dev tooling that stays in-repo.

Public packages

Package	Source size	Tests	Page
vue	~146 lines (3 files)	20	vue
@vue/reactivity	~3,900 lines (13 files)	16	reactivity
@vue/runtime-core	~20,700 lines (65 files)	45	runtime-core
@vue/runtime-dom	~5,000 lines (17 files)	16	runtime-dom
@vue/runtime-test	~400 lines (5 files)	1	runtime-test
@vue/server-renderer	~1,300 lines (15 files)	18	server-renderer
@vue/compiler-core	~11,000 lines (30 files)	21	compiler-core
@vue/compiler-dom	~1,400 lines (16 files)	13	compiler-dom
@vue/compiler-sfc	~8,100 lines (30 files)	20	compiler-sfc
@vue/compiler-ssr	~2,250 lines (17 files)	16	compiler-ssr
@vue/shared	~1,100 lines (16 files)	6	shared
vue-compat	~210 lines (6 files)	12	vue-compat

xychart-beta horizontal
    title "Source lines per package"
    x-axis ["vue-compat", "vue", "shared", "runtime-test", "server-renderer", "compiler-dom", "compiler-ssr", "reactivity", "runtime-dom", "compiler-sfc", "compiler-core", "runtime-core"]
    y-axis "Lines of TypeScript"
    bar [208, 146, 1088, 405, 1321, 1417, 2249, 3898, 5038, 8113, 11011, 20714]

Private packages

Package	Purpose
packages-private/sfc-playground	The Vite-based SFC playground deployed at https://play.vuejs.org. Run locally via pnpm dev-sfc.
packages-private/template-explorer	Compiler debugging tool deployed at https://template-explorer.vuejs.org. Run locally via pnpm dev-compiler.
packages-private/dts-test	Type-level tests run against built .d.ts files. Run via pnpm test-dts.
packages-private/dts-built-test	Smoke test that the built .d.ts files import cleanly in a separate tsconfig.
packages-private/vite-debug	Scratch Vite project for debugging.

Dependency graph

graph TD
    sfc["@vue/compiler-sfc"]
    cdom["@vue/compiler-dom"]
    cssr["@vue/compiler-ssr"]
    ccore["@vue/compiler-core"]
    vue["vue"]
    rdom["@vue/runtime-dom"]
    rcore["@vue/runtime-core"]
    reactivity["@vue/reactivity"]
    rtest["@vue/runtime-test"]
    ssr["@vue/server-renderer"]
    shared["@vue/shared"]
    compat["vue-compat"]

    sfc --> cdom
    sfc --> ccore
    cdom --> ccore
    cssr --> cdom

    rdom --> rcore
    rcore --> reactivity
    rtest --> rcore
    ssr --> rcore
    ssr --> shared

    vue --> cdom
    vue --> rdom
    compat --> rdom

    ccore --> shared
    rcore --> shared
    rdom --> shared

Reading order

If you are new to the codebase, the recommended path through this section is:

1. shared — small package, contains the bitmask flags everything else uses.
2. reactivity — the foundation; understand Dep, ReactiveEffect, ref, reactive first.
3. runtime-core — components, vnodes, scheduler, renderer.
4. runtime-dom — short, mostly delegates to runtime-core.
5. compiler-core — parser → transform → codegen pipeline.
6. compiler-dom, compiler-ssr — incremental specializations.
7. compiler-sfc — the SFC toolchain that ties templates, scripts, and styles together.
8. server-renderer — the SSR side, easier once SFC and runtime-core are familiar.
9. vue, vue-compat, runtime-test — small wrapper packages.