# Linux / macOS / WSL — official installer
curl -fsSL https://deno.land/install.sh | sh

# macOS — Homebrew
brew install deno

# Windows — PowerShell
powershell -c "irm https://deno.land/install.ps1 | iex"

# Cargo (from Rust source)
cargo install deno --locked

deno --version

deno 2.1.4 (stable, release, x86_64-unknown-linux-gnu)
v8 13.0.245.12
typescript 5.6.2

deno upgrade

Looking up latest version
Found latest version 2.1.6
Checking https://github.com/denoland/deno/releases/...
Deno is upgrading to version 2.1.6
Upgraded successfully to Deno 2.1.6

deno <subcommand> [permissions] [args] file.ts -- [script-args]

# Zero permissions — fetch() throws "Requires net access"
deno run script.ts

# Grant network only
deno run --allow-net script.ts

# Grant network to a specific host
deno run --allow-net=api.example.com script.ts

# Read access scoped to a directory
deno run --allow-read=./data script.ts

# Read + write
deno run --allow-read --allow-write script.ts

# Environment variables (allowlist named vars)
deno run --allow-env=NODE_ENV,DATABASE_URL script.ts

# Subprocess spawning
deno run --allow-run=git,ls script.ts

# Foreign function interface (FFI)
deno run --allow-ffi=./libsqlite.so script.ts

# All permissions (escape hatch — equivalent to running as Node)
deno run -A script.ts
deno run --allow-all script.ts

error: Uncaught (in promise) NotCapable: Requires net access to "api.example.com",
run again with the --allow-net flag

deno run script.ts

⚠️  Deno requests net access to "api.example.com".
├ Requested by `fetch()` API.
├ Run again with --allow-net to bypass this prompt.
└ Allow? [y/n/A] (y = yes, allow; n = no, deny; A = allow all net access) ›

// server.ts — TypeScript with no setup
interface User {
  name: string;
  email: string;
}

const user: User = { name: "Alice Dev", email: "alice@example.com" };
console.log(`Welcome, ${user.name}!`);

deno run server.ts

Welcome, Alice Dev!

deno check server.ts

Check file:///home/alice/server.ts

{
  "compilerOptions": {
    "lib": ["deno.window", "dom"],
    "strict": true,
    "noUncheckedIndexedAccess": true
  }
}

{
  "name": "@alicedev/myapp",
  "version": "0.1.0",
  "exports": "./mod.ts",
  "tasks": {
    "dev": "deno run --watch --allow-net --allow-env server.ts",
    "test": "deno test --allow-read",
    "build": "deno compile --allow-net --output dist/server server.ts"
  },
  "imports": {
    "@std/assert": "jsr:@std/assert@^1.0.0",
    "@std/path": "jsr:@std/path@^1.0.0",
    "hono": "jsr:@hono/hono@^4.6.0",
    "lodash": "npm:lodash@^4.17.21"
  },
  "fmt": { "lineWidth": 100, "indentWidth": 2 },
  "lint": { "rules": { "tags": ["recommended"] } },
  "exclude": ["dist/", "coverage/"]
}

# List available tasks
deno task

# Run a task
deno task dev

# Pass extra args after --
deno task test -- --filter "User"

Available tasks:
- dev
    deno run --watch --allow-net --allow-env server.ts
- test
    deno test --allow-read
- build
    deno compile --allow-net --output dist/server server.ts

# Add a JSR package — writes to deno.json imports
deno add jsr:@std/path
deno add jsr:@std/assert@^1.0.0

# Add an npm package
deno add npm:lodash

# Remove
deno remove @std/path

Add @std/path - jsr:@std/path@^1.0.8

// app.ts
import { join } from "@std/path";
import { assertEquals } from "@std/assert";
import _ from "lodash";

console.log(join("/home/alice", "docs", "file.txt"));

deno run app.ts

/home/alice/docs/file.txt

// no install — just import a versioned URL
import { serve } from "https://deno.land/std@0.224.0/http/server.ts";

serve((_req) => new Response("Hello Alice Dev!"));

deno run --allow-net server.ts

Listening on http://0.0.0.0:8000/

deno run --reload --allow-net server.ts

// Node-style imports both work
import express from "npm:express@^4.19.0";
import { readFile } from "node:fs/promises";
import process from "node:process";

const text = await readFile("./config.json", "utf8");
console.log("PID:", process.pid);

deno run --allow-read --allow-env server.ts

PID: 12345

# Format every supported file under the cwd
deno fmt

# Format a single file
deno fmt src/server.ts

# Check formatting without writing (CI-friendly — exits non-zero if changes needed)
deno fmt --check

from src/server.ts:
   3 |   const user = { name: "Alice Dev", email: "alice@example.com" }
     +   const user = { name: "Alice Dev", email: "alice@example.com" };

Found 1 not formatted file in 12 files

# Lint everything
deno lint

# Lint one file
deno lint src/server.ts

# List all available rules
deno lint --rules

# JSON output for editor integrations
deno lint --json

(no-unused-vars) `oldVar` is never used
   at file:///home/alice/src/server.ts:5:7

  hint: If this is intentional, prefix it with an underscore like `_oldVar`
  help: for further information visit https://lint.deno.land/rules/no-unused-vars

Found 1 problem (0 fixable via --fix)

// math_test.ts
import { assertEquals } from "@std/assert";

Deno.test("add() adds positives", () => {
  assertEquals(2 + 3, 5);
});

Deno.test("permission scoped", {
  permissions: { read: ["./fixtures"] },
}, async () => {
  const data = await Deno.readTextFile("./fixtures/sample.txt");
  assertEquals(data.trim(), "hello");
});

Deno.test("nested steps", async (t) => {
  await t.step("step 1", () => assertEquals(1, 1));
  await t.step("step 2", () => assertEquals(2, 2));
});

deno test --allow-read=./fixtures

running 3 tests from ./math_test.ts
add() adds positives ... ok (3ms)
permission scoped ... ok (7ms)
nested steps ...
  step 1 ... ok (0ms)
  step 2 ... ok (0ms)
nested steps ... ok (1ms)

ok | 3 passed (2 steps) | 0 failed (12ms)

deno test --coverage=cov/
deno coverage cov/ --lcov --output=lcov.info

file:///home/alice/math.ts             100.000% (8/8 lines)
file:///home/alice/user.ts              91.667% (11/12 lines)

// hash_bench.ts
import { crypto } from "@std/crypto";

const input = new TextEncoder().encode("a".repeat(1024));

Deno.bench("sha-256", { group: "hash", baseline: true }, async () => {
  await crypto.subtle.digest("SHA-256", input);
});

Deno.bench("sha-512", { group: "hash" }, async () => {
  await crypto.subtle.digest("SHA-512", input);
});

deno bench

benchmark    time (avg)        iter/s    (min … max)
-----------------------------------------------------
sha-256       4.21 µs/iter     237,529   (4.05 µs … 7.81 µs)
sha-512       6.14 µs/iter     162,866   (5.98 µs … 9.42 µs)

summary
  sha-256
   1.46x faster than sha-512

# Compile for the current platform
deno compile --allow-net --output mycli cli.ts

# Cross-compile from macOS to Linux ARM64
deno compile --allow-net --target=aarch64-unknown-linux-gnu --output mycli-linux cli.ts

# Cross-compile to Windows
deno compile --allow-net --target=x86_64-pc-windows-msvc --output mycli.exe cli.ts

# Include an asset (read at runtime via Deno.readTextFile from $DENO_DIR)
deno compile --include=./templates --allow-read=./templates --output mycli cli.ts

Compile file:///home/alice/cli.ts to mycli

# Start REPL
deno repl

# One-shot inline script
deno eval 'console.log(Math.PI * 2)'

6.283185307179586

deno repl

Deno 2.1.4
exit using ctrl+d, ctrl+c, or close()
REPL is running with all permissions allowed.
To specify permissions, run `deno repl` with allow flags.
> const x = [1, 2, 3]
undefined
> x.reduce((a, b) => a + b, 0)
6
> Deno.version
{ deno: "2.1.4", v8: "13.0.245.12", typescript: "5.6.2" }

// cli.ts
import { parseArgs } from "jsr:@std/cli/parse-args";

const args = parseArgs(Deno.args, {
  string: ["name"],
  default: { name: "world" },
});

console.log(`Hello, ${args.name}!`);

deno compile --output hello cli.ts
./hello --name "Alice Dev"

Compile file:///home/alice/cli.ts to hello
Hello, Alice Dev!

deno compile --target=aarch64-unknown-linux-gnu --output hello-linux-arm64 cli.ts
file hello-linux-arm64

hello-linux-arm64: ELF 64-bit LSB executable, ARM aarch64, version 1 (SYSV), statically linked

// proxy.ts
Deno.serve({ port: 3000 }, async (req) => {
  const url = new URL(req.url);
  if (url.pathname === "/star-count") {
    const res = await fetch("https://api.github.com/repos/denoland/deno");
    const data = await res.json();
    return Response.json({ stars: data.stargazers_count });
  }
  return new Response("Not Found", { status: 404 });
});

deno run --allow-net=0.0.0.0:3000,api.github.com proxy.ts

Listening on http://0.0.0.0:3000/

// deno.json
{
  "tasks": {
    "ci": "deno fmt --check && deno lint && deno check **/*.ts && deno test --coverage=cov/"
  }
}

deno task ci

$ deno fmt --check && deno lint && deno check **/*.ts && deno test --coverage=cov/
Checked 23 files
Checked 23 files
Check file:///home/alice/myapp/server.ts
running 12 tests from ./...
ok | 12 passed | 0 failed (218ms)

// fetch-stars.ts (was a Node script)
const [repo = "denoland/deno"] = Deno.args;
const res = await fetch(`https://api.github.com/repos/${repo}`);
const { stargazers_count } = await res.json();
console.log(`${repo}: ${stargazers_count} stars`);

deno run --allow-net=api.github.com fetch-stars.ts denoland/deno

denoland/deno: 97624 stars

// deno.json
{
  "name": "@alicedev/greetings",
  "version": "0.1.0",
  "exports": "./mod.ts"
}

// mod.ts
export function greet(name: string): string {
  return `Hello, ${name}!`;
}

deno publish --dry-run

Checking for slow types in the public API...
Check file:///home/alice/greetings/mod.ts
Publishing @alicedev/greetings@0.1.0 ...
Would have published @alicedev/greetings@0.1.0 (dry run)