Nuxt/docs/content/2.concepts/2.vuejs-development.md

# Vue.js development

Nuxt uses Vue as a frontend framework, and adds features such as components auto-imports and file-based routing. Nuxt 3 integrates Vue 3, the new major release of Vue that enables new patterns for Nuxt users.

## Vue.js

> While an in-depth knowledge of Vue is not required to use Nuxt, we recommend that you read the documentation and go through some of the examples on [vuejs.org](https://vuejs.org/)
>

Nuxt has always used Vue as a frontend framework. We chose to build Nuxt in top of Vue for these reasons:

- The reactivity model of Vue, where a change in data automatically triggers a change in the interface.
- The component-based templating, while keeping HTML as the common language of the web, enables intuitive patterns to keep your interface consistent, yet powerful.
- From small projects to large web applications, Vue keeps performing well at scale to ensure that your application keeps delivering value to your users.

## Vue with Nuxt

### Single file components

[Vue’s single file components](https://v3.vuejs.org/guide/single-file-component.html) (SFC, or `*.vue` files) encapsulate the markup (`<template>`), logic (`<script>`) and styling (`<style>`) of a Vue component. Nuxt provides a zero-config experience for SFCs with [Hot Module Replacement](https://webpack.js.org/concepts/hot-module-replacement/) that offers a seamless developer experience.

### Components auto-imports

Every Vue components created in the [`components/` directory](/docs/directory-structure/components) of a Nuxt project will be available in your project without having to import them. If a component is not used anywhere, it will not be included in your production’s code.

### Vue Router

Most applications need multiple pages and a way to navigate between them. This is called **routing**. Nuxt uses a [`pages/` directory](/docs/directory-structure/pages) and naming conventions to directly create routes mapped to your files using the official [Vue Router library](https://router.vuejs.org/).

### Example

:button-link[Open on StackBlitz]{href="https://stackblitz.com/edit/github-9hzuns?file=app.vue" blank}
:button-link[Open on CodeSandBox]{href="https://codesandbox.io/s/nuxt-3-components-auto-import-2xq9z?file=/app.vue" blank}

The `app.vue` file is the entrypoint, which represents the page displayed in the browser window.

Inside the `<template>` of the component, we use the `<Welcome>` component created in the `components/`  directory without having to import it.

Try to replace the `<template>`’s content with a custom welcome message. The browser window on the right will automatically render the changes without reloading.

::alert{type="info"}
💡 If you are familiar with Vue, you might wonder where is the `main.js` file that creates a Vue app. This part is done by Nuxt behind the scene.
::

**If you were a previous user of Nuxt 2 or Vue 2, keep reading to get a feel of the differences between Vue 2 and Vue 3, and how Nuxt integrates those evolutions.**

**Otherwise, go to the next chapter to discover another key feature of Nuxt: [Rendering modes](/concepts/rendering)**

## Differences with Nuxt 2 / Vue 2

Nuxt 3 is based on Vue 3. The new Vue major version introduces several changes that Nuxt takes advantage of:

- Better performances
- Composition API
- Typescript support

### Faster rendering

Vue Virtual DOM (VDOM) has been rewritten from the ground-up and allows for better rendering performances. On top of that, when working with compiled Single-file components, Vue compiler can further optimize components at build time by separating static and dynamic markup.

This results in faster first rendering (component creation) and updates, and less memory usage. In Nuxt 3, it enables faster server-side rendering as well.

### Smaller bundle

With Vue 3 and Nuxt 3, a focus has been put on bundle size reduction. With version 3, most of Vue’s functionality, including template directives and built-in components are tree-shakeable. They will not be included in your production bundle if you don’t use them.

This way, a minimal Vue 3 application can be reduced to 12 kb gzipped.

### Composition API

The only way to provide data and logic to components in Vue 2 was through the Options API, allowing to return data and methods to a template with pre-defined properties like `data` and `methods`:

```vue
<script>
export default {
  data() {
    return {
      count: 0
    }
  },
  methods: {
    increment(){
      this.count++
    }
  }
}
</script>
```

The [Composition API](https://vuejs.org/guide/extras/composition-api-faq.html) introduced in Vue 3 is not a replacement to the Options API, but enables better logic reuse throughout an application, and a more natural way to group code by concerns in complex components.

Used with the `setup` keyword in the `<script>` definition, here is the above component rewritten with Composition API and Nuxt 3’s auto-imported Reactivity APIs:

```vue
<script setup>
  const count = ref(0);
  const increment = () => count.value++;
</script>
```

The goal of Nuxt 3 is to provide a great developer experience around the composition API.

- Use auto-imported [Reactivity functions](https://vuejs.org/api/reactivity-core.html) from Vue and Nuxt 3 [built-in composables](https://v3.nuxtjs.org/docs/usage/data-fetching).
- Write your own auto-imported reusable functions in the `composables/` directory.

### Typescript support

Both Vue 3 and Nuxt 3 have been written in Typescript. A fully typed codebase prevents mistakes and documents APIs usage. This doesn’t mean that you have to write your application in Typescript to take advantage of it. With Nuxt 3, you can opt-in by just renaming your file from `.js` to `.ts` , or add `<script lang="ts">` in a component.

::alert{type="info"}
🔎 [Read the details about Typescript in Nuxt 3](/concepts/typescript)
::