What is new in vue 3

What is new in vue 3

Vue 3 is the latest major release of the popular JavaScript framework, Vue.js. It comes with a range of new features and updates that make it even more powerful and flexible than before. Whether you’re a seasoned Vue developer or just starting out with the framework, the new features in Vue 3 will definitely enhance your development experience.

One of the key updates in Vue 3 is the new Composition API, which provides a more flexible and modular approach to building components. With the Composition API, you can easily organize and reuse your code, making it easier to understand and maintain your application. This new API allows you to create logic that can be easily shared across multiple components, making it easier to build complex applications.

In addition to the Composition API, Vue 3 also introduces a new rendering mechanism called the Vue 3 Renderer. This new renderer is faster and more efficient than the previous version, allowing for improved performance and better user experience. With the new renderer, you can expect faster updates to the DOM, reduced memory usage, and improved overall performance.

Another exciting feature in Vue 3 is the new Teleport component, which allows you to render a component’s content at a different place in the DOM tree. This makes it easier to create complex UI layouts and handle edge cases where content needs to be rendered outside of its parent component. The Teleport component is a powerful addition to Vue 3 that will greatly enhance the flexibility and usability of your applications.

Overall, Vue 3 brings a range of new features and updates that make it an even more powerful and flexible JavaScript framework. Whether you’re a beginner or an experienced developer, the new features in Vue 3 will enhance your development experience and help you build better and more efficient applications.

Table of Contents

Composition API: Simplified Development Process

The Composition API is one of the most exciting features introduced in Vue 3. It aims to simplify the development process by providing a more flexible and scalable way to organize code.

What is the Composition API?

The Composition API allows developers to define the logic of a component in a more declarative manner. It replaces the Options API, where developers would define the component’s properties, methods, and lifecycle hooks in a single options object.

With the Composition API, developers can now split the code into reusable and composable functions called “composition functions”. These functions can be organized based on their responsibility or functionality, making the code more modular and maintainable.

Benefits of the Composition API

Benefits of the Composition API

The Composition API brings several benefits to Vue developers:

  • Improved Reusability: Composition functions can be easily reused across multiple components, reducing code duplication and improving code organization.
  • Better Code Organization: The Composition API allows developers to organize code into smaller, composable functions, making it easier to understand and maintain.
  • Scoped Logic: Each composition function can focus on a specific aspect of the component’s logic, making it easier to reason about and test.
  • TypeScript Support: The Composition API provides better TypeScript support compared to the Options API, making it easier to catch errors and enforce type checking.

Using the Composition API

To use the Composition API, developers can import the necessary functions from the Vue package:

import { reactive, computed, watchEffect } from 'vue';



They can then define composition functions using these imported functions:

const useCounter = () => {

const count = reactive({ value: 0 });
const increment = () => {
const double = computed(() => {
return count.value * 2;
watchEffect(() => {
console.log(‘Count:’, count.value);

return {











Finally, developers can use the composition function in their component:

export default {


setup() {


const { count, increment, double } = useCounter();


return {
















The Composition API is a powerful addition to Vue 3 that simplifies the development process by providing a more modular and reusable approach to organizing code. It allows developers to write cleaner and more maintainable code, with better TypeScript support and improved code organization.

Fragments: Grouping Elements without Extra Markup

Vue 3 introduces a new feature called Fragments, which allows you to group elements without the need for extra markup.

What are Fragments?

In Vue 2, when you want to group multiple elements in a component, you have to wrap them in a single root element. This often leads to the use of unnecessary `

` elements, just for the purpose of grouping elements.

With Vue 3 Fragments, you can now group elements without the need for an extra root element. Fragments are a way to create a virtual parent element that does not render any actual HTML markup. This allows you to group elements together without adding any extra DOM elements.

How to use Fragments

To use Fragments in Vue 3, you simply need to wrap your elements in the “ tag. The “ tag acts as a fragment container, allowing you to group multiple elements without the need for a root element.

Here’s an example:



My Fragmented Elements

  • Element 1
  • Element 2
  • Element 3



In the example above, the `

` and `

    • ` elements are grouped together within the “ tag. This creates a fragment that can be used within your component.

Advantages of Fragments

Fragments provide several advantages in Vue 3:

1. Cleaner code: Fragments eliminate the need for unnecessary root elements, resulting in cleaner and more concise code.

See also:  TypeScript Reference : Mixins

2. Improved performance: Since Fragments don’t generate any additional DOM elements, it improves overall performance by reducing the number of elements rendered on the page.

3. Easier styling: Without the need for extra root elements, styling becomes easier as you don’t have to take the extra elements into account when applying styles.

Using Fragments in Vue 3 allows you to organize your components more efficiently and maintain cleaner code.


Fragments in Vue 3 provide a cleaner and more efficient way to group elements without the need for extra markup. By using the “ tag as a fragment container, you can eliminate the need for unnecessary root elements and improve the performance of your components. Fragments make your code cleaner, easier to maintain, and improve overall performance in Vue 3.

Teleport: Efficiently Render Content in a Different Location

In Vue 3, the new Teleport feature allows developers to efficiently render content in a different location within the DOM. This can be useful for scenarios where you want to render a component’s content outside of its parent component, such as popovers, tooltips, and modals.

With Teleport, you can define a target element for your content to be rendered in using the teleport attribute. This attribute takes a CSS selector string or a DOM element as its value.

Example Usage:

	<div class="modal">
		<button @click="isOpen = false">Close</button>
			<teleport to="#modal-root">
				<div class="modal-content">
					<p>Content rendered outside the modal.</p>

In the above example, the content inside the <teleport> element will be rendered outside of the parent <div class="modal"> element and placed within the target element with the ID of #modal-root.

This provides a cleaner and more efficient way of managing the DOM structure for components with complex UI structures.


      • The target element must exist in the DOM before the component using <teleport> is mounted.
      • Sibling components cannot be targeted, only elements outside of the component’s parent.
      • The content being teleported does not maintain any reactivity to the component’s data changes.


The Teleport feature in Vue 3 provides a convenient way to render content in a different location within the DOM. It allows developers to create complex UI structures without compromising on performance or code cleanliness. With Teleport, you can easily render content outside of a component’s parent and improve the overall organization of your Vue applications.

Suspense: Improve User Experience with Placeholder Content

With the release of Vue 3, one of the most exciting new features is the addition of Suspense. Suspense is a way to improve user experience by allowing developers to show placeholder content while waiting for the actual content to load. This eliminates the need for users to stare at a blank screen or spinner while waiting for data to be fetched.

How does Suspense work?

With Suspense, you can define a fallback component that will be displayed while the actual component is loading. This can be useful when fetching data from an API or loading a heavy component. The fallback component can be something as simple as a loading spinner, or it can be a more meaningful placeholder that resembles the actual component.

Example usage:

      1. Wrap the component you want to lazy load with a <suspense> tag.
      2. Inside the <suspense> tag, define a <template #default> block that represents the content that will be shown after the component is loaded.
      3. Add a <template #fallback> block that represents the placeholder content to be shown while the component is loading.
      4. Use the is attribute to specify the component to load asynchronously.

Here’s an example of how you can use Suspense to improve user experience:

		<template #fallback>
			<p>Loading component...</p>
		<template #default>
			<heavy-component is="actual-component"></heavy-component>

In this example, while the actual-component is loading, the placeholder content will be displayed. Once the component is loaded, the placeholder content will be replaced with the actual component.


Suspense is a powerful new feature introduced in Vue 3 that significantly improves user experience by providing placeholder content while waiting for data to load. By using Suspense, you can enhance your application’s perceived performance and make it more user-friendly. Consider incorporating Suspense into your Vue 3 projects to provide a smooth and seamless user experience.

Global Mounting: Enhancing Performance and Flexibility

One of the most important updates in Vue 3 is the introduction of global mounting, which enhances performance and flexibility in Vue applications.

Previously, in Vue 2, mounting a Vue instance required a root element and a mount point in the HTML document. This means that you could only mount a Vue instance to a single element on the page, limiting the flexibility of your application.

With Vue 3, global mounting allows you to mount a Vue instance to multiple elements on the page. This means that you can have multiple root elements for your Vue application, giving you more options and flexibility in how you structure your components.

In addition to the increased flexibility, global mounting also improves the performance of your Vue application. In Vue 2, the initial mount and subsequent updates of a Vue instance required traversing the virtual DOM to find the mount point. With global mounting in Vue 3, the mount point is registered and cached during the creation of the Vue instance. This reduces the amount of work required during the mount process, resulting in faster rendering and improved performance.

To use global mounting in Vue 3, you can use the app.mount() method to mount your Vue instance to a specific element. This method takes a selector string as its argument, allowing you to mount the instance to any element that matches the selector.

Here’s an example:

const app = createApp(MyApp);

In this example, the Vue instance created with createApp() is mounted to an element with the ID “app”. This element can be any existing element in the HTML document, giving you the flexibility to mount your Vue instance wherever it makes the most sense for your application.

Overall, global mounting in Vue 3 enhances performance and flexibility, giving you more control over how your Vue components are structured and displayed on the page.

Props Emits: More Robust Communication between Components

In Vue 3, the communication between components has become more robust with the introduction of the new Props Emits feature. This feature enhances the inter-component communication by providing a standardized way for child components to receive data from parent components and emit events back to them.

What are Props and Emits?

Props and Emits are two important concepts in Vue that allow components to communicate with each other.

      • Props: Props are used to pass data from a parent component to a child component. They are similar to function parameters and can be defined in the child component’s props option. The parent component can then pass data to the child component by binding values to the defined props.
      • Emits: Emits are used to emit custom events from a child component to its parent component. The child component can define the events it can emit using the emits option. The parent component can then listen to these events and handle them accordingly.

Improved Features in Props Emits

The introduction of Props Emits in Vue 3 brings several improvements and enhancements to component communication.

      1. Typed Props: Vue 3 allows you to type your props, providing better type-checking and code completion support in IDEs. This helps in reducing errors and improving the development experience.
      2. Emit Option: With Props Emits, you can define the events a component can emit using the new emit option. This makes it easier to see which events a component can emit, and provides better documentation for the component’s public API.
      3. Event Composition: In Vue 3, you have the ability to compose events, meaning that you can listen to an emitted event and emit a new event with modified or additional data. This allows for more flexible and powerful event handling between components.
See also:  TypeScript Type Manipulation : Keyof Type Operator

Usage of Props Emits

Using Props Emits in Vue 3 is straightforward. Here is an example:

Parent Component Child Component

<ChildComponent :message="message" @childEvent="handleChildEvent"></ChildComponent>
<p>{{ message }}</p>
<button @click="emitEvent">Click Me</button>
export default {
props: ['message'],
emits: ['childEvent'],
methods: {

emitEvent() {
this.$emit('childEvent', 'Data from Child Component');


In the above example, the parent component passes the message prop to the child component. The child component then emits the “childEvent” event with some data when the button is clicked. The parent component handles the emitted event using the handleChildEvent method.

Props Emits in Vue 3 provides an improved and standardized way of communication between components. It enhances code readability, type-checking, and overall development experience. Take advantage of these features to build more robust and maintainable Vue applications.

Vite Integration: Faster and Smoother Development Experience

Vite is a build tool that is designed to provide a faster and smoother development experience for Vue projects. It aims to optimize the development workflow by leveraging modern browser technology and a dependency pre-bundling approach.

Key Features of Vite Integration

      • Lightning-fast development server: Vite comes with a highly optimized development server that leverages ES module imports to provide near-instant page hot-reloading. This allows developers to see immediate feedback as they make changes to the code, resulting in a more efficient development process.
      • On-demand compilation: Unlike traditional bundlers that need to rebuild the entire project every time a change is made, Vite only recompiles the modified part of the code. This significantly reduces compilation time, making the development process faster and more efficient.
      • Dependency pre-bundling: Vite pre-bundles the dependencies during the development process, which allows for faster module resolution and loading. This results in quicker page startup times and a smoother user experience.

How Vite Integration Benefits Vue 3 Projects

Vite’s integration with Vue 3 brings several benefits to Vue projects:

      • Improved developer productivity: The lightning-fast development server and on-demand compilation provided by Vite significantly reduce the time developers have to wait to see the changes they make to the code. This speeds up the development process and improves productivity.
      • Better performance: Vite’s dependency pre-bundling and optimized module loading ensure faster page startup times and a smoother user experience. The faster development server also results in quicker hot-reload times, allowing developers to quickly iterate and test their changes.
      • Seamless migration: Vite is designed to be compatible with existing Vue projects, which makes it easier for developers to migrate their projects to Vue 3. The integration provides a smooth transition and allows developers to take advantage of the new features and improvements offered by Vue 3 without significant disruptions to their existing projects.


Vite integration offers a faster and smoother development experience for Vue 3 projects. It improves developer productivity, enhances performance, and facilitates seamless migration to Vue 3. By leveraging modern browser technology and a dependency pre-bundling approach, Vite optimizes the development workflow and provides immediate feedback during the development process, resulting in an efficient and satisfying development experience.

TypeScript Support: Type Safety and Better Code Navigation

One of the major updates in Vue 3 is the enhanced support for TypeScript. TypeScript is a statically-typed superset of JavaScript that brings type safety and better code navigation to your development workflow.

With TypeScript support in Vue 3, you can now define types for your Vue components, props, data, and more. This allows you to catch errors and typos early during development, as the TypeScript compiler will provide type checking and suggestions for type-related issues.

Additionally, TypeScript support in Vue 3 improves code navigation and autocompletion in modern code editors. By providing explicit types and interfaces, you can easily navigate through your codebase and understand the structure and relationships between different components and modules.

Here are some key benefits of TypeScript support in Vue 3:

      • Type Safety: With static typing, TypeScript helps prevent runtime errors by catching them during compilation. This enhances code reliability and reduces the likelihood of bugs.
      • Better Developer Experience: TypeScript provides improved autocompletion, code navigation, and documentation support in modern code editors like Visual Studio Code. This helps developers write code faster and with greater confidence.
      • Refactoring Support: With TypeScript, refactoring becomes easier and less error-prone. By providing clear type annotations, you can confidently make changes to your codebase and rely on the compiler to catch any potential issues.
      • Improved Collaboration: TypeScript’s type annotations serve as documentation for your codebase, making it easier for other developers to understand and work on your project. This can greatly enhance collaboration and maintainability.

By combining the power of Vue 3 and TypeScript, you can create robust, maintainable, and scalable applications with ease. Whether you’re building a small project or a large enterprise application, TypeScript support in Vue 3 can greatly improve your development workflow and code quality.

Reactivity System: Improved Efficiency and Performance

The reactivity system in Vue 3 has undergone significant improvements to enhance efficiency and overall performance. These updates have been aimed at making Vue more performant and delivering a better user experience.

Proxy-based Reactivity

Vue 3 uses a new reactivity system based on JavaScript Proxies, which provides several advantages over the previous system. The new system allows Vue to track dependencies more accurately and avoids unnecessary re-renders, resulting in improved performance.

With Proxy-based reactivity, Vue 3 is able to directly observe changes to the data properties of the reactive objects. This eliminates the need for manual tracking and reduces the complexity of the reactivity system.

Static Tree Optimization (STO)

Vue 3 introduces Static Tree Optimization (STO), a new optimization technique that significantly enhances rendering performance for components with deeply nested structures. STO analyzes the static tree structure of a component and optimizes the rendering process by minimizing updates to the DOM.

By reducing the number of DOM manipulations, STO improves rendering performance, resulting in faster component updates and better overall user experience. This optimization is particularly beneficial for components with large and complex rendering trees.

Faster Component Mounting

Vue 3 introduces a faster component mounting algorithm that improves the initial rendering performance. The new algorithm eliminates redundant work during the component initialization process, resulting in faster mounting and rendering of components.

By optimizing the component mounting process, Vue 3 reduces the time required to render a component for the first time, resulting in improved performance and a more responsive user interface.

Fragment Syntax

Vue 3 introduces a new syntax for defining fragments, allowing developers to group multiple elements without using an extra wrapping element. This syntax improvement helps to reduce the complexity of the component structure and enhances the efficiency of the rendering process.

The new fragment syntax also enables better compatibility with existing HTML and CSS code, making it easier to integrate Vue 3 into existing projects.

Efficient Change Detection

Efficient Change Detection

Vue 3 incorporates a more efficient change detection mechanism that reduces the amount of work required to detect and propagate changes in the component tree. The new algorithm avoids unnecessary re-renders and optimizes the update process, resulting in improved performance.

See also:  How to use pinia in vue 3

With the efficient change detection mechanism, Vue 3 can track and update only the components and data that have actually changed, minimizing the impact on rendering performance and ensuring a smooth user experience.


The reactivity system in Vue 3 has been significantly improved to enhance efficiency and overall performance. The introduction of Proxy-based reactivity, Static Tree Optimization, faster component mounting, improved change detection, and the new fragment syntax all contribute to better performance and a more enjoyable user experience.

Custom Directives: Extend Vue’s Core Functionality

Vue provides a powerful and flexible way to extend its core functionality through custom directives. Custom directives allow you to directly manipulate the DOM, register event listeners, or add additional behavior to elements in your Vue application. This can be useful when you need to interact with third-party libraries, access low-level DOM APIs, or create reusable UI components.

Custom directives are defined as JavaScript objects with several hook functions that are called at different stages of the directive’s lifecycle. These hook functions can be used to perform actions such as adding or removing event listeners, updating the DOM, or modifying the behavior of elements.

Creating a Custom Directive

To create a custom directive in Vue, you need to use the v-directiveName syntax in your template, where directiveName is the name you choose for your directive. You can then define the directive using the Vue.directive method in your component’s JavaScript code.

<div v-myDirective>Directive example</div>
export default {
	directives: {
		myDirective: {
		/* Directive hooks go here */

Directive Hooks

The following are the main hook functions that can be defined in a custom directive:

      • bind: Called once when the directive is first bound to the element. This is a good place to do one-time setup work.
      • inserted: Called once when the bound element is inserted into the parent node.
      • update: Called when the bound element’s value or expression updates.
      • componentUpdated: Called once after the component has been updated.
      • unbind: Called once when the directive is unbound from the element.

Example: Custom Directive to Limit Input Length

Here’s an example of a custom directive that limits the length of input fields:

<input v-limitInputLength="10">
export default {
	directives: {
		limitInputLength: {
			bind(el, binding) {
			const { value } = binding;
				el.addEventListener('input', () => {
					if (el.value.length > value) {
						el.value = el.value.slice(0, value);

In this example, the custom directive v-limitInputLength is used to limit the input length of the associated input field to the specified value (in this case, 10). The bind hook function is used to add an event listener to the input element, which checks the value length and slices it if it exceeds the specified limit.

Custom directives provide a powerful and flexible way to extend Vue’s core functionality to suit your specific requirements. By defining and using custom directives, you can add new features and behaviors to your Vue application easily and efficiently.

Vue Router 4: Enhanced Navigation and State Management

The latest version of Vue Router, Vue Router 4, comes with several new features and improvements that enhance navigation and state management in Vue applications.

Type-Safe Routing

One of the key changes in Vue Router 4 is the introduction of type-safe routing. With the new TypeScript support, you can now define the types for route parameters, query parameters, and meta fields. This provides better type checking and improves the development experience by catching errors at compile time.

Improved Navigation Guards

Vue Router 4 introduces a more flexible and powerful navigation guard API. You can now define global and per-route navigation guards using the new `beforeEach` and `beforeRouteLeave` methods. This allows you to control the navigation behavior and perform complex operations like authentication checks or data validation before entering or leaving a route.

Lazy Loading Routes

Lazy loading routes is now easier with Vue Router 4. You can use the new `import()` function syntax to dynamically import components only when they are needed. This helps to minimize the initial bundle size of your application and improves the loading performance.

Immutable Route Properties

Vue Router 4 introduces immutable route properties. This means that you can no longer directly modify the route properties like `params`, `query`, or `meta`, but instead, you need to use the provided methods for interacting with them. This ensures that the route state remains consistent and helps to prevent unintended side effects.

Composition API Integration

Vue Router 4 also integrates seamlessly with the Composition API of Vue 3. You can now use the new `useRoute` and `useRouter` functions to access the current route and router instances within your components. This simplifies the usage of the router in a composition-style setup and allows for better decoupling of logic.


Vue Router 4 brings several enhancements to the navigation and state management in Vue applications. With features like type-safe routing, improved navigation guards, lazy loading routes, immutable route properties, and Composition API integration, it provides a more robust and efficient routing solution for Vue developers.


What are the new major features introduced in Vue 3?

Vue 3 introduces several major features such as the Composition API, the new teleport component, better TypeScript support, enhanced performance with a new reactivity system, and many more improvements.

How does the Composition API differ from the Options API in Vue 2?

The Composition API in Vue 3 allows developers to organize their code logic into reusable composition functions, making it easier to share and compose logic across different components. It encourages a more modular and flexible approach to building components compared to the Options API in Vue 2.

What is the teleport component in Vue 3?

The teleport component in Vue 3 enables developers to dynamically render content at a different place in the component tree, regardless of the parent-child relationship. It provides a powerful tool for creating portals and modals in your application.

How does Vue 3 improve TypeScript support?

Vue 3 improves TypeScript support by providing enhanced typing for component props, emits, and slots. It also introduces the new `defineComponent` function which automatically infers and checks the types of the component options, making it easier to build type-safe Vue applications.

Does Vue 3 offer better performance compared to Vue 2?

Yes, Vue 3 comes with a new reactivity system called “Proxy-based reactivity” which brings significant performance improvements over the Object.defineProperty-based system used in Vue 2. It allows for better tracking of reactivity dependencies and enables faster rendering and updates for components.

Is it possible to use Vue 3 in an existing Vue 2 project?

Yes, it is possible to use Vue 3 in an existing Vue 2 project. However, there are some considerations and migration steps that need to be taken into account, as Vue 3 introduces some breaking changes. The Vue team provides a migration guide to help with the process.

What are some other notable improvements in Vue 3?

In addition to the major features mentioned previously, Vue 3 brings several other notable improvements, including better TypeScript support, improved performance, more flexible component rendering with fragments, better handling of async components, and improved error handling and warning system.