Nift — Build the web without the baggage

Keep your HTML. Keep your tools. Stop repeating yourself.

Nift is a fast, dependency-aware templating and build system that adds reusable structure to web projects without asking you to hand over the rest of your stack.

⚡ Fast incremental builds▱ Dependency aware◇ Tiny mental model✦ AI-friendly♥ MIT licensed

Get started →View on GitHub ↗

Install with

Install docs →

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>$[title]</title>
    <link rel="stylesheet" href="@pathto('public/assets/site.css')">
  </head>
  <body>
    @input('templates/partials/header.html')
    <main>
      @content
    </main>
    <script src="@pathto('public/assets/app.js')"></script>
  </body>
</html>

<section class="hero">
  <h1>Build the web your way.</h1>
  <p>Keep your HTML, your tools and your stack.</p>
</section>

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Home</title>
    <link rel="stylesheet" href="assets/site.css">
  </head>
  <body>
    <header>...</header>
    <main>
      <section class="hero">
        <h1>Build the web your way.</h1>
        <p>Keep your HTML, your tools and your stack.</p>
      </section>
    </main>
    <script src="assets/app.js"></script>
  </body>
</html>

Small by design

Add the useful machinery. Keep everything else yours.

Nift does a focused job: track files, compose templates and content, resolve project-aware paths, and rebuild what changed. Your HTML, CSS, JavaScript, TypeScript, frameworks, backend and deployment choices remain yours.

□

Templates without a takeover

@content and @input are enough to remove duplicated layouts and reusable fragments from an ordinary website.

↪

Easy to adopt

Start with an existing HTML site, extract the pieces that repeat, and let Nift build the same frontend. A migration does not need to become a rewrite.

▱

Dependency aware

Included files become dependencies automatically, so changing a shared partial can rebuild the pages that actually use it.

↯

Built for speed

Written in C++ with fast full and incremental builds, Nift stays comfortable as projects grow.

♡

Use the wider ecosystem

npm, TypeScript, React, Vue, Svelte, Tailwind, Go, C++, APIs and image tools remain themselves. Nift does not need a special version of everything.

◇

Easy to reason about

A small set of explicit primitives makes the project easier to understand, debug, explain and hand to coding assistants.

Built to stay light

Fast tooling should disappear into the workflow.

Nift's architecture is deliberately lean: a native executable, multithreaded builds, dependency-aware incremental work and deployable output that can stay as simple as ordinary files.

Single native executable

The core tool does not require a project-local runtime dependency tree just to parse templates and build pages.

Multithreaded builds

When a project needs substantial work, Nift can build tracked outputs across multiple threads using the project's configured thread count.

Incremental by design

During normal development, nift build can focus on outputs affected by what changed instead of treating every edit like a full rebuild.

Tiny project footprint

A Nift site can remain mostly HTML, CSS, JavaScript and assets. Add other tooling only when the project actually needs it.

No browser runtime required

If the site does not need a client framework, Nift does not make you ship one. Generated HTML can just be HTML.

Scale work with the change

Change one page, rebuild one path through the graph. Change a shared partial, rebuild the outputs that depend on it.

Why Nift is designed this way →

AI-assisted development

Small enough to explain to an AI. Powerful enough to build the real site.

Nift does not need an AI subsystem to work well with AI coding assistants. Its advantage is that there is comparatively little Nift-specific machinery for an assistant to learn, hallucinate or fight against.

Give Copilot, ChatGPT or another coding assistant a short ai-context.txt explaining the handful of Nift primitives, then spend your actual prompt describing the website you want. Most of what the assistant edits remains ordinary HTML, CSS, JavaScript, TypeScript and whichever application stack you chose.

AI-assisted workflow →See stack examples →

ai-context.txt

This is a Nift v4 project.

@content inserts page content.
@input(...) composes reusable files.
@pathto(...) links tracked pages and local assets.

Keep the existing Nift architecture.
Use the project's normal HTML/CSS/JS/TS
and other tooling rather than replacing it.

Then ask for the portfolio, documentation site, product site, dashboard shell or application frontend you actually want.

The philosophy

Nift provides the glue without trying to become the universe.

Use Nift where composition and build tracking help. Leave everything else alone. A Nift project can be mostly ordinary web code because Nift is a layer in your stack, not a replacement for your stack.

Keep

Start with the HTML, assets and architecture you already understand.

Extract

Move repeated layouts and fragments into templates and partials.

Track

Let Nift understand pages, paths and dependencies.

Compose

Build the result without introducing machinery you did not ask for.

A deliberately short path

From a bare directory to reusable pages.

You can understand the core workflow without learning an application framework.

Initialise

nift init .html

Start from a small HTML project rather than a pile of generated framework machinery.

Compose

@input('templates/header.html')
@content

Extract repeated structure while keeping page content direct.

Build

nift build

During normal development, rebuild what Nift considers updated rather than reflexively rebuilding the whole site.

Existing site?

You do not need to start over.

Take repeated headers, navigation and footers out of your existing pages, put them in reusable files, keep each page's unique markup as content, and let Nift compose the result.

Convert an existing site →

# before
index.html
about.html
contact.html

# after
content/
templates/
public/

Bring your stack

Nift can sit beside the tools you already chose.

TypeScript, Vite, React, Vue, Svelte, Tailwind, Go, Node, Bun, Python, minifiers, bundlers and deployment tooling do not have to be absorbed into Nift to work with it.

HTMLCSSJavaScriptTypeScriptnpmBunViteReactVueSvelteTailwindGoNodeExpressPythonWebSockets

See how Nift fits into the wider ecosystem →

Use it your way

From plain HTML to full web applications.

Nift's build-time role does not constrain what your website becomes at runtime.

Existing sitesRefactor without rewriting DocumentationShared technical content Web appsNift + your backend UI islandsFrameworks where useful AI-assisted workSmall context, clear structure Text assetsCompose more than HTML

Start from something polished

Ten complete Nift projects you can actually download.

Ten dark starters are available on the templates page. Each stays intentionally small enough to understand immediately; the visual language changes while the Nift machinery barely does.

✦ Aurora · AI / SaaS Clear direction.

■ Forge · Developer tooling Ship the system.

$ forge deploy
✓ deployment ready

Meridian° · Studio Worth feeling.

MONUMENT

Browse and download all templates →

Human-readable. AI-readable.

The less framework-specific ceremony there is, the more attention can go to the website itself.

A coding assistant can reason about Nift's small build model and then work mostly in familiar web technologies. That makes Nift particularly interesting as AI-assisted development shifts from generating snippets toward maintaining whole repositories.

Give an AI a Nift project →

A deliberately small contract

“We don't care how you build your website. Here's a really fast templating/build layer. Carry on.”

Nift gives you the pieces that benefit from project awareness—composition, metadata, paths and dependencies—then gets out of the way.

Explore the docs →