cscharf.de — posts

Hello World

2026-08-16T00:00:00Z

Welcome to your new Kiln site!

This is your first post. Edit it or create new .md files in content/posts/.

Code highlighting

Kiln uses Prism.js for syntax highlighting:

var site = new KilnSite("My Site");
site.Build();

console.log("Hello, Kiln!");

Pflegeelternschaft und Verantwortung: Was Alltag wirklich lehrt

2026-08-16T00:00:00Z

Im Alltag von Pflegeelternschaft gibt es wenig Platz für perfekte Lösungen. Vielmehr geht es darum, stabil zu bleiben, wenn sich Situationen schwer einschätzen lassen und man trotzdem verantwortungsvoll handeln muss.

Verantwortung ist kein Konzept, sondern Alltag

Es ist leicht, Verantwortung als etwas Abstraktes zu sehen – als Leitbild oder als berufliches Schlagwort. In der Praxis ist sie ein ständiger Rhythmus aus Aufmerksamkeit, Geduld, Anpassung und Klarheit.

Man muss Dinge abwägen, priorisieren und im Zweifel Entscheidungen treffen, die weder einfach noch sauber sind. Genau dort zeigt sich, was wirklich zählt: Haltung und Klarheit.

Die Verbindung zur Technik

Vielleicht ist es gerade deshalb, dass mich Architektur und Verantwortung so nahe verbinden. In beiden Bereichen geht es um Systeme, Grenzen, Wechselwirkungen und die Frage, was tragfähig ist.

Gute Entscheidungen entstehen oft nicht durch Perfektion, sondern durch die Bereitschaft, die vorhandenen Zusammenhänge ernst zu nehmen und danach handelbar zu bleiben.

Was ich daraus mitnehme

Pflegeelternschaft hat mich in einer sehr konkreten Weise gelehrt, dass gute Lösungen nicht immer die elegantesten sind. Oft sind sie die verständlichsten, die am meisten stabilisieren und die am ehesten im echten Leben funktionieren.

Das gilt für Technik genauso wie für den Alltag.

Fazit

Im Kern geht es um dieselbe Sache: echte Verantwortung ist nicht die Abwesenheit von Ungewissheit, sondern die Fähigkeit, auch in komplexen Situationen klar, menschlich und stabil zu bleiben.

Das ist eine Haltung, die ich auch beim Entwerfen von Systemen respektiere – und die ich im Leben täglich neu erlebe.

Dataverse-Architektur: Warum gute Grenzen wichtiger sind als mehr Features

2026-08-16T00:00:00Z

Dataverse ist eine starke Plattform. Genau deshalb ist die Architekturentscheidung so wichtig: Zu viel Komplexität entsteht oft nicht durch die Technik selbst, sondern durch die fehlenden Grenzen.

Die zentrale Frage

Wenn eine Plattform viele Möglichkeiten bietet, entsteht schnell die Versuchung, alles in einem Modell zu lösen. Das ist genau dort problematisch, wo Dataverse-Projekte an Komplexität verlieren.

Eine gute Dataverse-Architektur beginnt daher nicht mit Features, sondern mit klaren Verantwortlichkeiten:

Was gehört in Dataverse?
Was gehört in eine externe API?
Was wird durch Power Automate gelöst?
Wo liegt die fachliche Verantwortung?

Grenzen sind keine Einschränkung

Viele Teams sehen Grenzziehung als Verzicht. In der Praxis ist sie aber ein Designmittel. Gute Grenzen machen Lösungen verständlich, testbar und wartbar.

Das gilt vor allem dann, wenn mehrere Business-Streams auf derselben Plattform arbeiten. Sobald Rollen, Prozesse und Integrationen miteinander verschmelzen, verlieren Teams schnell die Übersicht.

Architektur heißt auch Governance

Ein gutes Dataverse-Setup ist nicht nur technisch sauber, sondern auch governancefähig:

klare Namenskonventionen
verständliche Modellgrenzen
eindeutige Verantwortlichkeiten
nachvollziehbare Integrationsmuster

Ohne Governance entsteht schnell eine Plattform, die anfänglich nützlich wirkt, langfristig aber schwer zu beherrschen ist.

Mein Fazit

Dataverse ist keine „einfach alles“-Lösung. Es ist eine Plattform mit Potenzial, aber nur dort wirklich stark, wo Architektur und Verantwortung sauber zusammenspielen.

Wenn wir Lösungen mit klaren Grenzen und echten fachlichen Verantwortlichkeiten bauen, wird Dataverse zu einem echten Basis- und Integrationsbaustein – und nicht zu einer unübersichtlichen Technikkulisse.

Welcome to Kiln

2026-08-16T00:00:00Z

Welcome to Kiln, a powerful and flexible static site generator built on .NET.

This blog demonstrates all the features Kiln offers out-of-the-box. Read through these posts to learn how Kiln works and what you can build with it.

What is Kiln?

Kiln transforms your Markdown content into a blazing-fast static website. No database, no server complexity — just pure, fast HTML served anywhere.

Key Features

Content Collections: Organize your posts, pages, and custom collections
Markdown-First: Write in Markdown, customize with Frontmatter
Built-in Taxonomies: Tags, categories, or custom taxonomies
Code Highlighting: Prism.js integration for syntax highlighting
Page Bundles: Co-locate assets with your content
Theming: Flexible template system with Liquid/Scriban
Plugins: Extend Kiln with custom functionality
Performance: Lightning-fast builds and deployments

Start exploring — each post showcases a different Kiln feature. Happy building!

Markdown Showcase

2026-08-15T00:00:00Z

This post demonstrates Markdown formatting capabilities supported by Kiln.

Headings

All heading levels (h2-h6) are supported. Use ## for h2, ### for h3, and so on.

Text Formatting

You can use bold and italic text. You can also use bold and italic together.

You can create ~~strikethrough~~ text and inline code.

Lists

Unordered Lists

Item one
Item two
- Nested item
- Another nested item
Item three

Ordered Lists

First item
Second item
Third item

Blockquotes

This is a blockquote. You can use blockquotes to highlight important information or quotes from other sources.

Blockquotes can be nested too!

Tables

Feature	Support	Notes
Markdown	✓	Full GFM support
Frontmatter	✓	YAML format
Links	✓	Internal and external
Images	✓	Relative and absolute paths

Links and Images

Link to Kiln repository

Images are embedded the same way as Markdown links, with an exclamation mark prefix:

Code Blocks

Inline code uses backticks: var x = 42;

Code blocks are created with triple backticks and optional language identifier:

// Plain text code block
const greeting = "Hello, Kiln!";

Learn more about code highlighting in the next post!

Code Highlighting with Prism.js

2026-08-14T00:00:00Z

Kiln integrates Prism.js for beautiful syntax highlighting across all supported languages.

C# Example

using System;
using Kiln.Core;

public class SiteBuilder
{
    private readonly Configuration _config;

    public SiteBuilder(Configuration config)
    {
        _config = config ?? throw new ArgumentNullException(nameof(config));
    }

    public void Build()
    {
        Console.WriteLine($"Building {_config.Title}...");
        // Build your site here
    }
}

JavaScript/TypeScript

// Frontend interactivity with Kiln
class SiteNavigator {
  constructor(rootSelector) {
    this.root = document.querySelector(rootSelector);
    this.init();
  }

  init() {
    console.log("Initializing site navigation...");
    this.attachEventListeners();
  }

  attachEventListeners() {
    document.querySelectorAll('a[data-nav]')
      .forEach(link => {
        link.addEventListener('click', (e) => this.navigate(e));
      });
  }
}

// Initialize on page load
document.addEventListener('DOMContentLoaded', () => {
  new SiteNavigator('[data-navigator]');
});

YAML Configuration

title: My Kiln Site
description: A blazingly fast static site
baseUrl: https://example.com
theme: default

collections:
  posts:
    directory: content/posts
    permalink: /blog/:slug/
    sort: date desc
    taxonomies:
      - tags
      - categories

taxonomies:
  tags:
    permalink: /tags/:slug/
  categories:
    permalink: /categories/:slug/

HTML/CSS

<article class="post">
  <header class="post-header">
    <h1 class="post-title">{{ page.title }}</h1>
    <time class="post-date">{{ page.date | format_date }}</time>
  </header>
  <div class="post-content">
    {{ content }}
  </div>
</article>

.post {
  max-width: 65ch;
  margin: 2rem auto;
  padding: 1rem;
  font-family: system-ui, -apple-system, sans-serif;
}

.post-header {
  border-bottom: 2px solid var(--color-primary);
  padding-bottom: 1rem;
  margin-bottom: 1.5rem;
}

.post-title {
  margin: 0.5rem 0;
  font-size: 2rem;
}

Prism supports 60+ languages out of the box. Check the language identifier in the code fence to enable highlighting!

Working with Collections

2026-08-13T00:00:00Z

Collections are the heart of Kiln. They organize your content into logical groups with consistent structure, metadata, and rendering.

What is a Collection?

A collection is a directory of content items (Markdown files) that share:

A common location (e.g., content/posts/)
Consistent Frontmatter structure
Shared layout template
Optional sorting and pagination rules

Built-in Collections

Kiln includes two default collections:

Posts Collection

collections:
  posts:
    directory: content/posts
    permalink: /blog/:slug/
    sort: date desc
    layout: post
    paginate: 10

Posts are sorted by date (newest first), paginated at 10 items per page, and rendered with the post.html layout.

Pages Collection

collections:
  pages:
    directory: content/pages
    permalink: /:slug/
    sort: weight asc
    layout: page

Pages are sorted by weight (Frontmatter field), allowing you to control menu order.

Creating Custom Collections

You can create as many collections as you need. Example:

collections:
  projects:
    directory: content/projects
    permalink: /portfolio/:slug/
    layout: project
    taxonomies:
      - technologies
      - year

Each item in the collection becomes a page with its own URL and can be listed on category pages.

Collection Metadata

Every item in a collection automatically gets:

url: The generated URL
slug: URL-friendly name
content: Rendered HTML
title, date, tags: Custom Frontmatter
collection: The collection name

This metadata is available in templates for navigation, related posts, and more.

Accessing Collections

In Kiln templates, you can iterate over collections:

{% for post in collections.posts %}
  <article>
    <h2><a href="{{ post.url }}">{{ post.title }}</a></h2>
    <time>{{ post.date }}</time>
  </article>
{% endfor %}

Collections make it easy to build blogs, portfolios, documentation sites, and more!

Taxonomies and Tags

2026-08-12T00:00:00Z

Taxonomies in Kiln let you organize and cross-reference your content through tags, categories, or any custom dimension.

What are Taxonomies?

A taxonomy is a classification system applied to collection items via Frontmatter. Common examples:

Tags: Topics or keywords (e.g., kiln, getting-started, development)
Categories: Broader groupings (e.g., tutorial, feature, announcement)
Authors: For multi-author blogs
Years: For chronological archives
Technologies: For portfolio sites

Defining Taxonomies

Taxonomies are configured in site.yaml:

taxonomies:
  tags:
    permalink: /tags/:slug/
    paginate: 20
  categories:
    permalink: /categories/:slug/
    paginate: 10

And applied to collections:

collections:
  posts:
    taxonomies:
      - tags
      - categories

Using Tags in Frontmatter

Simply add a list to your Frontmatter:

---
title: My Post
tags:
  - kiln
  - getting-started
  - documentation
categories:
  - tutorial
---

Generated Pages

Kiln automatically generates:

/tags/kiln/ — All posts tagged "kiln"
/tags/getting-started/ — All posts tagged "getting-started"
/categories/tutorial/ — All posts categorized "tutorial"

Paginated at the configured limit.

Displaying Taxonomy Links

In templates, display tags and categories:

<div class="post-tags">
  {% for tag in page.tags %}
    <a href="/tags/{{ tag | slugify }}/" class="tag">{{ tag }}</a>
  {% endfor %}
</div>

<div class="post-categories">
  {% for cat in page.categories %}
    <span class="category">{{ cat }}</span>
  {% endfor %}
</div>

Benefits

Discoverability: Readers find related content through tags
SEO: Dedicated tag pages for keyword targeting
Organization: Structure content without rigid hierarchies
Flexibility: Add or remove tags without changing permalinks

Taxonomies are a powerful way to organize and surface your content!

Page Bundles and Images

2026-08-12T00:00:00Z

Page Bundles are directories that group a post with its associated assets (images, documents, etc.). This keeps your content organized and simplifies asset references.

Traditional Asset Organization

Without page bundles, you might structure assets like this:

content/
├── posts/
│   ├── my-post.md
│   └── another-post.md
assets/
└── images/
    ├── my-post-header.png
    └── another-post-diagram.svg

This separates content from assets, making it hard to manage.

Page Bundle Structure

With page bundles:

content/
└── posts/
    ├── my-post/
    │   ├── index.md.template
    │   ├── header.png
    │   └── diagram.svg
    └── another-post/
        ├── index.md.template
        └── screenshot.jpg

Each post is a directory with its own content and assets.

Benefits

Co-location: Content and assets live together
Easier management: No hunt through global asset folders
Better scaling: Hundreds of posts without losing track
Reproducibility: Move a post dir, everything moves with it
Versioning: Assets change with their content

Referencing Assets

In your Markdown, reference assets by relative path:

![Post header](./header.png)

![Diagram](./diagram.svg)

[Download PDF](./resources.pdf)

When Kiln builds, it:

Copies header.png to _site/assets/content/posts/my-post/
Updates the Markdown link to /assets/content/posts/my-post/header.png
Preserves the file with its original name and format

Asset URL Structure

Assets are namespaced by location:

/assets/content/posts/06-page-bundles-and-images/ — Post bundle assets
/assets/content/pages/about/ — Page bundle assets (if applicable)
/assets/shared/ — Global shared assets

This namespace makes cache-busting and organization predictable.

Creating a Bundle

Create a directory: content/posts/my-post/
Move your post content to index.md.template
Add images/assets to the same directory
Kiln handles the rest!

mkdir -p content/posts/my-new-post
echo "---
id: {{ID-new}}
title: My New Post
---

# Welcome

![Image](./my-image.png)" > content/posts/my-new-post/index.md.template

cp ~/my-image.png content/posts/my-new-post/

Advanced Use Cases

Multiple images in one post

my-post/
├── index.md.template
├── diagram-1.svg
├── diagram-2.svg
├── screenshots/
│   ├── ui-before.png
│   └── ui-after.png
└── data.json

Embedding data files

{% include './data.json' %}

Using images in templates

<img src="{{ page.relative_url }}diagram.png" alt="Architecture">

Best Practices

Organize by type: images/, data/, documents/
Use descriptive names: feature-comparison.svg not img1.png
Compress media: Reduce file sizes before bundling
Document references: In Markdown comments, list what assets are included

Page bundles are a powerful way to organize scalable content sites!

See the Kiln Architecture diagram below — this entire post is a page bundle!

Theming with Kiln

2026-08-11T00:00:00Z

Kiln's theming system makes it easy to customize the look and feel of your site without touching core functionality.

Theme Structure

A Kiln theme is organized as:

themes/
└── default/
    ├── layouts/          # Page templates
    │   ├── default.html
    │   ├── post.html
    │   └── page.html
    ├── partials/         # Reusable components
    │   ├── header.html
    │   ├── footer.html
    │   └── nav.html
    └── static/           # CSS, JS, images
        ├── css/
        └── js/

Layouts

Layouts are Liquid templates that wrap your content:

<!DOCTYPE html>
<html lang="{{ site.language }}">
<head>
  {% include 'partials/head.html' %}
</head>
<body>
  {% include 'partials/header.html' %}
  <main>
    {{ content }}
  </main>
  {% include 'partials/footer.html' %}
</body>
</html>

Partials

Reusable components reduce repetition:

<!-- partials/header.html -->
<header class="site-header">
  <h1><a href="/">{{ site.title }}</a></h1>
  {% include 'partials/nav.html' %}
</header>

CSS Variables

The default Kiln theme uses CSS custom properties (variables) for easy customization:

:root {
  --color-primary: #007acc;
  --color-secondary: #f0f0f0;
  --font-family-sans: system-ui, -apple-system, sans-serif;
  --font-size-base: 16px;
  --max-width: 65ch;
}

body {
  font-family: var(--font-family-sans);
  font-size: var(--font-size-base);
  max-width: var(--max-width);
}

Override these in your own CSS to customize the site instantly.

Creating a Custom Theme

Copy themes/default/ to themes/my-theme/
Modify layouts, partials, and CSS
Update site.yaml:
```
theme: my-theme
```

Asset Serving

Static assets (CSS, images) in themes/*/static/ are served at:

/css/style.css from themes/default/static/css/style.css
/images/logo.svg from themes/default/static/images/logo.svg

Keep your static assets organized for easy maintainability.

Theming in Kiln is flexible, fast, and beginner-friendly!

Deploy Your Site

2026-08-10T00:00:00Z

Once you've built your Kiln site, deploying it is straightforward. Static sites can be hosted anywhere.

Build Output

Running kiln build generates a _site/ directory with:

Static HTML files
CSS and JavaScript
Images and other assets

This entire directory is what you deploy.

GitHub Pages

GitHub Pages is perfect for Kiln sites hosted on GitHub:

Push your site to a GitHub repository
In repository settings, enable GitHub Pages
Set the source branch (usually main or gh-pages)
Your site is live at https://username.github.io/repo

Automate this with GitHub Actions:

name: Build and Deploy

on:
  push:
    branches: [main]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - name: Setup .NET
        uses: actions/setup-dotnet@v3
        with:
          dotnet-version: '10.x'
      - run: dotnet run --project src/Kiln.Cli -- build .
      - name: Deploy to GitHub Pages
        uses: peaceiris/actions-gh-pages@v3
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          publish_dir: ./_site

Azure Static Web Apps

Azure SWA offers global distribution and edge caching:

Create a Static Web App in Azure Portal
Connect your GitHub repository
Configure the build output directory: _site
Deploy automatically on every push

Netlify

Netlify's drag-and-drop interface makes deployment simple:

Create a netlify.toml:

[build]
command = "dotnet run --project src/Kiln.Cli -- build ."
publish = "_site"

Connect your GitHub repository in Netlify Dashboard
Your site is live with automatic deployments

Vercel

Vercel works similarly to Netlify:

Import your GitHub project
Set build command: dotnet run --project src/Kiln.Cli -- build .
Set output directory: _site
Deploy with one click

Custom Servers

For any web server (Apache, Nginx, custom VPS):

Build locally: kiln build
Upload _site/ directory via FTP, SCP, or Git
Configure your web server to serve the content
Optionally set up automated deployments with webhooks

Performance Tips

Enable gzip compression in your web server
Use a CDN for global distribution
Set proper cache headers for static assets
Minify CSS and JavaScript (optional, can be added as build step)

Deploying a Kiln site is as simple as uploading static files. Choose the platform that fits your needs!

Plugins and Slots

2026-08-09T00:00:00Z

Plugins extend Kiln's functionality without modifying core code. Slots are the extension points where plugins hook in.

What are Slots?

Slots are predefined hook points in Kiln's build pipeline where custom logic runs:

Slot	When	Purpose
`content:loaded`	After content loaded	Modify frontmatter, metadata
`build:before`	Before site build	Pre-process assets
`build:after`	After site build	Post-process, validate
`page:rendered`	After page rendered	Modify HTML output

Creating a Plugin

A plugin is a .NET class implementing IKilnPlugin:

using Kiln.Core.Plugins;

public class MyCustomPlugin : IKilnPlugin
{
    public string Name => "My Custom Plugin";
    public string Version => "1.0.0";

    public void Register(IPluginContext context)
    {
        context.OnSlot("content:loaded", OnContentLoaded);
        context.OnSlot("build:after", OnBuildAfter);
    }

    private void OnContentLoaded(IContentMetadata metadata)
    {
        // Modify frontmatter here
        if (metadata.Tags.Count == 0)
        {
            metadata.Tags.Add("untagged");
        }
    }

    private void OnBuildAfter(IBuildContext context)
    {
        Console.WriteLine($"Build completed: {context.PagesGenerated} pages");
    }
}

Installing Plugins

Plugins can be distributed as:

NuGet Packages: Add to project dependencies
Local Assemblies: Place in plugins/ directory
Source Files: Include .cs files in plugin directory

plugins:
  - name: MyCustomPlugin
    enabled: true

Plugin Use Cases

SEO Optimization: Auto-generate meta tags, sitemaps
Analytics: Track page generation, build time
Media Processing: Resize images, generate WebP variants
Validation: Check broken links, missing images
Notifications: Alert on build failures, new posts

Filesystem Plugin Location

Kiln scans plugins/ directory for plugin assemblies:

plugins/
├── MyPlugin.dll
├── MyPlugin.pdb
└── MyPlugin.deps.json

Plugin Discovery

Kiln automatically:

Discovers plugins in plugins/ and registered NuGet packages
Loads plugin assemblies
Calls Register() on each plugin
Executes slot handlers in order

Best Practices

Keep it simple: Focus on one responsibility
Document slots: Explain what data is available
Handle errors: Don't crash the build
Use meaningful names: Clear plugin and slot names
Version your plugins: Semantic versioning

Plugins make Kiln infinitely extensible!

Configuration Deep Dive

2026-08-08T00:00:00Z

site.yaml is the central configuration file for your Kiln site. This post covers all available options.

Site Metadata

title: My Kiln Site
description: A blazingly fast static site generator
baseUrl: https://example.com
language: en
theme: default

title: Site name (used in templates)
description: Meta description tag
baseUrl: Full URL to your site
language: Language code (for HTML lang attribute)
theme: Theme directory name

Collections

collections:
  posts:
    directory: content/posts
    permalink: /blog/:slug/
    sort: date desc
    paginate: 10
    feed: true
    layout: post
    taxonomies:
      - tags
      - categories
  pages:
    directory: content/pages
    permalink: /:slug/
    sort: weight asc
    layout: page

directory: Source directory
permalink: URL pattern (:slug, :date, :title)
sort: Field and direction (date desc, weight asc)
paginate: Items per page (pagination enabled if >0)
feed: Generate RSS feed?
layout: Default template name
taxonomies: Applied taxonomy types

Taxonomies

taxonomies:
  tags:
    permalink: /tags/:slug/
    paginate: 20
    layout: taxonomy
  categories:
    permalink: /categories/:slug/
    paginate: 10
    layout: taxonomy

permalink: URL pattern for taxonomy pages
paginate: Items per page
layout: Template for category pages

Menus

menus:
  main:
    - title: Home
      ref: posts/
    - title: About
      ref: pages/about
    - title: External
      url: https://example.com
      external: true

title: Display text
ref: Link to collection/page
url: External URL (sets external: true)

Build Options

build:
  outputDirectory: _site
  cleanBefore: true
  minifyHtml: false
  minifyCss: false

outputDirectory: Where to generate the site
cleanBefore: Remove old output before build?
minifyHtml: Compress HTML output?
minifyCss: Compress CSS files?

Development

dev:
  port: 5555
  watch: true
  liveReload: true

port: Dev server port
watch: Watch files for changes?
liveReload: Auto-refresh browser?

Advanced

markdown:
  extensions:
    - strikethrough
    - tables
    - task-lists

feeds:
  - collection: posts
    permalink: /feed.xml

markdown.extensions: Enable CommonMark extensions
feeds: RSS feeds per collection

Full documentation at Kiln Docs

Understanding these options gives you full control over your Kiln site!

Performance Tips and Optimization

2026-08-07T00:00:00Z

Kiln is already fast, but here are tips to optimize your site further for speed and SEO.

Asset Namespace Optimization

Kiln's Asset Namespace feature organizes assets by content type and location:

assets/
├── content/
│   ├── posts/
│   │   └── my-post/
│   │       └── diagram.png
│   └── pages/
│       └── about-logo.svg
├── shared/
│   ├── fonts/
│   └── icons/
└── vendor/
    └── scripts/

Assets are served at predictable URLs:

/assets/content/posts/my-post/diagram.png
/assets/shared/fonts/main.woff2

This structure:

Colocates assets with content (easier management)
Enables cache busting per content item
Allows aggressive caching for shared assets
Reduces build complexity (no asset duplication)

Image Optimization

![Article banner](./my-image.webp)

Use WebP format for modern browsers (smaller files)
Compress PNG/JPEG with tools like ImageOptim
Provide descriptive alt text for accessibility and SEO
Use responsive images with srcset (optional plugin)

CSS Performance

/* Minimize CSS specificity */
.post-title { font-size: 2rem; }

/* Use CSS variables for theming */
:root {
  --spacing-unit: 1rem;
  --color-primary: #007acc;
}

/* Avoid @import in CSS (blocks rendering) */

Minify CSS via site.yaml build options
Use CSS variables for maintainability
Limit font files: Load only necessary weights
Inline critical CSS for above-the-fold content

Build Performance

# Fast rebuild for large sites
kiln build --incremental

# Parallel processing (default)
kiln build --threads 8

Kiln automatically:

Caches intermediate results
Parallelizes page generation
Skips unchanged files

For monitoring:

kiln build --verbose  # Show timing per step

Caching Headers

Configure your web server for optimal caching:

# nginx example
location /assets/ {
  expires 1y;
  add_header Cache-Control "public, immutable";
}

location /css/ {
  expires 30d;
  add_header Cache-Control "public";
}

location / {
  expires 1h;
  add_header Cache-Control "public";
}

SEO Performance

Structured data: Add JSON-LD to head.html
Sitemap: Enabled by default in RSS feeds
Open Graph: Add tags in partials/head.html
Heading hierarchy: Use h2, h3, not multiple h1s

Monitoring

Use lighthouse or similar tools:

# Google Lighthouse CLI
lighthouse https://example.com --output=html

Focus on:

Core Web Vitals: LCP, FID, CLS
First Contentful Paint: <1.8s
Largest Contentful Paint: <2.5s

Content Best Practices

Keep posts focused: Easier to read, faster to load
Use clear headings: Improves readability and SEO
Optimize media: Compress before uploading
Update old posts: Refresh content for better search ranking

Performance is a feature. Make it a priority from the start!

What's Next? Your Kiln Journey Continues

2026-08-06T00:00:00Z

You've explored Kiln's core features. Here's how to continue your journey and contribute to the project.

Next Steps

Build Your Own Site

Copy this theme: Use the default Kiln theme as a starting point
Create custom collections: Portfolio, documentation, wiki
Design your layout: Modify CSS variables and templates
Deploy: Choose a platform (GitHub Pages, Netlify, Azure SWA)
Celebrate: Share your Kiln-powered site with the community

Explore Advanced Features

Plugins: Extend Kiln with custom functionality
Custom taxonomies: Organize content your way
Liquid filters: Create powerful templates
Asset namespacing: Better asset management
Build hooks: Pre/post-build automation

Learn from Examples

Blog: Multi-author blog with tags, categories, search
Portfolio: Project showcase with filtering
Documentation site: Multi-version docs with search
E-commerce: Product listings with filtering

Getting Help

Documentation

GitHub README — Quick start and API reference
Examples Repository — Real-world samples
Discussion Board — Ask questions

Community

Join our community:

GitHub Discussions: Ask questions, share projects
Issues: Report bugs, request features
Pull Requests: Contribute code improvements
Twitter: Follow for updates and announcements

Roadmap

Planned features for Kiln:

Search: Built-in full-text search
Comments: Disqus/Utterances integration
Analytics: Native analytics dashboard
Admin Panel: Web-based content editor
Database Backend: SQLite, PostgreSQL support (coming)
Internationalization: Multi-language sites
E-commerce: Product management

Check GitHub Issues for active development.

Contributing

Help make Kiln better:

Report bugs: Found an issue? Create a GitHub issue with details
Suggest features: Share ideas in Discussions
Improve docs: Fix typos, add examples
Write plugins: Share your extensions as NuGet packages
Code contributions: Fork, create a branch, submit PR

All contributions are welcome!

Say Thank You

If you love Kiln:

⭐ Star the GitHub repository
📢 Share your site with the community
💬 Mention Kiln in your blog or talks
🤝 Contribute code or feedback

Final Thoughts

Kiln is designed to be:

Fast: Blazing-fast builds and deployments
Simple: Markdown in, static HTML out
Powerful: Flexible enough for any static site
Community-driven: Your feedback shapes the roadmap

Thank you for exploring Kiln. Happy building! 🚀

Questions? Join the community at github.com/PepperPix/Kiln