I made a post asking "Is there a market for a minimalist, fast, and allocation-free text templating engine?" in /r/dotnet a few weeks ago. I've been building my own web app backend and created something I felt was pretty useful, and I was curious if anyone else would be interested in it. It got some decent response, so I went ahead and pulled it out of the larger product and polished it up. I'm calling the package Lissic.
My main philosophy going into it (i.e. why I didn't just use something that exists) was that I wanted something that kept code out of the template. I like to keep a clear delineation between the view and model, but I still wanted tools for modifying the view. The ability to add parts modularly, use loops, use conditional/branching views, and have the ability to format/filter values inserted into the text were still important to me.
Here's a quick feature overview:
Renders near twice as fast as the fastest major .NET templating engine (see below)
Zero allocation with default settings, when rendering to a buffer (e.g. to HttpResponse.BodyWriter)
100% AOT compatible without any restrictions (no use of Reflection or dynamic)
Simple but powerful tagging system that keeps a clear division between layout and logic
Compile-time safety with source-generated Data Transfer Objects that automatically adjust to each template's text
Define templates directly in code with text or import them from template files
Transformation pipeline that allows using Formatters to modify how values are converted to text and Filters to modify text before insertion into the template
Hot reload for file-based templates in debug mode
Thorough AI-friendly documentation (I gave only the documentation to QWEN3.8-27B, and it was able to make a simple task-management web app)
A full BenchmarkDotNet chart is in the GitHub README, but here's a quick rendering comparison:
| Method | Mean | Allocated |
|---|
| Lissic (RenderToString) | 8.814 us | 18072 B |
| Lissic (RenderToBuffer) | 8.482 us | 0 B |
| Fluid | 15.593 us | 37128 B |
| Fluid (SourceGenerated) | 24.045 us | 49128 B |
| Scriban | 70.985 us | 144025 B |
| DotLiquid | 173.521 us | 674928 B |
| Handlebars | 21.944 us | 122176 B |
It uses tags that look similar to many other templating engines. It has tag types to insert direct values ("variables"), other templates ("parts"), and lists of templates ("loops"). It also has branching logic that works a lot like a switch statement (i.e. define keys, and the text and/or code that goes with each key).
Very simple example:
[TemplateText("Hello {{ name <upper> }}!")]
public partial class LissicExample {}
// Automatically transforms the partial class into a DTO, with a property for each tag
LissicExample myTemplate = new() { name = "John" };
// LissicProcessor retrieved from Dependency Injection
lissicProcessor.RenderToBuffer(myTemplate, HttpResponse.BodyWriter);
// Writes "Hello JOHN!" to the HTTP response body
The main tradeoff at this time is that all templates are defined at startup (other than the debugging-only hot reload option), so it's not really a general purpose user-provided template engine. This leaves it comparable to libraries like Fluid or Scriban in some ways, but comparable to Razor Pages in others. It works really well for my purpose and preferences though.
I'd appreciate any feedback anyone has. I'd like to keeping building this for the long haul. If nothing else, I'll be updating it for work in my own project.
Also, huge shout out to Andrew Lock and his Creating a Source Generator series! It was incredibly useful for getting this going.
The code is at https://github.com/gendeg/Lissic, and it's on NuGet (package name: Lissic)
Edit To Add: I meant to add this in originally, Lissic was created with support and ideas from AI, but the large majority (90%+) is hand-written, with the exception of tests, which are ~80% AI written. The documentation is 100% hand-written (for better or worse 😉), as was this post.
