What Vue actually is

Released in 2014 by Evan You — a former Google engineer who had worked with AngularJS — Vue.js took a deliberate position in the front-end landscape: progressive by design, meaning you can drop it into a page with a single script tag today and graduate to a full component-driven SPA tomorrow, without rewriting what you've already built. That incremental adoption story is still Vue's sharpest differentiator against React and Angular, both backed by corporations with sharper opinions about how you should structure an app.

Vue ships under the MIT licence and keeps its runtime impressively lean. The core is small enough that every kilobyte it costs you has to justify itself, and the Virtual DOM implementation is fast without demanding the kind of manual optimisation tuning that larger runtimes sometimes require. If you already know HTML, CSS, and JavaScript, the learning curve is genuinely shallow. Templates feel familiar — closer to Handlebars or Mustache than to JSX — which is a real comfort for developers coming from Ember or Angular.

State management lands via Pinia (the current official recommendation, succeeding Vuex) and follows a Flux-influenced model: unidirectional data flow, actions, predictable state. The project structure Vue scaffolds is readable almost immediately: index.html as the entry point, src/main.js (or .ts) as the bootstrap that imports the root App.vue component and mounts a Vue instance to the DOM, and individual .vue single-file components that co-locate their template, script, and styles in one coherent file. That colocation is a small thing that turns out to matter enormously once a codebase grows past the point where you can hold it all in your head.

The TypeScript turn, and why Vue made it

Vue 2 had TypeScript support, but it was bolted on — workable if you were determined, awkward if you expected it to feel native. Vue 3, released in 2020, rebuilt the framework internals in TypeScript from scratch. That wasn't primarily a signal to developers about which language they should use; it was a decision about how the framework itself should be maintained. A TypeScript codebase produces type declarations for free, which means editors can offer precise autocompletion and inline documentation without any extra tooling layer. The framework ships its own types, and they're accurate because they're generated from the source.

For application developers, this matters in concrete ways. When you define a component using the Composition API — Vue 3's setup() function or the <script setup> shorthand — TypeScript can infer the shape of reactive refs, computed values, and props without much annotation. You get red underlines in your editor before you get runtime errors in a browser. In a growing codebase where multiple developers are touching the same components, that feedback loop is the difference between catching a broken prop type at write-time and debugging a production rendering failure.

ts.ts
<script setup lang="ts">
import { ref, computed } from 'vue'

const count = ref(0)
const doubled = computed(() => count.value * 2)

function increment() {
  count.value++
}
</script>

That's a complete, runnable <script setup> block. TypeScript infers that count is Ref<number> and that doubled is ComputedRef<number> — no explicit annotations needed for something this simple. Add a more complex prop interface and the types propagate down into child components automatically.

This is the practical case for TypeScript in Vue projects: not ideology, not corporate mandate, but editor intelligence and earlier error detection that pay back the initial keystroke cost within a few days on any non-trivial component tree. Vue's own toolchain — the Vite-based create-vue scaffolder, the Volar language-server plugin for VS Code — is built around the assumption that TypeScript is the default. You can still write plain JavaScript in Vue 3, and the framework won't fight you. But the tooling will have less to tell you, and you'll feel the gap.

Vue remains, as it always was, an indie project in spirit — community-driven, not underwritten by a technology giant's roadmap concerns. That independence has sometimes meant slower momentum on the marketing side, but it has produced a framework with unusually coherent priorities: approachable enough for a solo developer, structured enough for a team, and now typed well enough that the editor becomes a collaborator rather than a passive text buffer.