Skip to main content

How to use Vue with Deno

Vue is a progressive front-end JavaScript framework, built for performance and versatility.

This How To guide will show you how to create a simple app using Deno, Vite, and Vue.

View source or follow the video guide.

Run npm:create-vite-extra

We'll use Vite to scaffold our Vue app. First, run:

deno run --allow-read --allow-write --allow-env npm:create-vite-extra@latest

Name your project, then select "deno-vue".

Then, cd into your new project and run:

deno task dev

You should now be able to view your default Deno and Vue app in your browser:

default vue app

Add a backend

The next step is to add a backend API. We'll create a very simple API that returns information about dinosaurs.

In the directory, let's create an api folder. In that folder, we'll create a main.ts file, which will run the server, and a data.json, which is the hard coded data.

mkdir api && touch api/data.json && touch api/main.ts

Copy and paste this json file into your api/data.json.

Then, let's update api/main.ts:

import { Application, Router } from "";
import { oakCors } from "";
import data from "./data.json" assert { type: "json" };

const router = new Router();
.get("/", (context) => {
context.response.body = "Welcome to dinosaur API!";
.get("/api", (context) => {
context.response.body = data;
.get("/api/:dinosaur", (context) => {
if (context?.params?.dinosaur) {
const found = data.find((item) => === context.params.dinosaur.toLowerCase()
if (found) {
context.response.body = found;
} else {
context.response.body = "No dinosaurs found.";

const app = new Application();
app.use(oakCors()); // Enable CORS for All Routes

await app.listen({ port: 8000 });

This is a very simple API server using oak that will return dinosaur information based on the route. Let's start the API server:

deno run --allow-env --allow-net api/main.ts

If we go to localhost:8000/api, we see:

json response of dinosaurs

Lookin' good so far.

Add Vue components

Let's update src/components. We'll add the files:

  • HomePage.vue, the component for the home page
  • Dinosaurs.vue, the component that lists all dinosaur names as anchor links, and
  • Dinosaur.vue, the component that shows an individual dinosaur's name and description
touch src/components/HomePage.vue src/components/Dinosaurs.vue src/components/Dinosaur.vue

Before we create the components, let's add some state management.

Maintain state with store

In order to maintain state across our <Dinosaur> and <Dinosaurs> components, we'll use Vue store. Note for more complex state management, check out the Vue-endorsed Pinia library.

Create a src/store.js file:

touch src/store.js

And in it, let's add:

import { reactive } from "vue";

export const store = reactive({
dinosaur: {},
setDinosaur(name, description) { = name;
this.dinosaur.description = description;

We'll import store into both Dinosaurs.vue and Dinosaur.vue to set and retrieve dinosaur name and description.

Update Vue components

In Dinosaurs.vue, we'll do three things:

  • send a GET request to our API and return that as dinosaurs
  • iterate through dinosaurs and render each dinosaur in <router-link> that points to the <Dinosaur> component
  • add store.setDinosaur() to @click on each dinosaur, which will set the store

Here is the complete code below:

import { ref } from 'vue'
import { store } from '../store.js'
export default ({
async setup() {
const res = await fetch("http://localhost:8000/api")
const dinosaurs = await res.json();
return {
data() {
return {

<div class="container">
<div v-for="dinosaur in dinosaurs" class="dinosaur-wrapper">
<span class="dinosaur">
<router-link :to="{ name: 'Dinosaur', params: { dinosaur: `${}` }}">
<span @click="store.setDinosaur(, dinosaur.description)">

<style scoped>
.dinosaur {
.dinosaur-wrapper {
display: inline-block;
margin: 0.15rem 1rem;
padding: 0.15rem 1rem;
.container {
text-align: left;

In Dinosaur.vue, we'll add:

  • importing store
  • rendering store.dinosaur in the HTML
import { store } from '../store.js';
export default {
data() {
return {

Name: {{ }}
<br />
Description: {{ store.dinosaur.description }}

Next, we'll update HomePage.vue. Since the Dinosaurs component needs to fetch the data from the API, we'll use <Suspense>, which manages async dependencies in a component tree.

import { ref } from 'vue'
import Dinosaurs from './Dinosaurs.vue'
export default {
components: {

<template #default>
<Dinosaurs />
<template #fallback>

Check out
<a href="" target="_blank"
>, the official Vue + Vite starter
<p class="read-the-docs">Learn more about using Deno and Vite.</p>

<style scoped>
.read-the-docs {
color: #888;

Tying it all together, let's update src/App.vue:

<router-view />

Add routing

You'll notice that we have used <router-link> and <router-view>. These components are part of the vue-router library, which we'll have to setup and configure in another file.

First, let's import vue-router in our vite.config.mjs file:

import { defineConfig } from "npm:vite@^3.1.3";
import vue from "npm:@vitejs/plugin-vue@^3.2.39";

import "npm:vue@^3.2.39";
import "npm:vue-router@4";

export default defineConfig({
plugins: [vue()],

Next, let's create a folder named router. In it, let's create index.ts:

mkdir router && touch router/index.ts

In router/index.ts, we'll create router, which contains information about each route and their component, and export it. For more information on using vue-router, check out their guide.

import { createRouter, createWebHistory } from "vue-router";
import HomePage from "../components/HomePage.vue";
import Dinosaur from "../components/Dinosaur.vue";

const routes = [
path: "/",
name: "Home",
component: HomePage,
path: "/:dinosaur",
name: "Dinosaur",
component: Dinosaur,
props: true,

const router = createRouter({
history: createWebHistory("/"),

export default router;

Next, in our src/main.ts file, which contains all of the logic for the frontend app, we'll have to import and use router:

import { createApp } from "vue";
import "./style.css";
import App from "./App.vue";
import router from "./router/index.ts";

const app = createApp(App);

Let's run it and see what we get so far:

Clicking on a dinosaur to get to an individual dinosaur page