Project Templates

Scaffolding lets you create new projects from pre-built templates. Instead of starting from scratch, choose a template and get a complete, working project structure with all necessary files, dependencies, and configurations.

Available Templates

Frontend Templates

React

React + TypeScript - Modern React with TypeScript, Vite, and Tailwind CSS
React + Next.js - Full-stack React with SSR, API routes, and TypeScript
React + Vite - Lightweight React setup with fast development server

Vue

Vue 3 + TypeScript - Vue 3 with Composition API, TypeScript, and Vite
Vue + Nuxt - Full-stack Vue with SSR, routing, and TypeScript

Svelte

Svelte + TypeScript - Svelte with TypeScript and Vite
SvelteKit - Full-stack Svelte with SSR and TypeScript

Backend Templates

Node.js

Express + TypeScript - REST API with Express, TypeScript, and MongoDB
Fastify + TypeScript - High-performance API with Fastify and TypeScript
NestJS + TypeScript - Enterprise-grade framework with dependency injection

Python

FastAPI - Modern async API with automatic documentation
Django - Full-featured web framework with ORM and admin
Flask - Lightweight API with SQLAlchemy

Other

Go + Gin - High-performance API with Gin framework
Rust + Actix - Safe, concurrent web server
Elixir + Phoenix - Fault-tolerant real-time applications

Full-Stack Templates

MERN Stack

MongoDB + Express + React + Node.js - Complete JavaScript stack
Includes authentication, CRUD operations, and deployment configs

JAMstack

Next.js + TypeScript + Prisma + PostgreSQL - Modern static/dynamic hybrid
Includes CMS integration, API routes, and hosting setup

Microservices

Docker + Node.js + Express + Redis - Containerized microservices
Includes service discovery, load balancing, and monitoring

Mobile Templates

React Native

React Native + TypeScript - Cross-platform mobile apps
Includes navigation, state management, and build configs

Flutter

Flutter + Dart - Native mobile apps with single codebase
Includes Material Design, state management, and testing

Using Scaffold

Quick Start

Click New App on welcome screen
Browse available templates
Select template
Configure project options
Click Create Project

Template Selection

Browse Categories - Frontend, Backend, Full-Stack, Mobile
Filter by Technology - React, Vue, Python, Node.js, etc.
Preview Template - See included files and structure
Read Description - Understand features and dependencies

Project Configuration

For each template, configure:

Basic Settings

Project Name - Human-readable name
Project ID - URL-friendly identifier
Description - Brief project description
Author - Your name or organization

Technical Settings

Package Manager - npm, yarn, pnpm, or bun
TypeScript - Enable/disable TypeScript support
Testing Framework - Jest, Vitest, or Pytest
Styling - CSS framework or preprocessor

Advanced Options

Git Repository - Auto-create GitHub repo
CI/CD - Setup GitHub Actions or similar
Deployment - Configure hosting provider
Environment - Development vs production settings

Template Features

Standard Inclusions

Every template includes:

Project Structure

project-name/
├── src/                    # Source code
├── public/                  # Static assets
├── tests/                   # Test files
├── docs/                    # Documentation
├── .gitignore              # Git ignore rules
├── package.json            # Dependencies and scripts
├── README.md               # Project documentation
└── config files            # TypeScript, linting, etc.

Development Tools

Package manager configuration - package.json, requirements.txt, etc.
Build system - Vite, Webpack, or equivalent
Linting and formatting - ESLint, Prettier, or equivalent
Testing setup - Test framework configuration and example tests
Development server - Hot reload and debugging

Documentation

README.md - Project overview and setup instructions
API documentation - Auto-generated or manual API docs
Contributing guide - Guidelines for contributors
License - Appropriate open source license

Template-Specific Features

React Templates

Component structure - Reusable component patterns
State management - Context API, Redux, or Zustand
Routing - React Router setup with example routes
Styling - CSS modules, styled-components, or Tailwind
Hooks - Custom hooks for common patterns

Node.js Templates

Express setup - Middleware configuration and error handling
Database integration - MongoDB, PostgreSQL, or SQLite setup
Authentication - JWT or session-based auth
API documentation - Swagger/OpenAPI setup
Environment config - Development and production settings

Python Templates

Virtual environment - venv or conda setup
Dependency management - pip or poetry configuration
Web framework - Flask, FastAPI, or Django setup
Database ORM - SQLAlchemy, Django ORM, or Tortoise
Testing - pytest configuration and example tests

Custom Templates

Creating Custom Templates

Create your own templates for team consistency:

Create template structure:

my-template/
├── template.json          # Template metadata
├── template/             # Project template files
│   ├── src/
│   ├── package.json
│   └── README.md
└── hooks/               # Post-generation scripts
    └── install.sh

Define template.json:

{
  "name": "My Custom Template",
  "description": "Custom template for our team's projects",
  "category": "Frontend",
  "technologies": ["React", "TypeScript", "Tailwind"],
  "version": "1.0.0",
  "author": "Your Name",
  "repository": "https://github.com/user/template-repo",
  "variables": [
    {
      "name": "projectName",
      "type": "string",
      "description": "Name of the project",
      "required": true
    },
    {
      "name": "includeAuth",
      "type": "boolean",
      "description": "Include authentication setup",
      "default": false
    }
  ]
}

Create template files with variables:

{
  "name": "{{projectName}}",
  "version": "1.0.0",
  "dependencies": {
    "react": "^18.0.0"
    {{#includeAuth}}
    ,"@auth0/auth0-react": "^2.0.0"
    {{/includeAuth}}
  }
}

Add post-generation hooks:

#!/bin/bash
echo "Installing dependencies..."
npm install
echo "Setting up git..."
git init
git add .
git commit -m "Initial commit from template"

Template Variables

Use variables in template files:

String Variables

{
  "name": "{{projectName}}",
  "description": "{{projectDescription}}"
}

Boolean Variables

{{#includeAuth}}
"dependencies": {
  "@auth0/auth0-react": "^2.0.0"
}
{{/includeAuth}}

Array Variables

"dependencies": {
{{#dependencies}}
  "{{name}}": "^{{version}}",
{{/dependencies}}
}

Local Templates

Store templates in:

~/.tarsk/templates/
├── my-react-template/
├── company-backend/
└── fullstack-template/

Remote Templates

Share templates via Git repository:

Create template repo on GitHub/GitLab
Add template URL in Tarsk settings:
```
https://github.com/user/template-repo
```
Templates auto-sync when creating new projects

Post-Scaffold Workflow

Initial Setup

After scaffold creation:

Automatic dependency installation
- Runs npm install, pip install, or equivalent
- Shows progress and any errors
- Creates lock files for reproducibility
Git initialization
- Creates .git repository
- Adds initial commit with template files
- Sets up remote if repository URL provided
Development server start
- Starts dev server automatically
- Opens browser to local URL
- Shows build status and any errors

First Steps

Explore the structure - Understand generated files and folders
Review configuration - Update package.json, environment files
Run tests - Verify everything works correctly
Customize - Add your specific logic and styling
Commit changes - Save your modifications

Common Customizations

Project Metadata

{
  "name": "my-awesome-project",
  "version": "0.1.0",
  "description": "A description of my project",
  "author": "Your Name",
  "license": "MIT"
}

Environment Configuration

DATABASE_URL=postgresql://user:pass@localhost:5432/db
JWT_SECRET=your-secret-key
API_KEY=your-api-key

Styling and Theming

:root {
  --primary-color: #3b82f6;
  --secondary-color: #64748b;
  --background-color: #ffffff;
}

Template Management

Updating Templates

When templates are updated:

Check for updates - Tarsk notifies of newer template versions
Review changes - See what’s new in updated template
Update existing projects - Apply changes to current projects
Migrate manually - Handle breaking changes carefully

Template Versions

Templates use semantic versioning:

Major (X.0.0) - Breaking changes, manual migration required
Minor (0.X.0) - New features, backward compatible
Patch (0.0.X) - Bug fixes, safe to update

Template Ratings and Feedback

Rate and review templates:

Use template - Create project from template
Provide feedback - Rate quality and documentation
Report issues - Help template authors improve
Share experiences - Help others choose templates

Best Practices

Choosing Templates

Match your stack - Choose technologies you know
Consider complexity - Start simple, add complexity later
Check maintenance - Active templates are more reliable
Read documentation - Understand included features
Preview structure - Ensure it fits your needs

Customizing Templates

Start with template - Don’t reinvent the wheel
Understand structure - Know why files are organized certain ways
Modify gradually - Make small changes and test
Keep improvements - Save customizations for future projects
Share back - Contribute improvements to template authors

Team Templates

Standardize - Create team-specific templates
Include conventions - Add coding standards and patterns
Document everything - Explain team-specific choices
Version control - Track template changes
Train team - Ensure everyone knows how to use templates

Scaffolding accelerates project setup while maintaining consistency and best practices across your organization’s projects.