giget vs degit vs tiged (2026)

# git clone downloads the ENTIRE history:
git clone https://github.com/nuxt/starter
# → Downloads all commits, branches, tags
# → .git directory is ~50MB for large repos
# → You just wanted the latest files

# What you actually want:
# → Download just the latest files
# → No .git directory
# → No commit history
# → Ready to start a new project

# Download from GitHub:
npx giget gh:nuxt/starter my-app
npx giget github:vitejs/vite/packages/create-vite/template-react-ts my-react-app

# Short syntax:
npx giget nuxt/starter my-app

# GitLab:
npx giget gitlab:user/repo my-project

# Bitbucket:
npx giget bitbucket:user/repo my-project

# Specific branch/tag:
npx giget gh:nuxt/starter#v3 my-app
npx giget gh:vuejs/create-vue#main my-vue-app

# Subdirectory:
npx giget gh:unjs/template/ts my-ts-project

import { downloadTemplate } from "giget"

// Download a template:
const { source, dir } = await downloadTemplate("gh:nuxt/starter", {
  dir: "./my-app",
  force: true,     // Overwrite existing directory
  install: false,  // Don't run npm install
})

console.log(`Downloaded from ${source} to ${dir}`)

// With options:
await downloadTemplate("gh:vitejs/vite", {
  dir: "./my-project",
  preferOffline: true,   // Use cache if available
  offline: false,         // Allow network requests
  cwd: process.cwd(),
  auth: process.env.GITHUB_TOKEN,  // For private repos
})

import { downloadTemplate } from "giget"

// Nuxt uses a custom registry for starters:
await downloadTemplate("nuxt", {
  registry: "https://raw.githubusercontent.com/nuxt/starter/templates/templates",
})

// Custom registry for your organization:
await downloadTemplate("my-template", {
  registry: "https://templates.mycompany.com",
})

// nuxi init uses giget to scaffold projects:
// npx nuxi init my-app

// Internally:
import { downloadTemplate } from "giget"

async function initProject(name: string, template: string = "v3") {
  await downloadTemplate(`nuxt/starter#${template}`, {
    dir: name,
    force: false,
  })

  console.log(`✅ Nuxt project created in ./${name}`)
  console.log(`   cd ${name} && npm install`)
}

# Download from GitHub:
npx degit user/repo my-project
npx degit sveltejs/template my-svelte-app

# Specific branch:
npx degit user/repo#dev my-project

# Specific tag:
npx degit user/repo#v1.0.0 my-project

# Subdirectory:
npx degit user/repo/path/to/subdir my-project

# GitLab / Bitbucket:
npx degit gitlab:user/repo my-project
npx degit bitbucket:user/repo my-project

# With verbose output:
npx degit -v user/repo my-project

import degit from "degit"

const emitter = degit("user/repo", {
  cache: true,
  force: true,
  verbose: true,
})

emitter.on("info", (info) => {
  console.log(info.message)
})

await emitter.clone("./my-project")

// degit.json — post-clone actions:
[
  {
    "action": "clone",
    "src": "user/another-repo"
  },
  {
    "action": "remove",
    "files": ["LICENSE", ".github"]
  }
]

degit:
  ✅ Simple CLI — npx degit user/repo dir
  ✅ Caching — downloads faster on repeat
  ✅ Post-clone actions (degit.json)
  ✅ Created by Rich Harris (Svelte author)

  ❌ Not actively maintained (last release 2020)
  ❌ GitHub API issues unfixed
  ❌ No private repo support (without workarounds)
  ❌ Limited programmatic API
  ❌ No TypeScript types

→ Use tiged (maintained fork) or giget instead

# Drop-in replacement for degit:
npx tiged user/repo my-project
npx tiged sveltejs/template my-svelte-app

# All degit syntax works:
npx tiged user/repo#branch my-project
npx tiged gitlab:user/repo my-project
npx tiged user/repo/subdir my-project

tiged improvements over degit:
  ✅ Fixed GitHub API rate limiting issues
  ✅ Fixed private repo downloading
  ✅ Fixed subdirectory extraction bugs
  ✅ Active maintenance (regular releases)
  ✅ TypeScript support
  ✅ Better error messages

Same API — just replace "degit" with "tiged":
  npx degit user/repo dir  →  npx tiged user/repo dir

import tiged from "tiged"

const emitter = tiged("user/repo", {
  cache: true,
  force: true,
  verbose: true,
})

emitter.on("info", (info) => {
  console.log(info.message)
})

emitter.on("warn", (warning) => {
  console.warn(warning.message)
})

await emitter.clone("./my-project")

// create-myapp — a minimal scaffolding CLI using giget
import { downloadTemplate } from "giget"
import { defineCommand, runMain } from "citty"

const main = defineCommand({
  meta: {
    name: "create-myapp",
    description: "Scaffold a new MyApp project",
  },
  args: {
    name: {
      type: "positional",
      description: "Project directory name",
      required: true,
    },
    template: {
      type: "string",
      description: "Template to use (default, typescript, minimal)",
      default: "default",
    },
  },
  async run({ args }) {
    const { name, template } = args

    console.log(`Scaffolding ${name} with ${template} template...`)

    const { source, dir } = await downloadTemplate(
      `gh:myorg/myapp-templates/${template}`,
      {
        dir: `./${name}`,
        force: false,
        install: false,
      }
    )

    console.log(`✅ Project created at ${dir}`)
    console.log(`   cd ${name} && npm install && npm run dev`)
  },
})

runMain(main)

// package.json for the create-* CLI:
{
  "name": "create-myapp",
  "bin": {
    "create-myapp": "./dist/index.mjs"
  },
  "dependencies": {
    "citty": "^0.1.6",
    "giget": "^1.2.3"
  }
}

# Via environment variable (recommended for CI):
GITHUB_TOKEN=ghp_your_token npx giget gh:myorg/private-template my-project

# Via CLI flag:
npx giget gh:myorg/private-template my-project --auth=ghp_your_token

// Programmatic with token:
await downloadTemplate("gh:myorg/private-template", {
  dir: "./my-project",
  auth: process.env.GITHUB_TOKEN,
})

# tiged can use GITHUB_TOKEN via environment variable
GITHUB_TOKEN=ghp_your_token npx tiged myorg/private-repo my-project

// giget — custom source providers:
import { downloadTemplate } from "giget"

// Self-hosted GitLab:
await downloadTemplate("gitlab:myorg/template", {
  dir: "./my-project",
  auth: process.env.GITLAB_TOKEN,
  // Custom GitLab instance:
  // registry: "https://gitlab.mycompany.com/api/v4"
})

# Manual approach:
git clone https://github.com/user/template my-project
rm -rf my-project/.git
cd my-project && npm install

# Problems:
# 1. Downloads entire git history (may be hundreds of MB for large repos)
# 2. Requires git to be installed (not always true in container environments)
# 3. No subdirectory support (git sparse checkout is complex)
# 4. No registry abstraction (can't use "nuxt/starter" shorthand)

# giget approach:
npx giget nuxt/starter my-project

# Advantages:
# 1. Downloads only latest commit (tarball — much faster)
# 2. Works in environments without git
# 3. Supports subdirectories: npx giget user/repo/path/to/subdir
# 4. Shorthand registry support

# Before:
npx degit user/repo my-project
npx degit user/repo#branch my-project

# After (identical syntax):
npx tiged user/repo my-project
npx tiged user/repo#branch my-project

# Programmatic — change only the import:
# Before:
import degit from "degit"
const emitter = degit("user/repo", { cache: true })

# After:
import tiged from "tiged"
const emitter = tiged("user/repo", { cache: true })

# CLI — syntax differs slightly:
# Before:
npx degit user/repo my-project
npx degit user/repo#branch my-project

# After:
npx giget gh:user/repo my-project
npx giget gh:user/repo#branch my-project

# Programmatic:
# Before:
import degit from "degit"
const emitter = degit("user/repo")
await emitter.clone("./my-project")

# After:
import { downloadTemplate } from "giget"
await downloadTemplate("gh:user/repo", { dir: "./my-project" })