Documentation

Learn the small part first. Reach for the rest when you need it.

Nift's core model is intentionally compact: install one executable, track the files you want to build, put shared structure in templates and partials, and let Nift keep paths and incremental dependencies straight. Everything else in your web stack can stay itself.

The whole mental model in one paragraph.

A tracked name connects content, a template and an output. @content places the tracked content, @input(...) composes reusable files, @pathto(...) creates checked project-aware paths, and Nift records enough dependency information to rebuild the outputs affected by a change.

Start here.

If you are new to Nift, these four pages are the shortest route from installation to a useful project.

Install Nift

Use your platform's package manager, a release binary, or build the single native executable from source.

Create your first project

Run nift init yourself, or nift init --handover if you want a coding agent to start with Nift's project context.

Learn the tiny template surface

Most projects go a long way with @content, @input, @pathto, metadata and environment values.

Use the fast development loop

After the first build, let nift build rebuild only the outputs affected by what you changed.

Choose your starting style.

See the result

Built with Nift

See actual Nift projects and the architecture behind each one.

Starter projects

Begin with a polished template

Download a complete dark-mode Nift project and replace the design/content with your own.

AI-assisted

Initialize with a handover

Create the project with nift init --handover, let the agent read the canonical Nift context, then describe the site you actually want.

Migration

Bring an existing site

Keep the frontend you already have. Extract repeated structure instead of rewriting the project into a framework.

Start simple

Three primitives go a long way

See how @content, @input and @pathto alone can form the architecture of a serious site.

The everyday reference.

Core

Paths & links

Use @pathto to reuse links from any nesting depth and catch missing local targets during builds.

Template language

Comments

Use Nift comments for source-only notes and ordinary HTML comments when the comment belongs in the generated page.

Core language

Collection operations

Transform, query and aggregate immutable arrays with composable typed results, including filter/map/sort, sum/min/max and reduce.

Structured data

JSON data

Load immutable project JSON, chain member/index access and make it part of the dependency graph.

Validation

JSON Schema

Give structured data an optional standard schema so bad shapes and types fail at build time.

Full-stack pattern

Route contracts

Keep frontend route references tied to a declared application/API route catalogue without making Nift your backend router.

Project contracts

Checked project-wide values

Declare named JSON contract sources in config and consume them through the existing $[...] value model.

Core language

Expressions

Use the same pure expression model in $[...] and @if(...): arithmetic, comparisons, logic, precedence and lazy ternaries.

Structured data

Loops & conditions

Repeat arrays/objects and conditionally render scalar JSON data without introducing a scripting runtime.

Multi-output

Pagination

Collect rendered items, split them across deterministic pages and keep the whole set dependency-aware.

Core

Page & build metadata

Use tracked titles, names, paths, dates, times and build information with $[...].

Output

Minification

Minify final HTML, CSS, JavaScript, JSX, JSON, XML and SVG outputs automatically or use the standalone file command.

CLI

Commands

Track, build, inspect, watch, minify, move, copy and remove files.

Structure

Project layout

See how content/, templates/, public/ and the rest of your repository can fit together.

Understand what Nift is tracking.

.nift

config.json

Project-wide directories, extensions, template defaults, thread count, incremental mode, contracts and optional minified output extensions.

.nift

tracked.json

The names, titles and optional template/extension/minification overrides for tracked outputs, including template-less entries.

Explicit dependencies

@dep

Declare a dependency in the source exactly where the relationship matters.

Per-page metadata

*.deps.json

Declare additional file or directory dependencies beside a tracked content file.

Ship what you build.

Nift's responsibility can end at the generated files. Deploy public/ to a static host, serve it from your own backend, or package it into a larger application.

Deployment

Platform targets

Initialise provider-ready projects for Vercel, Netlify, Amplify, Azure, Firebase, Render, Cloudflare and GitHub Pages.

Deployment

Hosting & deployment

Generic static hosts, GitLab Pages, Supabase-backed applications, traditional servers, Docker and more.

Deployment architecture

Serverless stacks

Use Nift for static frontend generation alongside AWS Lambda, Azure Functions, Google Cloud, Supabase Edge Functions, Vercel, Netlify and GitHub Pages.

Understand the design when you are ready.

You do not need Nift's philosophy, implementation architecture or testing history to build your first site. These pages are intentionally later in the documentation: they are for evaluating the design, understanding internals, or deciding whether Nift is a good long-term fit.

Philosophy

Why Nift?

Why Nift stays deliberately small, keeps ordinary web technologies ordinary, and aims to provide project-aware glue rather than own your stack.

Build-time guarantees

Contracts

How Nift turns useful assumptions into checked relationships, dependencies and build-time assertions—and uses guarantees to drive feature design.

Design rules

Nift architectural rules

A concrete decision framework for what belongs in Nift, what stays external, safe defaults, source-compilation boundaries, incremental correctness and extractable subsystems.

Architecture

How Nift works

Follow tracked state through parsing, dependency discovery, rendering, build metadata, incremental decisions and parallel builds.

Ecosystem boundary

Nift and the wider toolchain

See where Nift deliberately stops and how npm, TypeScript, bundlers, frontend frameworks, backends and deployment tools fit around it.

Evaluate Nift after you have met it.

These pages answer questions about reliability and comparative fit. They are useful when you are deciding whether to trust or adopt Nift, but they should not stand between a newcomer and installation or Getting Started.

Developer experience

What working with Nift feels like

Evaluate Nift's small mental model, fast feedback loops, composable tooling philosophy, deliberate non-features and AI-DX.

Comparative fit

Nift vs other tools

Compare Nift with integrated web frameworks and frontend/UI choices such as Astro, Next.js, React, Vue, Svelte and SolidJS by architecture, strengths, weaknesses and project fit.

Quality & reliability

Battle tested

Explore the focused smoke tests, end-to-end regression coverage and adversarial cases used to protect parser, filesystem, JSON, incremental and CLI behaviour.

Living quality record

Memory & resource safety

Track the maintained leak, watch-mode endurance and large-project memory campaign, including exact evidence as those gates are rerun.

AI collaborator perspectives

AI opinion: Nift vs other tools

Hands-on assessments from ChatGPT, Codex and DeepSeek, including how those views changed through deeper engineering work and where another tool may still be the better choice.

Engineering process

AI-assisted development

How living handovers, bounded checkpoints, independent suites and source/generated publication boundaries make AI collaboration durable.

Current status

Production readiness

A candid assessment of Nift's supported contract, release evidence, operational limits and maintained production verdict.

Patterns for larger projects.

Full stack

Web applications

Pair Nift with Go, Node, Express, Python, APIs, authentication, databases and realtime backends.

Cross-platform web

Mobile development

Build a PWA or package Nift-generated web application assets for Android/iOS while leaving native APIs to the mobile wrapper.

Frontend

React / Vue / Svelte islands

Let a component framework own the interactive region without forcing it to own every document.

Content

Documentation projects

Compose shared navigation and technical content while incremental builds keep changes focused.

Application UI

Dashboards

Use Nift for the build-time shell and ordinary browser/runtime tooling for live data and interaction.

You do not need to read all of this before using Nift.

The documentation is intentionally broader than the core language. Start with installation, Getting Started and the template essentials. The rest is here when your project reaches the problem it explains.