diff --git a/core.d b/core.d
index 3eca15c..b2814bd 100644
--- a/core.d
+++ b/core.d
@@ -26,6 +26,23 @@
 +/
 module arsd.core;
 
+
+static if(__traits(compiles, () { import core.interpolation; })) {
+	import core.interpolation;
+
+	alias InterpolationHeader    = core.interpolation.InterpolationHeader;
+	alias InterpolationFooter    = core.interpolation.InterpolationFooter;
+	alias InterpolatedLiteral    = core.interpolation.InterpolatedLiteral;
+	alias InterpolatedExpression = core.interpolation.InterpolatedExpression;
+} else {
+	// polyfill for old versions
+	struct InterpolationHeader {}
+	struct InterpolationFooter {}
+	struct InterpolatedLiteral(string literal) {}
+	struct InterpolatedExpression(string code) {}
+}
+
+
 // FIXME: add callbacks on file open for tracing dependencies dynamically
 
 // see for useful info: https://devblogs.microsoft.com/dotnet/how-async-await-really-works/
diff --git a/database.d b/database.d
index 15a188b..7d21c75 100644
--- a/database.d
+++ b/database.d
@@ -105,6 +105,25 @@ interface Database {
 		return queryImpl(sql, args);
 	}
 
+	final ResultSet query(Args...)(arsd.core.InterpolationHeader header, Args args, arsd.core.InterpolationFooter footer) {
+		import arsd.core;
+		Variant[] vargs;
+		string sql;
+		foreach(arg; args) {
+			static if(is(typeof(arg) == InterpolatedLiteral!str, string str)) {
+				sql ~= str;
+			} else static if(is(typeof(arg) == InterpolatedExpression!str, string str)) {
+				// intentionally blank
+			} else static if(is(typeof(arg) == InterpolationHeader) || is(typeof(arg) == InterpolationFooter)) {
+				static assert(0, "Nested interpolations not allowed at this time");
+			} else {
+				sql ~= "?";
+				vargs ~= Variant(arg);
+			}
+		}
+		return queryImpl(sql, vargs);
+	}
+
 	/// turns a systime into a value understandable by the target database as a timestamp to be concated into a query. so it should be quoted and escaped etc as necessary
 	string sysTimeToValue(SysTime);
 
diff --git a/dom.d b/dom.d
index 9b36106..3b947fc 100644
--- a/dom.d
+++ b/dom.d
@@ -122,6 +122,8 @@ bool isConvenientAttribute(string name) {
 		document.parseUtf8("<example></example>", true, true); // changes the trues to false to switch from xml to html mode
 	---
 
+	You can also modify things like [selfClosedElements] and [rawSourceElements] before calling the `parse` family of functions to do further advanced tasks.
+
 	However you parse it, it will put a few things into special variables.
 
 	[root] contains the root document.
@@ -432,8 +434,25 @@ class Document : FileResource, DomParent {
 
 		History:
 			Added February 8, 2021 (included in dub release 9.2)
+
+			Changed from `string[]` to `immutable(string)[]` on
+			February 4, 2024 (dub v11.5) to plug a hole discovered
+			by the OpenD compiler's diagnostics.
 	+/
-	string[] selfClosedElements = htmlSelfClosedElements;
+	immutable(string)[] selfClosedElements = htmlSelfClosedElements;
+
+	/++
+		List of elements that contain raw CDATA content for this
+		document, e.g. `<script>` and `<style>` for HTML. The parser
+		will read until the closing string and put everything else
+		in a [RawSource] object for future processing, not trying to
+		do any further child nodes or attributes, etc.
+
+		History:
+			Added February 4, 2024 (dub v11.5)
+
+	+/
+	immutable(string)[] rawSourceElements = htmlRawSourceElements;
 
 	/++
 		List of elements that are considered inline for pretty printing.
@@ -443,8 +462,12 @@ class Document : FileResource, DomParent {
 
 		History:
 			Added June 21, 2021 (included in dub release 10.1)
+
+			Changed from `string[]` to `immutable(string)[]` on
+			February 4, 2024 (dub v11.5) to plug a hole discovered
+			by the OpenD compiler's diagnostics.
 	+/
-	string[] inlineElements = htmlInlineElements;
+	immutable(string)[] inlineElements = htmlInlineElements;
 
 	/**
 		Take XMLish data and try to make the DOM tree out of it.
@@ -978,7 +1001,7 @@ class Document : FileResource, DomParent {
 
 
 						// HACK to handle script and style as a raw data section as it is in HTML browsers
-						if(!pureXmlMode && (tagName == "script" || tagName == "style")) {
+						if(!pureXmlMode && tagName.isInArray(rawSourceElements)) {
 							if(!selfClosed) {
 								string closer = "</" ~ tagName ~ ">";
 								ptrdiff_t ending;
@@ -1559,6 +1582,189 @@ class Document : FileResource, DomParent {
 	}
 }
 
+/++
+	Basic parsing of HTML tag soup
+
+	If you simply make a `new Document("some string")` or use [Document.fromUrl] to automatically
+	download a page (that's function is shorthand for `new Document(arsd.http2.get(your_given_url).contentText)`),
+	the Document parser will assume it is broken HTML. It will try to fix up things like charset messes, missing
+	closing tags, flipped tags, inconsistent letter cases, and other forms of commonly found HTML on the web.
+
+	It isn't exactly the same as what a HTML5 web browser does in all cases, but it usually it, and where it
+	disagrees, it is still usually good enough (but sometimes a bug).
++/
+unittest {
+	auto document = new Document(`<html><body><p>hello <P>there`);
+	// this will automatically try to normalize the html and fix up broken tags, etc
+	// so notice how it added the missing closing tags here and made them all lower case
+	assert(document.toString() == "<!DOCTYPE html>\n<html><body><p>hello </p><p>there</p></body></html>", document.toString());
+}
+
+/++
+	Stricter parsing of HTML
+
+	When you are writing the HTML yourself, you can remove most ambiguity by making it throw exceptions instead
+	of trying to automatically fix up things basic parsing tries to do. Using strict mode accomplishes this.
+
+	This will help guarantee that you have well-formed HTML, which means it is going to parse a lot more reliably
+	by all users - browsers, dom.d, other libraries, all behave better with well-formed input... people too!
+
+	(note it is not a full *validator*, just a well-formedness checker. Full validation is a lot more work for very
+	little benefit in my experience, so I stopped here.)
++/
+unittest {
+	try {
+		auto document = new Document(`<html><body><p>hello <P>there`, true, true); // turns on strict and case sensitive mode to ctor
+		assert(0); // never reached, the constructor will throw because strict mode is turned on
+	} catch(Exception e) {
+
+	}
+
+	// you can also create the object first, then use the [parseStrict] method
+	auto document = new Document;
+	document.parseStrict(`<foo></foo>`); // this is invalid html - no such foo tag - but it is well-formed, since it is opened and closed properly, so it passes
+
+}
+
+/++
+	Custom HTML extensions
+
+	dom.d is a custom HTML parser, which means you can add custom HTML extensions to it too. It normally reads
+	and discards things like ASP style `<% ... %>` code as well as XML processing instruction / PHP style embeds `<? ... ?>`
+	but you can keep this data if you call a function to opt into it in before parsing.
+
+	Additionally, you can add special tags to be read like `<script>` to preserve its insides for future processing
+	via the `.innerRawSource` member.
++/
+unittest {
+	auto document = new Document; // construct an empty thing first
+	document.enableAddingSpecialTagsToDom(); // add the special tags like <% ... %> etc
+	document.rawSourceElements ~= "embedded-plaintext"; // tell it we want a custom
+
+	document.parseStrict(`<html>
+		<% some asp code %>
+		<script>embedded && javascript</script>
+		<embedded-plaintext>my <custom> plaintext & stuff</embedded-plaintext>
+	</html>`);
+
+	// please note that if we did `document.toString()` right now, the original source - almost your same
+	// string you passed to parseStrict - would be spit back out. Meaning the embedded-plaintext still has its
+	// special text inside it. Another parser won't understand how to use this! So if you want to pass this
+	// document somewhere else, you need to do some transformations.
+	//
+	// This differs from cases like CDATA sections, which dom.d will automatically convert into plain html entities
+	// on the output that can be read by anyone.
+
+	assert(document.root.tagName == "html"); // the root element is normal
+
+	int foundCount;
+	// now let's loop through the whole tree
+	foreach(element; document.root.tree) {
+		// the asp thing will be in
+		if(auto asp = cast(AspCode) element) {
+			// you use the `asp.source` member to get the code for these
+			assert(asp.source == "% some asp code %");
+			foundCount++;
+		} else if(element.tagName == "script") {
+			// and for raw source elements - script, style, or the ones you add,
+			// you use the innerHTML method to get the code inside
+			assert(element.innerHTML == "embedded && javascript");
+			foundCount++;
+		} else if(element.tagName == "embedded-plaintext") {
+			// and innerHTML again
+			assert(element.innerHTML == "my <custom> plaintext & stuff");
+			foundCount++;
+		}
+
+	}
+
+	assert(foundCount == 3);
+
+	// writeln(document.toString());
+}
+
+// FIXME: <textarea> contents are treated kinda special in html5 as well...
+
+/++
+	Demoing CDATA, entities, and non-ascii characters.
+
+	The previous example mentioned CDATA, let's show you what that does too. These are all read in as plain strings accessible in the DOM - there is no CDATA, no entities once you get inside the object model - but when you convert back into a string, it will normalize them in a particular way.
+
+	This is not exactly standards compliant completely in and out thanks to it doing some transformations... but I find it more useful - it reads the data in consistently and writes it out consistently, both in ways that work well for interop. Take a look:
++/
+unittest {
+	auto document = new Document(`<html>
+		<p>¤ is a non-ascii character. It will be converted to a numbered entity in string output.</p>
+		<p>&curren; is the same thing, but as a named entity. It also will be changed to a numbered entity in string output.</p>
+		<p><![CDATA[xml cdata segments, which can contain <tag> looking things, are converted to encode the embedded special-to-xml characters to entities too.]]></p>
+	</html>`, true, true); // strict mode turned on
+
+	// Inside the object model, things are simplified to D strings.
+	auto paragraphs = document.querySelectorAll("p");
+	// no surprise on the first paragraph, we wrote it with the character, and it is still there in the D string
+	assert(paragraphs[0].textContent == "¤ is a non-ascii character. It will be converted to a numbered entity in string output.");
+	// but note on the second paragraph, the entity has been converted to the appropriate *character* in the object
+	assert(paragraphs[1].textContent == "¤ is the same thing, but as a named entity. It also will be changed to a numbered entity in string output.");
+	// and the CDATA bit is completely gone from the DOM; it just read it in as a text node. The txt content shows the text as a plain string:
+	assert(paragraphs[2].textContent == "xml cdata segments, which can contain <tag> looking things, are converted to encode the embedded special-to-xml characters to entities too.");
+	// and the dom node beneath it is just a single text node; no trace of the original CDATA detail is left after parsing.
+	assert(paragraphs[2].childNodes.length == 1 && paragraphs[2].childNodes[0].nodeType == NodeType.Text);
+
+	// And now, in the output string, we can see they are normalized thusly:
+	assert(document.toString() == "<!DOCTYPE html>\n<html>
+		<p>&#164; is a non-ascii character. It will be converted to a numbered entity in string output.</p>
+		<p>&#164; is the same thing, but as a named entity. It also will be changed to a numbered entity in string output.</p>
+		<p>xml cdata segments, which can contain &lt;tag&gt; looking things, are converted to encode the embedded special-to-xml characters to entities too.</p>
+	</html>");
+}
+
+/++
+	Streaming parsing
+
+	dom.d normally takes a big string and returns a big DOM object tree - hence its name. This is usually the simplest
+	code to read and write, so I prefer to stick to that, but if you wanna jump through a few hoops, you can still make
+	dom.d work with streams.
+
+	It is awkward - again, dom.d's whole design is based on building the dom tree, but you can do it if you're willing to
+	subclass a little and trust the garbage collector. Here's how.
++/
+unittest {
+	bool encountered;
+	class StreamDocument : Document {
+		// the normal behavior for this function is to `parent.appendChild(child)`
+		// but we can override to read it as it is processed and not append it
+		override void processNodeWhileParsing(Element parent, Element child) {
+			if(child.tagName == "bar")
+				encountered = true;
+			// note that each element's object is created but then discarded as garbage.
+			// the GC will take care of it, even with a large document, whereas the normal
+			// object tree could become quite large.
+		}
+
+		this() {
+			super("<foo><bar></bar></foo>");
+		}
+	}
+
+	auto test = new StreamDocument();
+	assert(encountered); // it should have been seen
+	assert(test.querySelector("bar") is null); // but not appended to the dom node, since we didn't append it
+}
+
+/++
+	Basic parsing of XML.
+
+	dom.d is not technically a standards-compliant xml parser and doesn't implement all xml features,
+	but its stricter parse options together with turning off HTML's special tag handling (e.g. treating
+	`<script>` and `<style>` the same as any other tag) gets close enough to work fine for a great many
+	use cases.
+
+	For more information, see [XmlDocument].
++/
+unittest {
+	auto xml = new XmlDocument(`<my-stuff>hello</my-stuff>`);
+}
+
 interface DomParent {
 	inout(Document) asDocument() inout;
 	inout(Element) asElement() inout;
@@ -3934,6 +4140,7 @@ class XmlDocument : Document {
 	this(string data, bool enableHtmlHacks = false) {
 		selfClosedElements = null;
 		inlineElements = null;
+		rawSourceElements = null;
 		contentType = "text/xml; charset=utf-8";
 		_prolog = `<?xml version="1.0" encoding="UTF-8"?>` ~ "\n";
 
@@ -5902,6 +6109,10 @@ private immutable static string[] htmlSelfClosedElements = [
 	"embed","source","track","wbr"
 ];
 
+private immutable static string[] htmlRawSourceElements = [
+	"script", "style"
+];
+
 private immutable static string[] htmlInlineElements = [
 	"span", "strong", "em", "b", "i", "a"
 ];
@@ -8549,24 +8760,6 @@ unittest {
 	auto document = new Document("broken"); // just ensuring it doesn't crash
 }
 
-unittest {
-	bool encountered;
-	class StreamDocument : Document {
-		override void processNodeWhileParsing(Element parent, Element child) {
-			// import std.stdio; writeln("Processing: ", child);
-			if(child.tagName == "bar")
-				encountered = true;
-		}
-
-		this() {
-			super("<foo><bar></bar></foo>");
-		}
-	}
-
-	auto test = new StreamDocument();
-	assert(encountered); // it should have been seen
-	assert(test.querySelector("bar") is null); // but not appended to the dom node
-}
 
 /*
 Copyright: Adam D. Ruppe, 2010 - 2023
diff --git a/http2.d b/http2.d
index 3003ba1..75c5be3 100644
--- a/http2.d
+++ b/http2.d
@@ -5528,7 +5528,13 @@ template addToSimpledisplayEventLoop() {
 	import arsd.simpledisplay;
 	void addToSimpledisplayEventLoop(WebSocket ws, imported!"arsd.simpledisplay".SimpleWindow window) {
 
+		version(Windows)
+		auto event = WSACreateEvent();
+		// FIXME: supposed to close event too
+
 		void midprocess() {
+			version(Windows)
+				ResetEvent(event);
 			if(!ws.lowLevelReceive()) {
 				ws.readyState_ = WebSocket.CLOSED;
 				WebSocket.unregisterActiveSocket(ws);
@@ -5565,7 +5571,6 @@ template addToSimpledisplayEventLoop() {
 		} else version(Windows) {
 			ws.socket.blocking = false; // the WSAEventSelect does this anyway and doing it here lets phobos know about it.
 			//CreateEvent(null, 0, 0, null);
-			auto event = WSACreateEvent();
 			if(!event) {
 				throw new Exception("WSACreateEvent");
 			}
diff --git a/sqlite.d b/sqlite.d
index 191ee3f..d9c4336 100644
--- a/sqlite.d
+++ b/sqlite.d
@@ -290,7 +290,7 @@ struct Statement {
 
 		this.db = db;
 		if(sqlite3_prepare_v2(db.db, toStringz(sql), cast(int) sql.length, &s, null) != SQLITE_OK)
-			throw new DatabaseException(db.error());
+			throw new DatabaseException(db.error() ~ " " ~ sql);
 	}
 
 	version(sqlite_extended_metadata_available)
diff --git a/terminal.d b/terminal.d
index 9c4bcee..6030ddb 100644
--- a/terminal.d
+++ b/terminal.d
@@ -1302,6 +1302,8 @@ struct Terminal {
 				if(!integratedTerminalEmulatorConfiguration.fallbackToDegradedTerminal)
 					throw e;
 			}
+		} else {
+			usingDirectEmulator = true;
 		}
 
 		if(integratedTerminalEmulatorConfiguration.preferDegradedTerminal)
diff --git a/webtemplate.d b/webtemplate.d
index 4ac39ee..2f53af3 100644
--- a/webtemplate.d
+++ b/webtemplate.d
@@ -2,7 +2,7 @@
 	This provides a kind of web template support, built on top of [arsd.dom] and [arsd.script], in support of [arsd.cgi].
 
 	```html
-		<main>
+		<main body-class="foo">
 			<%=HTML some_var_with_html %>
 			<%= some_var %>
 
@@ -54,6 +54,474 @@ import arsd.dom;
 
 public import arsd.jsvar : var;
 
+/++
+	A class to render web template files into HTML documents.
+
+
+	You can customize various parts of this with subclassing and dependency injection. Customization hook points include:
+
+	$(NUMBERED_LIST
+		* You pass a [TemplateLoader] instance to the constructor. This object is responsible for loading a particular
+		named template and returning a string of its html text. If you don't pass one, the default behavior is to load a
+		particular file out of the templates directory.
+
+		* The next step is transforming the string the TemplateLoader returned into a document object model. This is done
+		by a private function at this time. If you want to use a different format than HTML, you should either embed the other
+		language in your template (you can pass a translator to the constructor, details to follow later in this document)
+
+		* Next, the contexts must be prepared. It will call [addDefaultFunctions] on each one to prepare them. You can override that
+		to provide more or fewer functions.
+
+		* Now, it is time to expand the template. This is done by a private function, so you cannot replace this step, but you can
+		customize it in some ways by passing functions to the constructor's `embeddedTagTranslators` argument.
+
+		* At this point, it combines the expanded template with the skeleton to form the complete, expanded document.
+
+		* Finally, it will call your custom post-processing function right before returning the document. You can override the [postProcess] method to add custom behavior to this step.
+	)
+
+	### Custom Special Tags
+
+	You can define translator for special tags, such as to embed a block of custom markup inside your template.
+
+	Let's suppose we want to add a `<plaintext>...</plaintext>` tag that does not need HTML entity encoding.
+
+	```html
+		<main>
+			I can use <b>HTML</b> &amp; need to respect entity encoding here.
+
+			<plaintext>
+				But here, I can write & as plain text and <b>html</b> will not work.
+			</plaintext>
+		</main>
+	```
+
+	We can make that possible by defining a custom special tag when constructing the `WebTemplateRenderer`, like this:
+
+	---
+		auto renderer = new WebTemplateRenderer(null /* no special loader needed */, [
+			// this argument is the special tag name and a function to work with it
+			// listed as associative arrays.
+			"plaintext": function(string content, string[string] attributes) {
+				import arsd.dom;
+				return WebTemplateRenderer.EmbeddedTagResult(new TextNode(content));
+			}
+		]);
+	---
+
+	The associative array keys are the special tag name. For each one, this instructs the HTML parser to treat them similarly to `<script>` - it will read until the closing tag, making no attempt to parse anything else inside it. It just scoops of the content, then calls your function to decide what to do with it.
+
+	$(SIDEBAR
+		Note: just like with how you cannot use `"</script>"` in a Javascript block in HTML, you also need to avoid using the closing tag as a string in your custom thing!
+	)
+
+	Your function is given an associative array of attributes on the special tag and its inner content, as raw source, from the file. You must construct an appropriate DOM element from the content (including possibly a `DocumentFragment` object if you need multiple tags inside) and return it, along with, optionally, an enumerated value telling the renderer if it should try to expand template text inside this new element. If you don't provide a value, it will try to automatically guess what it should do based on the returned element type. (That is, if you return a text node, it will try to do a string-based replacement, and if you return another node, it will descend into it the same as any other node written in the document looking for `AspCode` elements.)
+
+	The example given here returns a `TextNode`, so we let it do the default string-based template content processing. But if we returned `WebTemplateRenderer.EmbeddedTagResult(new TextNode(content), false);`, it would not support embedded templates and any `<% .. %>` stuff would be left as-is.
+
+	$(TIP
+		You can trim some of that namespace spam if you make a subclass and pass it to `super` inside your constructor.
+	)
+
+	History:
+		Added February 5, 2024 (dub v11.5)
++/
+class WebTemplateRenderer {
+	private TemplateLoader loader;
+	private EmbeddedTagResult function(string content, string[string] attributes)[string] embeddedTagTranslators;
+
+	/++
+
+	+/
+	this(TemplateLoader loader = null, EmbeddedTagResult function(string content, string[string] attributes)[string] embeddedTagTranslators = null) {
+		if(loader is null)
+			loader = TemplateLoader.forDirectory("templates/");
+		this.loader = loader;
+		this.embeddedTagTranslators = embeddedTagTranslators;
+	}
+
+	/++
+
+	+/
+	struct EmbeddedTagResult {
+		Element element;
+		bool scanForTemplateContent = true;
+	}
+
+	/++
+
+	+/
+	final Document renderTemplate(string templateName, var context = var.emptyObject, var skeletonContext = var.emptyObject, string skeletonName = null) {
+		import arsd.cgi;
+
+		try {
+			addDefaultFunctions(context);
+			addDefaultFunctions(skeletonContext);
+
+			if(skeletonName.length == 0)
+				skeletonName = "skeleton.html";
+
+			auto skeleton = parseTemplateString(loader.loadTemplateHtml(skeletonName), WrapTemplateIn.nothing);
+			auto document = parseTemplateString(loader.loadTemplateHtml(templateName), WrapTemplateIn.rootElement);
+
+			expandTemplate(skeleton.root, skeletonContext);
+
+			foreach(nav; skeleton.querySelectorAll("nav[data-relative-to]")) {
+				auto r = nav.getAttribute("data-relative-to");
+				foreach(a; nav.querySelectorAll("a")) {
+					a.attrs.href = Uri(a.attrs.href).basedOn(Uri(r));// ~ a.attrs.href;
+				}
+			}
+
+			expandTemplate(document.root, context);
+
+			// also do other unique elements and move them over.
+			// and have some kind of <document-fragment> that can be just reduced when going out in the final result.
+
+			// and try partials.
+
+			auto templateMain = document.requireSelector(":root > main");
+			if(templateMain.hasAttribute("body-class")) {
+				skeleton.requireSelector("body").addClass(templateMain.getAttribute("body-class"));
+				templateMain.removeAttribute("body-class");
+			}
+
+			skeleton.requireSelector("main").replaceWith(templateMain.removeFromTree);
+
+			if(auto title = document.querySelector(":root > title"))
+				skeleton.requireSelector(":root > head > title").innerHTML = title.innerHTML;
+
+			// also allow top-level unique id replacements
+			foreach(item; document.querySelectorAll(":root > [id]"))
+				skeleton.requireElementById(item.id).replaceWith(item.removeFromTree);
+
+			foreach(df; skeleton.querySelectorAll("document-fragment"))
+				df.stripOut();
+
+			debug
+			skeleton.root.prependChild(new HtmlComment(null, templateName ~ " inside skeleton.html"));
+
+			postProcess(skeleton);
+
+			return skeleton;
+		} catch(Exception e) {
+			throw new TemplateException(templateName, context, e);
+			//throw e;
+		}
+	}
+
+	private Document parseTemplateString(string templateHtml, WrapTemplateIn wrapTemplateIn) {
+		auto document = new Document();
+		document.parseSawAspCode = (string) => true; // enable adding <% %> to the dom
+		final switch(wrapTemplateIn) {
+			case WrapTemplateIn.nothing:
+				// no change needed
+			break;
+			case WrapTemplateIn.rootElement:
+				templateHtml = "<root>" ~ templateHtml ~ "</root>";
+			break;
+		}
+		foreach(k, v; embeddedTagTranslators)
+			document.rawSourceElements ~= k;
+		document.parse(templateHtml, true, true);
+		return document;
+	}
+
+	private enum WrapTemplateIn {
+		nothing,
+		rootElement
+	}
+
+	/++
+		Adds the default functions to the context. You can override this to add additional default functions (or static data) to the context objects.
+	+/
+	void addDefaultFunctions(var context) {
+		import std.conv;
+		// FIXME: I prolly want it to just set the prototype or something
+
+		/+
+			foo |> filterKeys(["foo", "bar"]);
+
+			It needs to match the filter, then if it is -pattern, it is removed and if it is +pattern, it is retained.
+
+			First one that matches applies to the key, so the last one in the list is your default.
+
+			Default is to reject. Putting a "*" at the end will keep everything not removed though.
+
+			["-foo", "*"] // keep everything except foo
+		+/
+		context.filterKeys = function var(var f, string[] filters) {
+			import std.path;
+			var o = var.emptyObject;
+			foreach(k, v; f) {
+				bool keep = false;
+				foreach(filter; filters) {
+					if(filter.length == 0)
+						throw new Exception("invalid filter");
+					bool filterOff = filter[0] == '-';
+					if(filterOff)
+						filter = filter[1 .. $];
+					if(globMatch(k.get!string, filter)) {
+						keep = !filterOff;
+						break;
+					}
+				}
+				if(keep)
+					o[k] = v;
+			}
+			return o;
+		};
+
+		context.encodeURIComponent = function string(var f) {
+			import std.uri;
+			return encodeComponent(f.get!string);
+		};
+
+		context.formatDate = function string(string s) {
+			if(s.length < 10)
+				return s;
+			auto year = s[0 .. 4];
+			auto month = s[5 .. 7];
+			auto day = s[8 .. 10];
+
+			return month ~ "/" ~ day ~ "/" ~ year;
+		};
+
+		context.dayOfWeek = function string(string s) {
+			import std.datetime;
+			return daysOfWeekFullNames[Date.fromISOExtString(s[0 .. 10]).dayOfWeek];
+		};
+
+		context.formatTime = function string(string s) {
+			if(s.length < 20)
+				return s;
+			auto hour = s[11 .. 13].to!int;
+			auto minutes = s[14 .. 16].to!int;
+			auto seconds = s[17 .. 19].to!int;
+
+			auto am = (hour >= 12) ? "PM" : "AM";
+			if(hour > 12)
+				hour -= 12;
+
+			return hour.to!string ~ (minutes < 10 ? ":0" : ":") ~ minutes.to!string ~ " " ~ am;
+		};
+
+		// don't want checking meta or data to be an error
+		if(context.meta == null)
+			context.meta = var.emptyObject;
+		if(context.data == null)
+			context.data = var.emptyObject;
+	}
+
+	/++
+		The default is currently to do nothing. This function only exists for you to override it.
+
+		However, this may change in the future. To protect yourself, if you subclass and override
+		this method, always call `super.postProcess(document);` before doing your own customizations.
+	+/
+	void postProcess(Document document) {
+
+	}
+
+	private void expandTemplate(Element root, var context) {
+		import std.string;
+
+		string replaceThingInString(string v) {
+			auto idx = v.indexOf("<%=");
+			if(idx == -1)
+				return v;
+			auto n = v[0 .. idx];
+			auto r = v[idx + "<%=".length .. $];
+
+			auto end = r.indexOf("%>");
+			if(end == -1)
+				throw new Exception("unclosed asp code in attribute");
+			auto code = r[0 .. end];
+			r = r[end + "%>".length .. $];
+
+			import arsd.script;
+			auto res = interpret(code, context).get!string;
+
+			return n ~ res ~ replaceThingInString(r);
+		}
+
+		foreach(k, v; root.attributes) {
+			if(k == "onrender") {
+				continue;
+			}
+
+			v = replaceThingInString(v);
+
+			root.setAttribute(k, v);
+		}
+
+		bool lastBoolResult;
+
+		foreach(ele; root.children) {
+			if(ele.tagName == "if-true") {
+				auto fragment = new DocumentFragment(null);
+				import arsd.script;
+				auto got = interpret(ele.attrs.cond, context).opCast!bool;
+				if(got) {
+					ele.tagName = "root";
+					expandTemplate(ele, context);
+					fragment.stealChildren(ele);
+				}
+				lastBoolResult = got;
+				ele.replaceWith(fragment);
+			} else if(ele.tagName == "or-else") {
+				auto fragment = new DocumentFragment(null);
+				if(!lastBoolResult) {
+					ele.tagName = "root";
+					expandTemplate(ele, context);
+					fragment.stealChildren(ele);
+				}
+				ele.replaceWith(fragment);
+			} else if(ele.tagName == "for-each") {
+				auto fragment = new DocumentFragment(null);
+				var nc = var.emptyObject(context);
+				lastBoolResult = false;
+				auto got = interpret(ele.attrs.over, context);
+				foreach(k, item; got) {
+					lastBoolResult = true;
+					nc[ele.attrs.as] = item;
+					if(ele.attrs.index.length)
+						nc[ele.attrs.index] = k;
+					auto clone = ele.cloneNode(true);
+					clone.tagName = "root"; // it certainly isn't a for-each anymore!
+					expandTemplate(clone, nc);
+
+					fragment.stealChildren(clone);
+				}
+				ele.replaceWith(fragment);
+			} else if(ele.tagName == "render-template") {
+				import std.file;
+				auto templateName = ele.getAttribute("file");
+				auto document = new Document();
+				document.parseSawAspCode = (string) => true; // enable adding <% %> to the dom
+				document.parse("<root>" ~ loader.loadTemplateHtml(templateName) ~ "</root>", true, true);
+
+				var obj = var.emptyObject;
+				obj.prototype = context;
+
+				// FIXME: there might be other data you pass from the parent...
+				if(auto data = ele.getAttribute("data")) {
+					obj["data"] = var.fromJson(data);
+				}
+
+				expandTemplate(document.root, obj);
+
+				auto fragment = new DocumentFragment(null);
+
+				debug fragment.appendChild(new HtmlComment(null, templateName));
+				fragment.stealChildren(document.root);
+				debug fragment.appendChild(new HtmlComment(null, "end " ~ templateName));
+
+				ele.replaceWith(fragment);
+			} else if(ele.tagName == "hidden-form-data") {
+				auto from = interpret(ele.attrs.from, context);
+				auto name = ele.attrs.name;
+
+				auto form = new Form(null);
+
+				populateForm(form, from, name);
+
+				auto fragment = new DocumentFragment(null);
+				fragment.stealChildren(form);
+
+				ele.replaceWith(fragment);
+			} else if(auto asp = cast(AspCode) ele) {
+				auto code = asp.source[1 .. $-1];
+				auto fragment = new DocumentFragment(null);
+				if(code[0] == '=') {
+					import arsd.script;
+					if(code.length > 5 && code[1 .. 5] == "HTML") {
+						auto got = interpret(code[5 .. $], context);
+						if(auto native = got.getWno!Element)
+							fragment.appendChild(native);
+						else
+							fragment.innerHTML = got.get!string;
+					} else {
+						auto got = interpret(code[1 .. $], context).get!string;
+						fragment.innerText = got;
+					}
+				}
+				asp.replaceWith(fragment);
+			} else if(ele.tagName == "script") {
+				auto source = ele.innerHTML;
+				string newCode;
+				check_more:
+				auto idx = source.indexOf("<%=");
+				if(idx != -1) {
+					newCode ~= source[0 .. idx];
+					auto remaining = source[idx + 3 .. $];
+					idx = remaining.indexOf("%>");
+					if(idx == -1)
+						throw new Exception("unclosed asp code in script");
+					auto code = remaining[0 .. idx];
+
+					auto data = interpret(code, context);
+					newCode ~= data.toJson();
+
+					source = remaining[idx + 2 .. $];
+					goto check_more;
+				}
+
+				if(newCode is null)
+					{} // nothing needed
+				else {
+					newCode ~= source;
+					ele.innerRawSource = newCode;
+				}
+			} else if(auto pTranslator = ele.tagName in embeddedTagTranslators) {
+				auto replacement = (*pTranslator)(ele.innerHTML, ele.attributes);
+				if(replacement.element is null)
+					ele.stripOut();
+				else {
+					ele.replaceWith(replacement.element);
+					if(replacement.scanForTemplateContent) {
+						if(auto tn = cast(TextNode) replacement.element)
+							tn.textContent = replaceThingInString(tn.nodeValue);
+						else
+							expandTemplate(replacement.element, context);
+					}
+				}
+			} else {
+				expandTemplate(ele, context);
+			}
+		}
+
+		if(root.hasAttribute("onrender")) {
+			var nc = var.emptyObject(context);
+			nc["this"] = wrapNativeObject(root);
+			nc["this"]["populateFrom"] = delegate var(var this_, var[] args) {
+				auto form = cast(Form) root;
+				if(form is null) return this_;
+				foreach(k, v; args[0]) {
+					populateForm(form, v, k.get!string);
+				}
+				return this_;
+			};
+			interpret(root.getAttribute("onrender"), nc);
+
+			root.removeAttribute("onrender");
+		}
+	}
+}
+
+/+
+unittest {
+
+}
++/
+
+deprecated("Use a WebTemplateRenderer class instead")
+void addDefaultFunctions(var context) {
+	scope renderer = new WebTemplateRenderer(null);
+	renderer.addDefaultFunctions(context);
+}
+
+
 // FIXME: want to show additional info from the exception, neatly integrated, whenever possible.
 class TemplateException : Exception {
 	string templateName;
@@ -68,84 +536,6 @@ class TemplateException : Exception {
 	}
 }
 
-void addDefaultFunctions(var context) {
-	import std.conv;
-	// FIXME: I prolly want it to just set the prototype or something
-
-	/+
-		foo |> filterKeys(["foo", "bar"]);
-
-		It needs to match the filter, then if it is -pattern, it is removed and if it is +pattern, it is retained.
-
-		First one that matches applies to the key, so the last one in the list is your default.
-
-		Default is to reject. Putting a "*" at the end will keep everything not removed though.
-
-		["-foo", "*"] // keep everything except foo
-	+/
-	context.filterKeys = function var(var f, string[] filters) {
-		import std.path;
-		var o = var.emptyObject;
-		foreach(k, v; f) {
-			bool keep = false;
-			foreach(filter; filters) {
-				if(filter.length == 0)
-					throw new Exception("invalid filter");
-				bool filterOff = filter[0] == '-';
-				if(filterOff)
-					filter = filter[1 .. $];
-				if(globMatch(k.get!string, filter)) {
-					keep = !filterOff;
-					break;
-				}
-			}
-			if(keep)
-				o[k] = v;
-		}
-		return o;
-	};
-
-	context.encodeURIComponent = function string(var f) {
-		import std.uri;
-		return encodeComponent(f.get!string);
-	};
-
-	context.formatDate = function string(string s) {
-		if(s.length < 10)
-			return s;
-		auto year = s[0 .. 4];
-		auto month = s[5 .. 7];
-		auto day = s[8 .. 10];
-
-		return month ~ "/" ~ day ~ "/" ~ year;
-	};
-
-	context.dayOfWeek = function string(string s) {
-		import std.datetime;
-		return daysOfWeekFullNames[Date.fromISOExtString(s[0 .. 10]).dayOfWeek];
-	};
-
-	context.formatTime = function string(string s) {
-		if(s.length < 20)
-			return s;
-		auto hour = s[11 .. 13].to!int;
-		auto minutes = s[14 .. 16].to!int;
-		auto seconds = s[17 .. 19].to!int;
-
-		auto am = (hour >= 12) ? "PM" : "AM";
-		if(hour > 12)
-			hour -= 12;
-
-		return hour.to!string ~ (minutes < 10 ? ":0" : ":") ~ minutes.to!string ~ " " ~ am;
-	};
-
-	// don't want checking meta or data to be an error
-	if(context.meta == null)
-		context.meta = var.emptyObject;
-	if(context.data == null)
-		context.data = var.emptyObject;
-}
-
 /++
 	A loader object for reading raw template, so you can use something other than files if you like.
 
@@ -190,71 +580,17 @@ interface TemplateLoader {
 
 	History:
 		Parameter `loader` was added on December 11, 2023 (dub v11.3)
+
+	See_Also:
+		[WebTemplateRenderer] gives you more control than the argument list here provides.
 +/
 Document renderTemplate(string templateName, var context = var.emptyObject, var skeletonContext = var.emptyObject, string skeletonName = null, TemplateLoader loader = null) {
-	import arsd.cgi;
-
-	if(loader is null)
-		loader = TemplateLoader.forDirectory("templates/");
-
-	try {
-		addDefaultFunctions(context);
-		addDefaultFunctions(skeletonContext);
-
-		if(skeletonName.length == 0)
-			skeletonName = "skeleton.html";
-
-		auto skeleton = new Document(loader.loadTemplateHtml(skeletonName), true, true);
-		auto document = new Document();
-		document.parseSawAspCode = (string) => true; // enable adding <% %> to the dom
-		document.parse("<root>" ~ loader.loadTemplateHtml(templateName) ~ "</root>", true, true);
-
-		expandTemplate(skeleton.root, skeletonContext, loader);
-
-		foreach(nav; skeleton.querySelectorAll("nav[data-relative-to]")) {
-			auto r = nav.getAttribute("data-relative-to");
-			foreach(a; nav.querySelectorAll("a")) {
-				a.attrs.href = Uri(a.attrs.href).basedOn(Uri(r));// ~ a.attrs.href;
-			}
-		}
-
-		expandTemplate(document.root, context, loader);
-
-		// also do other unique elements and move them over.
-		// and have some kind of <document-fragment> that can be just reduced when going out in the final result.
-
-		// and try partials.
-
-		auto templateMain = document.requireSelector(":root > main");
-		if(templateMain.hasAttribute("body-class")) {
-			skeleton.requireSelector("body").addClass(templateMain.getAttribute("body-class"));
-			templateMain.removeAttribute("body-class");
-		}
-
-		skeleton.requireSelector("main").replaceWith(templateMain.removeFromTree);
-
-		if(auto title = document.querySelector(":root > title"))
-			skeleton.requireSelector(":root > head > title").innerHTML = title.innerHTML;
-
-		// also allow top-level unique id replacements
-		foreach(item; document.querySelectorAll(":root > [id]"))
-			skeleton.requireElementById(item.id).replaceWith(item.removeFromTree);
-
-		foreach(df; skeleton.querySelectorAll("document-fragment"))
-			df.stripOut();
-
-		debug
-		skeleton.root.prependChild(new HtmlComment(null, templateName ~ " inside skeleton.html"));
-
-		return skeleton;
-	} catch(Exception e) {
-		throw new TemplateException(templateName, context, e);
-		//throw e;
-	}
+	scope auto renderer = new WebTemplateRenderer(loader);
+	return renderer.renderTemplate(templateName, context, skeletonContext, skeletonName);
 }
 
 /++
-	Shows how top-level things from the template are moved to their corresponding items on the  skeleton.
+	Shows how top-level things from the template are moved to their corresponding items on the skeleton.
 +/
 unittest {
 	// for the unittest, we want to inject a loader that uses plain strings instead of files.
@@ -293,178 +629,6 @@ unittest {
 	assert(doc.requireSelector("main").textContent == "Hello"); // and the main from the template is moved to the skeelton
 }
 
-private void expandTemplate(Element root, var context, TemplateLoader loader) {
-	import std.string;
-
-	string replaceThingInString(string v) {
-		auto idx = v.indexOf("<%=");
-		if(idx == -1)
-			return v;
-		auto n = v[0 .. idx];
-		auto r = v[idx + "<%=".length .. $];
-
-		auto end = r.indexOf("%>");
-		if(end == -1)
-			throw new Exception("unclosed asp code in attribute");
-		auto code = r[0 .. end];
-		r = r[end + "%>".length .. $];
-
-		import arsd.script;
-		auto res = interpret(code, context).get!string;
-
-		return n ~ res ~ replaceThingInString(r);
-	}
-
-	foreach(k, v; root.attributes) {
-		if(k == "onrender") {
-			continue;
-		}
-
-		v = replaceThingInString(v);
-
-		root.setAttribute(k, v);
-	}
-
-	bool lastBoolResult;
-
-	foreach(ele; root.children) {
-		if(ele.tagName == "if-true") {
-			auto fragment = new DocumentFragment(null);
-			import arsd.script;
-			auto got = interpret(ele.attrs.cond, context).opCast!bool;
-			if(got) {
-				ele.tagName = "root";
-				expandTemplate(ele, context, loader);
-				fragment.stealChildren(ele);
-			}
-			lastBoolResult = got;
-			ele.replaceWith(fragment);
-		} else if(ele.tagName == "or-else") {
-			auto fragment = new DocumentFragment(null);
-			if(!lastBoolResult) {
-				ele.tagName = "root";
-				expandTemplate(ele, context, loader);
-				fragment.stealChildren(ele);
-			}
-			ele.replaceWith(fragment);
-		} else if(ele.tagName == "for-each") {
-			auto fragment = new DocumentFragment(null);
-			var nc = var.emptyObject(context);
-			lastBoolResult = false;
-			auto got = interpret(ele.attrs.over, context);
-			foreach(k, item; got) {
-				lastBoolResult = true;
-				nc[ele.attrs.as] = item;
-				if(ele.attrs.index.length)
-					nc[ele.attrs.index] = k;
-				auto clone = ele.cloneNode(true);
-				clone.tagName = "root"; // it certainly isn't a for-each anymore!
-				expandTemplate(clone, nc, loader);
-
-				fragment.stealChildren(clone);
-			}
-			ele.replaceWith(fragment);
-		} else if(ele.tagName == "render-template") {
-			import std.file;
-			auto templateName = ele.getAttribute("file");
-			auto document = new Document();
-			document.parseSawAspCode = (string) => true; // enable adding <% %> to the dom
-			document.parse("<root>" ~ loader.loadTemplateHtml(templateName) ~ "</root>", true, true);
-
-			var obj = var.emptyObject;
-			obj.prototype = context;
-
-			// FIXME: there might be other data you pass from the parent...
-			if(auto data = ele.getAttribute("data")) {
-				obj["data"] = var.fromJson(data);
-			}
-
-			expandTemplate(document.root, obj, loader);
-
-			auto fragment = new DocumentFragment(null);
-
-			debug fragment.appendChild(new HtmlComment(null, templateName));
-			fragment.stealChildren(document.root);
-			debug fragment.appendChild(new HtmlComment(null, "end " ~ templateName));
-
-			ele.replaceWith(fragment);
-		} else if(ele.tagName == "hidden-form-data") {
-			auto from = interpret(ele.attrs.from, context);
-			auto name = ele.attrs.name;
-
-			auto form = new Form(null);
-
-			populateForm(form, from, name);
-
-			auto fragment = new DocumentFragment(null);
-			fragment.stealChildren(form);
-
-			ele.replaceWith(fragment);
-		} else if(auto asp = cast(AspCode) ele) {
-			auto code = asp.source[1 .. $-1];
-			auto fragment = new DocumentFragment(null);
-			if(code[0] == '=') {
-				import arsd.script;
-				if(code.length > 5 && code[1 .. 5] == "HTML") {
-					auto got = interpret(code[5 .. $], context);
-					if(auto native = got.getWno!Element)
-						fragment.appendChild(native);
-					else
-						fragment.innerHTML = got.get!string;
-				} else {
-					auto got = interpret(code[1 .. $], context).get!string;
-					fragment.innerText = got;
-				}
-			}
-			asp.replaceWith(fragment);
-		} else if(ele.tagName == "script") {
-			auto source = ele.innerHTML;
-			string newCode;
-			check_more:
-			auto idx = source.indexOf("<%=");
-			if(idx != -1) {
-				newCode ~= source[0 .. idx];
-				auto remaining = source[idx + 3 .. $];
-				idx = remaining.indexOf("%>");
-				if(idx == -1)
-					throw new Exception("unclosed asp code in script");
-				auto code = remaining[0 .. idx];
-
-				auto data = interpret(code, context);
-				newCode ~= data.toJson();
-
-				source = remaining[idx + 2 .. $];
-				goto check_more;
-			}
-
-			if(newCode is null)
-				{} // nothing needed
-			else {
-				newCode ~= source;
-				ele.innerRawSource = newCode;
-			}
-		} else {
-			expandTemplate(ele, context, loader);
-		}
-	}
-
-	if(root.hasAttribute("onrender")) {
-		var nc = var.emptyObject(context);
-		nc["this"] = wrapNativeObject(root);
-		nc["this"]["populateFrom"] = delegate var(var this_, var[] args) {
-			auto form = cast(Form) root;
-			if(form is null) return this_;
-			foreach(k, v; args[0]) {
-				populateForm(form, v, k.get!string);
-			}
-			return this_;
-		};
-		interpret(root.getAttribute("onrender"), nc);
-
-		root.removeAttribute("onrender");
-	}
-}
-
 void populateForm(Form form, var obj, string name) {
 	import std.string;
 
@@ -568,9 +732,16 @@ struct meta {
 	Can be used as a return value from one of your own methods when rendering websites with [WebPresenterWithTemplateSupport].
 +/
 struct RenderTemplate {
+	this(string name, var context = var.emptyObject, var skeletonContext = var.emptyObject, string skeletonName = null) {
+		this.name = name;
+		this.context = context;
+		this.skeletonContext = skeletonContext;
+		this.skeletonName = skeletonName;
+	}
+
 	string name;
-	var context = var.emptyObject;
-	var skeletonContext = var.emptyObject;
+	var context;
+	var skeletonContext;
 	string skeletonName;
 }
 
@@ -640,9 +811,22 @@ template WebPresenterWithTemplateSupport(CTRP) {
 			return null;
 		}
 
+		/++
+			You can override this.
+
+			History:
+				Added February 5, 2024 (dub v11.5)
+		+/
+		WebTemplateRenderer webTemplateRenderer() {
+			return new WebTemplateRenderer(templateLoader());
+		}
+
 		void presentSuccessfulReturnAsHtml(T : RenderTemplate)(Cgi cgi, T ret, Meta meta) {
 			addContext(cgi, ret.context);
-			auto skeleton = renderTemplate(ret.name, ret.context, ret.skeletonContext, ret.skeletonName, templateLoader());
+
+			auto renderer = this.webTemplateRenderer();
+
+			auto skeleton = renderer.renderTemplate(ret.name, ret.context, ret.skeletonContext, ret.skeletonName);
 			cgi.setResponseContentType("text/html; charset=utf8");
 			cgi.gzipResponse = true;
 			cgi.write(skeleton.toString(), true);
@@ -676,6 +860,10 @@ template WebPresenterWithTemplateSupport(CTRP) {
 	}
 }
 
+WebTemplateRenderer DefaultWtrFactory(TemplateLoader loader) {
+	return new WebTemplateRenderer(loader);
+}
+
 /++
 	Serves up a directory of template files as html. This is meant to be used for some near-static html in the midst of an application, giving you a little bit of dynamic content and conveniences with the ease of editing files without recompiles.
 
@@ -684,6 +872,7 @@ template WebPresenterWithTemplateSupport(CTRP) {
 		directory = the directory, under the template directory, to find the template files
 		skeleton = the name of the skeleton file inside the template directory
 		extension = the file extension to add to the url name to get the template name
+		wtrFactory = an alias to a function of type `WebTemplateRenderer function(TemplateLoader loader)` that returns `new WebTemplateRenderer(loader)` (or similar subclasses/argument lists);
 
 	To get the filename of the template from the url, it will:
 
@@ -699,8 +888,10 @@ template WebPresenterWithTemplateSupport(CTRP) {
 
 	History:
 		Added July 28, 2021 (documented dub v11.0)
+
+		The `wtrFactory` parameter was added on February 5, 2024 (dub v11.5).
 +/
-auto serveTemplateDirectory()(string urlPrefix, string directory = null, string skeleton = null, string extension = ".html", string templateDirectory = "templates/") {
+auto serveTemplateDirectory(alias wtrFactory = DefaultWtrFactory)(string urlPrefix, string directory = null, string skeleton = null, string extension = ".html", string templateDirectory = "templates/") {
 	import arsd.cgi;
 	import std.file;
 
@@ -732,7 +923,12 @@ auto serveTemplateDirectory()(string urlPrefix, string directory = null, string
 		auto fn = details.templateDirectory ~ details.directory ~ file ~ details.extension;
 		if(std.file.exists(fn)) {
 			cgi.setResponseExpiresRelative(600, true); // 10 minute cache expiration by default, FIXME it should be configurable
-			auto doc = renderTemplate(fn[details.templateDirectory.length.. $], var.emptyObject, var.emptyObject, details.skeleton, TemplateLoader.forDirectory(details.templateDirectory));
+
+			auto loader = TemplateLoader.forDirectory(details.templateDirectory);
+
+			WebTemplateRenderer renderer = wtrFactory(loader);
+
+			auto doc = renderer.renderTemplate(fn[details.templateDirectory.length.. $], var.emptyObject, var.emptyObject, details.skeleton);
 			cgi.gzipResponse = true;
 			cgi.write(doc.toString, true);
 			return true;