Merge pull request 'Text-and-Fonts' (#1) from Text-and-Fonts into main

Reviewed-on: #1
2026-05-05 13:57:23 +00:00
parent fd0ebb8d40 7e4ab5cbd8
commit cf31c91831
22 changed files with 1173 additions and 107 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -87,6 +87,7 @@ target_link_libraries(LoopThroughWithOpenGLCompositing PRIVATE
 	Ws2_32
 	Crypt32
 	Advapi32
+	Gdiplus
 )

 target_compile_definitions(LoopThroughWithOpenGLCompositing PRIVATE
--- a/README.md
+++ b/README.md
@@ -203,9 +203,10 @@ Each shader package lives under:
 shaders/<id>/
  shader.json
  shader.slang
+  optional-font-or-texture-assets
 ```

-See `SHADER_CONTRACT.md` for the manifest schema, parameter types, texture assets, temporal history support, and the Slang entry point contract.
+See `SHADER_CONTRACT.md` for the manifest schema, parameter types, texture assets, font/text assets, temporal history support, and the Slang entry point contract. `shaders/text-overlay/` is the reference live text package and bundles Roboto Regular with its OFL license.

 ## Generated Files

@@ -231,7 +232,14 @@ If your Windows runner stores the Blackmagic SDK outside the repo, configure `GP

 ## Still todo
 Audio
-Fonts
+improve text rendering
 genlock
 Logs
-anamorphic desqueeze
+anamorphic desqueeze
+solid color layer
+refactor, cleanup of source files
+display URL (Maybe clicakable) for control in the windows app (Not on the output)
+Sound shader as seperate .slang in shader package?
+runtime date time UTC and offset from PCs internal clock
+Add a value control to the color wheels
+![alt text](image.png)
--- a/SHADER_CONTRACT.md
+++ b/SHADER_CONTRACT.md
@@ -73,6 +73,7 @@ Optional fields:
 - `category`: UI grouping label.
 - `entryPoint`: Slang function to call. Defaults to `shadeVideo`.
 - `textures`: texture assets to load and expose as samplers.
+- `fonts`: packaged font assets for live text parameters.
 - `temporal`: history-buffer requirements.

 Shader-visible identifiers must be valid Slang-style identifiers:
@@ -80,6 +81,7 @@ Shader-visible identifiers must be valid Slang-style identifiers:
 - `entryPoint`
 - parameter `id`
 - texture `id`
+- font `id`

 Use letters, numbers, and underscores only, and start with a letter or underscore. For example, `logoTexture` is valid; `logo-texture` is not valid as a shader-visible texture ID.

@@ -180,6 +182,7 @@ Supported types:
 | `color` | `float4` | `[r, g, b, a]` |
 | `bool` | `bool` | `true` or `false` |
 | `enum` | `int` | selected option index |
+| `text` | generated texture/helper | string |

 Float example:

@@ -278,12 +281,42 @@ else if (mode == 2)
 }
 ```

+Text example:
+
+```json
+{
+  "fonts": [
+    { "id": "inter", "path": "fonts/Inter-Regular.ttf" }
+  ],
+  "parameters": [
+    {
+      "id": "titleText",
+      "label": "Title",
+      "type": "text",
+      "default": "LIVE",
+      "font": "inter",
+      "maxLength": 64
+    }
+  ]
+}
+```
+
+Text parameters are runtime-owned strings. They are not emitted as uniform values. Instead, the runtime renders the current string into a single-line SDF mask texture and the shader wrapper exposes helpers based on the parameter id:
+
+```slang
+float mask = sampleTitleText(textUv);
+float4 premultipliedText = drawTitleText(textUv, float4(1.0, 1.0, 1.0, 1.0));
+```
+
+Text is currently limited to printable ASCII. `maxLength` defaults to `64` and is clamped to `1..256`. The optional `font` field references a packaged font declared in `fonts`; if no font is specified, the runtime uses its fallback sans-serif renderer.
+
 Parameter validation:

 - Float values are clamped to `min`/`max` if provided.
 - `vec2` must have exactly 2 numbers.
 - `color` must have exactly 4 numbers.
 - Enum defaults must match one of the declared option values.
+- Text defaults must be strings. Non-printable characters are dropped and values are clamped to `maxLength`.
 - Non-finite numeric values are rejected.

 ## Texture Assets
@@ -323,6 +356,31 @@ return float4(logo.rgb * alpha, alpha);

 See `shaders/dvd-bounce/` for a complete texture-driven example.

+## Font Assets
+
+Declare packaged font assets in the manifest:
+
+```json
+{
+  "fonts": [
+    {
+      "id": "inter",
+      "path": "fonts/Inter-Regular.ttf"
+    }
+  ]
+}
+```
+
+Rules:
+
+- `id` must be a valid shader identifier.
+- `path` is relative to the shader package directory.
+- The file must exist when the manifest is loaded.
+- Font asset changes trigger shader reload.
+- V1 text layout is single-line; shaders position and scale the generated text texture themselves.
+
+See `shaders/text-overlay/` for a complete live text example. The sample bundles Roboto Regular and includes its OFL license beside the font file.
+
 ## Temporal Shaders

 Temporal shaders can request access to previous frames.
@@ -401,6 +459,7 @@ These files are ignored by git and are useful for debugging compiler output. If
 - Do not write a `[shader("fragment")]` entry point in `shader.slang`; the runtime provides it.
 - Remember enum globals are integer indexes, not strings.
 - Declare every texture in `shader.json`; undeclared texture samplers will not be bound.
+- Declare packaged fonts in `shader.json` when text parameters should use a specific font.
 - Keep temporal history requests modest. They consume texture units and memory and are capped by runtime config.
 - If a parameter appears in the UI but not in Slang, the shader may still compile, but the control has no effect.
 - If a Slang name collides with a generated global, rename your parameter or local symbol.
@@ -414,6 +473,7 @@ Before committing a new shader package:
 - `entryPoint`, parameter IDs, and texture IDs are valid identifiers.
 - `shader.slang` implements the configured entry point.
 - Texture files referenced by `textures` exist.
+- Font files referenced by `fonts` exist.
 - Enum defaults are present in their `options`.
 - Temporal shaders handle short or empty history gracefully.
 - The app can reload and compile the shader without errors.
--- a/apps/LoopThroughWithOpenGLCompositing/OpenGLComposite.cpp
+++ b/apps/LoopThroughWithOpenGLCompositing/OpenGLComposite.cpp
@@ -47,7 +47,11 @@
 #include <cstdint>
 #include <cstring>
 #include <cctype>
+#include <fstream>
+#include <gdiplus.h>
 #include <wincodec.h>
+#include <limits>
+#include <memory>
 #include <set>
 #include <sstream>
 #include <string>
@@ -64,6 +68,12 @@ constexpr GLuint kSourceHistoryTextureUnitBase = 2;
 constexpr GLuint kPackedVideoTextureUnit = 2;
 constexpr GLuint kGlobalParamsBindingPoint = 0;
 constexpr unsigned kPrerollFrameCount = 8;
+constexpr unsigned kTextTextureWidth = 2048;
+constexpr unsigned kTextTextureHeight = 256;
+constexpr int kTextSdfSpread = 20;
+constexpr unsigned kTextSdfBlurPasses = 1;
+constexpr float kTextFontPixelSize = 144.0f;
+constexpr float kTextLayoutPadding = 48.0f;
 const char* kVertexShaderSource =
 	"#version 430 core\n"
 	"out vec2 vTexCoord;\n"
@@ -100,6 +110,31 @@ const char* kDecodeFragmentShaderSource =
 	"	fragColor = rec709YCbCr2rgba(ySample, macroPixel.b, macroPixel.r, 1.0);\n"
 	"}\n";

+class GdiplusSession
+{
+public:
+	GdiplusSession()
+	{
+		Gdiplus::GdiplusStartupInput startupInput;
+		mStarted = Gdiplus::GdiplusStartup(&mToken, &startupInput, NULL) == Gdiplus::Ok;
+	}
+
+	~GdiplusSession()
+	{
+		if (mStarted)
+			Gdiplus::GdiplusShutdown(mToken);
+	}
+
+	GdiplusSession(const GdiplusSession&) = delete;
+	GdiplusSession& operator=(const GdiplusSession&) = delete;
+
+	bool started() const { return mStarted; }
+
+private:
+	ULONG_PTR mToken = 0;
+	bool mStarted = false;
+};
+
 void CopyErrorMessage(const std::string& message, int errorMessageSize, char* errorMessage)
 {
 	if (!errorMessage || errorMessageSize <= 0)
@@ -108,6 +143,305 @@ void CopyErrorMessage(const std::string& message, int errorMessageSize, char* er
 	strncpy_s(errorMessage, errorMessageSize, message.c_str(), _TRUNCATE);
 }

+std::wstring Utf8ToWide(const std::string& text)
+{
+	if (text.empty())
+		return std::wstring();
+	const int required = MultiByteToWideChar(CP_UTF8, 0, text.c_str(), -1, NULL, 0);
+	if (required <= 1)
+		return std::wstring();
+	std::wstring wide(static_cast<std::size_t>(required - 1), L'\0');
+	MultiByteToWideChar(CP_UTF8, 0, text.c_str(), -1, wide.data(), required);
+	return wide;
+}
+
+std::string TextValueForBinding(const RuntimeRenderState& state, const std::string& parameterId)
+{
+	auto valueIt = state.parameterValues.find(parameterId);
+	return valueIt == state.parameterValues.end() ? std::string() : valueIt->second.textValue;
+}
+
+const ShaderFontAsset* FindFontAssetForParameter(const RuntimeRenderState& state, const ShaderParameterDefinition& definition)
+{
+	if (!definition.fontId.empty())
+	{
+		for (const ShaderFontAsset& fontAsset : state.fontAssets)
+		{
+			if (fontAsset.id == definition.fontId)
+				return &fontAsset;
+		}
+	}
+	return state.fontAssets.empty() ? nullptr : &state.fontAssets.front();
+}
+
+std::vector<unsigned char> BuildLocalSdf(const std::vector<unsigned char>& alpha, unsigned width, unsigned height)
+{
+	std::vector<unsigned char> sdf(static_cast<std::size_t>(width) * height * 4, 0);
+	for (unsigned y = 0; y < height; ++y)
+	{
+		for (unsigned x = 0; x < width; ++x)
+		{
+			const bool inside = alpha[static_cast<std::size_t>(y) * width + x] > 127;
+			int bestDistanceSq = kTextSdfSpread * kTextSdfSpread;
+			for (int oy = -kTextSdfSpread; oy <= kTextSdfSpread; ++oy)
+			{
+				const int sy = static_cast<int>(y) + oy;
+				if (sy < 0 || sy >= static_cast<int>(height))
+					continue;
+				for (int ox = -kTextSdfSpread; ox <= kTextSdfSpread; ++ox)
+				{
+					const int sx = static_cast<int>(x) + ox;
+					if (sx < 0 || sx >= static_cast<int>(width))
+						continue;
+					const bool sampleInside = alpha[static_cast<std::size_t>(sy) * width + sx] > 127;
+					if (sampleInside == inside)
+						continue;
+					const int distanceSq = ox * ox + oy * oy;
+					if (distanceSq < bestDistanceSq)
+						bestDistanceSq = distanceSq;
+				}
+			}
+
+			const float distance = std::sqrt(static_cast<float>(bestDistanceSq));
+			const float signedDistance = (inside ? 1.0f : -1.0f) * distance;
+			float normalized = 0.5f + signedDistance / static_cast<float>(kTextSdfSpread * 2);
+			const unsigned char sourceAlpha = alpha[static_cast<std::size_t>(y) * width + x];
+			if (sourceAlpha > 0 && sourceAlpha < 255)
+				normalized = static_cast<float>(sourceAlpha) / 255.0f;
+			if (normalized < 0.0f)
+				normalized = 0.0f;
+			if (normalized > 1.0f)
+				normalized = 1.0f;
+			const unsigned char value = static_cast<unsigned char>(normalized * 255.0f + 0.5f);
+			const std::size_t out = (static_cast<std::size_t>(y) * width + x) * 4;
+			sdf[out + 0] = value;
+			sdf[out + 1] = value;
+			sdf[out + 2] = value;
+			sdf[out + 3] = value;
+		}
+	}
+	return sdf;
+}
+
+std::vector<unsigned char> BuildTextCoverageTexture(const std::vector<unsigned char>& alpha, unsigned width, unsigned height)
+{
+	std::vector<unsigned char> coverage(static_cast<std::size_t>(width) * height * 4, 0);
+	for (unsigned y = 0; y < height; ++y)
+	{
+		for (unsigned x = 0; x < width; ++x)
+		{
+			const unsigned char value = alpha[static_cast<std::size_t>(y) * width + x];
+			const std::size_t out = (static_cast<std::size_t>(y) * width + x) * 4;
+			coverage[out + 0] = value;
+			coverage[out + 1] = value;
+			coverage[out + 2] = value;
+			coverage[out + 3] = value;
+		}
+	}
+	return coverage;
+}
+
+std::vector<unsigned char> FlipTextTextureForShaderUv(const std::vector<unsigned char>& pixels, unsigned width, unsigned height)
+{
+	std::vector<unsigned char> flipped(pixels.size(), 0);
+	const std::size_t stride = static_cast<std::size_t>(width) * 4;
+	for (unsigned y = 0; y < height; ++y)
+	{
+		const std::size_t srcOffset = static_cast<std::size_t>(y) * stride;
+		const std::size_t dstOffset = static_cast<std::size_t>(height - 1 - y) * stride;
+		std::memcpy(flipped.data() + dstOffset, pixels.data() + srcOffset, stride);
+	}
+	return flipped;
+}
+
+std::vector<unsigned char> BlurTextSdf(const std::vector<unsigned char>& pixels, unsigned width, unsigned height, unsigned passes)
+{
+	std::vector<unsigned char> current = pixels;
+	std::vector<unsigned char> next(pixels.size(), 0);
+	for (unsigned pass = 0; pass < passes; ++pass)
+	{
+		for (unsigned y = 0; y < height; ++y)
+		{
+			for (unsigned x = 0; x < width; ++x)
+			{
+				unsigned weightedTotal = 0;
+				unsigned weightSum = 0;
+				for (int oy = -1; oy <= 1; ++oy)
+				{
+					const int sy = static_cast<int>(y) + oy;
+					if (sy < 0 || sy >= static_cast<int>(height))
+						continue;
+					for (int ox = -1; ox <= 1; ++ox)
+					{
+						const int sx = static_cast<int>(x) + ox;
+						if (sx < 0 || sx >= static_cast<int>(width))
+							continue;
+						const unsigned weight = (ox == 0 && oy == 0) ? 4u : ((ox == 0 || oy == 0) ? 2u : 1u);
+						const std::size_t sample = (static_cast<std::size_t>(sy) * width + sx) * 4;
+						weightedTotal += static_cast<unsigned>(current[sample]) * weight;
+						weightSum += weight;
+					}
+				}
+
+				const unsigned char value = static_cast<unsigned char>((weightedTotal + weightSum / 2) / weightSum);
+				const std::size_t out = (static_cast<std::size_t>(y) * width + x) * 4;
+				next[out + 0] = value;
+				next[out + 1] = value;
+				next[out + 2] = value;
+				next[out + 3] = value;
+			}
+		}
+		current.swap(next);
+	}
+	return current;
+}
+
+void WriteTextMaskDebugDump(const std::string& text, const std::vector<unsigned char>& alpha, const std::vector<unsigned char>& sdf, unsigned width, unsigned height)
+{
+	try
+	{
+		std::filesystem::path debugDir = std::filesystem::current_path() / "runtime";
+		std::filesystem::create_directories(debugDir);
+
+		auto writePgm = [width, height](const std::filesystem::path& path, const std::vector<unsigned char>& gray, std::size_t stride)
+		{
+			std::ofstream out(path, std::ios::binary);
+			if (!out)
+				return;
+			out << "P5\n" << width << " " << height << "\n255\n";
+			for (unsigned y = 0; y < height; ++y)
+			{
+				for (unsigned x = 0; x < width; ++x)
+					out.put(static_cast<char>(gray[(static_cast<std::size_t>(y) * width + x) * stride]));
+			}
+		};
+
+		writePgm(debugDir / "text-mask-alpha-debug.pgm", alpha, 1);
+		writePgm(debugDir / "text-mask-sdf-debug.pgm", sdf, 4);
+
+		unsigned alphaMin = 255;
+		unsigned alphaMax = 0;
+		unsigned sdfMin = 255;
+		unsigned sdfMax = 0;
+		std::size_t alphaLit = 0;
+		std::size_t sdfLit = 0;
+		for (unsigned char value : alpha)
+		{
+			alphaMin = std::min<unsigned>(alphaMin, value);
+			alphaMax = std::max<unsigned>(alphaMax, value);
+			if (value > 0)
+				++alphaLit;
+		}
+		for (std::size_t index = 0; index < sdf.size(); index += 4)
+		{
+			const unsigned char value = sdf[index];
+			sdfMin = std::min<unsigned>(sdfMin, value);
+			sdfMax = std::max<unsigned>(sdfMax, value);
+			if (value > 127)
+				++sdfLit;
+		}
+
+		std::ostringstream message;
+		message << "Text mask debug for '" << text << "': alpha min/max/lit=" << alphaMin << "/" << alphaMax << "/" << alphaLit
+			<< ", sdf min/max/gt127=" << sdfMin << "/" << sdfMax << "/" << sdfLit << "\n";
+		OutputDebugStringA(message.str().c_str());
+	}
+	catch (...)
+	{
+		OutputDebugStringA("Failed to write text mask debug dump.\n");
+	}
+}
+
+GLint FindSamplerUniformLocation(GLuint program, const std::string& samplerName)
+{
+	GLint location = glGetUniformLocation(program, samplerName.c_str());
+	if (location >= 0)
+		return location;
+	return glGetUniformLocation(program, (samplerName + "_0").c_str());
+}
+
+bool RasterizeTextSdf(const std::string& text, const std::filesystem::path& fontPath, std::vector<unsigned char>& sdf, std::string& error)
+{
+	GdiplusSession gdiplus;
+	if (!gdiplus.started())
+	{
+		error = "Could not start GDI+ for text rendering.";
+		return false;
+	}
+
+	Gdiplus::PrivateFontCollection fontCollection;
+	Gdiplus::FontFamily fallbackFamily(L"Arial");
+	Gdiplus::FontFamily* fontFamily = &fallbackFamily;
+	std::unique_ptr<Gdiplus::FontFamily[]> families;
+	const std::wstring wideFontPath = fontPath.empty() ? std::wstring() : fontPath.wstring();
+	if (!wideFontPath.empty())
+	{
+		if (fontCollection.AddFontFile(wideFontPath.c_str()) != Gdiplus::Ok)
+		{
+			error = "Could not load packaged font file for text rendering: " + fontPath.string();
+			return false;
+		}
+
+		const INT familyCount = fontCollection.GetFamilyCount();
+		if (familyCount <= 0)
+		{
+			error = "Packaged font did not contain a usable font family: " + fontPath.string();
+			return false;
+		}
+
+		families.reset(new Gdiplus::FontFamily[familyCount]);
+		INT found = 0;
+		if (fontCollection.GetFamilies(familyCount, families.get(), &found) != Gdiplus::Ok || found <= 0)
+		{
+			error = "Could not read the packaged font family: " + fontPath.string();
+			return false;
+		}
+		fontFamily = &families[0];
+	}
+
+	Gdiplus::Bitmap bitmap(kTextTextureWidth, kTextTextureHeight, PixelFormat32bppARGB);
+	Gdiplus::Graphics graphics(&bitmap);
+	graphics.SetCompositingMode(Gdiplus::CompositingModeSourceCopy);
+	graphics.Clear(Gdiplus::Color(255, 0, 0, 0));
+	graphics.SetCompositingMode(Gdiplus::CompositingModeSourceOver);
+	graphics.SetTextRenderingHint(Gdiplus::TextRenderingHintAntiAlias);
+	graphics.SetSmoothingMode(Gdiplus::SmoothingModeHighQuality);
+	Gdiplus::Font font(fontFamily, kTextFontPixelSize, Gdiplus::FontStyleRegular, Gdiplus::UnitPixel);
+	Gdiplus::SolidBrush brush(Gdiplus::Color(255, 255, 255, 255));
+	Gdiplus::StringFormat format;
+	format.SetAlignment(Gdiplus::StringAlignmentNear);
+	format.SetLineAlignment(Gdiplus::StringAlignmentCenter);
+	format.SetFormatFlags(Gdiplus::StringFormatFlagsNoWrap | Gdiplus::StringFormatFlagsMeasureTrailingSpaces);
+	const Gdiplus::RectF layout(
+		kTextLayoutPadding,
+		0.0f,
+		static_cast<Gdiplus::REAL>(kTextTextureWidth) - (kTextLayoutPadding * 2.0f),
+		static_cast<Gdiplus::REAL>(kTextTextureHeight));
+	const std::wstring wideText = Utf8ToWide(text);
+	graphics.DrawString(wideText.c_str(), -1, &font, layout, &format, &brush);
+
+	std::vector<unsigned char> alpha(static_cast<std::size_t>(kTextTextureWidth) * kTextTextureHeight, 0);
+	for (unsigned y = 0; y < kTextTextureHeight; ++y)
+	{
+		for (unsigned x = 0; x < kTextTextureWidth; ++x)
+		{
+			Gdiplus::Color pixel;
+			bitmap.GetPixel(x, y, &pixel);
+			BYTE luminance = pixel.GetRed();
+			if (pixel.GetGreen() > luminance)
+				luminance = pixel.GetGreen();
+			if (pixel.GetBlue() > luminance)
+				luminance = pixel.GetBlue();
+			alpha[static_cast<std::size_t>(y) * kTextTextureWidth + x] = static_cast<unsigned char>(luminance);
+		}
+	}
+	sdf = BuildTextCoverageTexture(alpha, kTextTextureWidth, kTextTextureHeight);
+	sdf = BlurTextSdf(sdf, kTextTextureWidth, kTextTextureHeight, kTextSdfBlurPasses);
+	sdf = FlipTextTextureForShaderUv(sdf, kTextTextureWidth, kTextTextureHeight);
+	WriteTextMaskDebugDump(text, alpha, sdf, kTextTextureWidth, kTextTextureHeight);
+	return true;
+}
+
 std::string NormalizeModeToken(const std::string& value)
 {
 	std::string normalized;
@@ -1488,13 +1822,33 @@ bool OpenGLComposite::compileSingleLayerProgram(const RuntimeRenderState& state,
 		}
 		textureBindings.push_back(textureBinding);
 	}
+	std::vector<LayerProgram::TextBinding> textBindings;
+	for (const ShaderParameterDefinition& definition : state.parameterDefinitions)
+	{
+		if (definition.type != ShaderParameterType::Text)
+			continue;
+		LayerProgram::TextBinding textBinding;
+		textBinding.parameterId = definition.id;
+		textBinding.samplerName = definition.id + "Texture";
+		textBinding.fontId = definition.fontId;
+		glGenTextures(1, &textBinding.texture);
+		glBindTexture(GL_TEXTURE_2D, textBinding.texture);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		std::vector<unsigned char> empty(static_cast<std::size_t>(kTextTextureWidth) * kTextTextureHeight * 4, 0);
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, kTextTextureWidth, kTextTextureHeight, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, empty.data());
+		glBindTexture(GL_TEXTURE_2D, 0);
+		textBindings.push_back(textBinding);
+	}

 	const GLuint globalParamsIndex = glGetUniformBlockIndex(newProgram.get(), "GlobalParams");
 	if (globalParamsIndex != GL_INVALID_INDEX)
 		glUniformBlockBinding(newProgram.get(), globalParamsIndex, kGlobalParamsBindingPoint);

 	const unsigned historyCap = mRuntimeHost ? mRuntimeHost->GetMaxTemporalHistoryFrames() : 0;
-	const GLuint shaderTextureBase = kSourceHistoryTextureUnitBase + historyCap + historyCap;
+	const GLuint shaderTextureBase = state.isTemporal ? kSourceHistoryTextureUnitBase + historyCap + historyCap : kSourceHistoryTextureUnitBase;
 	glUseProgram(newProgram.get());
 	const GLint videoInputLocation = glGetUniformLocation(newProgram.get(), "gVideoInput");
 	if (videoInputLocation >= 0)
@@ -1513,18 +1867,27 @@ bool OpenGLComposite::compileSingleLayerProgram(const RuntimeRenderState& state,
 	}
 	for (std::size_t index = 0; index < textureBindings.size(); ++index)
 	{
-		const GLint textureSamplerLocation = glGetUniformLocation(newProgram.get(), textureBindings[index].samplerName.c_str());
+		const GLint textureSamplerLocation = FindSamplerUniformLocation(newProgram.get(), textureBindings[index].samplerName);
 		if (textureSamplerLocation >= 0)
 			glUniform1i(textureSamplerLocation, static_cast<GLint>(shaderTextureBase + static_cast<GLuint>(index)));
 	}
+	const GLuint textTextureBase = shaderTextureBase + static_cast<GLuint>(textureBindings.size());
+	for (std::size_t index = 0; index < textBindings.size(); ++index)
+	{
+		const GLint textSamplerLocation = FindSamplerUniformLocation(newProgram.get(), textBindings[index].samplerName);
+		if (textSamplerLocation >= 0)
+			glUniform1i(textSamplerLocation, static_cast<GLint>(textTextureBase + static_cast<GLuint>(index)));
+	}
 	glUseProgram(0);

 	layerProgram.layerId = state.layerId;
 	layerProgram.shaderId = state.shaderId;
+	layerProgram.shaderTextureBase = shaderTextureBase;
 	layerProgram.program = newProgram.release();
 	layerProgram.vertexShader = newVertexShader.release();
 	layerProgram.fragmentShader = newFragmentShader.release();
 	layerProgram.textureBindings.swap(textureBindings);
+	layerProgram.textBindings.swap(textBindings);
 	return true;
 }

@@ -1626,6 +1989,15 @@ void OpenGLComposite::destroySingleLayerProgram(LayerProgram& layerProgram)
 		}
 	}
 	layerProgram.textureBindings.clear();
+	for (LayerProgram::TextBinding& textBinding : layerProgram.textBindings)
+	{
+		if (textBinding.texture != 0)
+		{
+			glDeleteTextures(1, &textBinding.texture);
+			textBinding.texture = 0;
+		}
+	}
+	layerProgram.textBindings.clear();

 	if (layerProgram.program != 0)
 	{
@@ -1759,15 +2131,58 @@ bool OpenGLComposite::loadTextureAsset(const ShaderTextureAsset& textureAsset, G
 	return true;
 }

+bool OpenGLComposite::renderTextBindingTexture(const RuntimeRenderState& state, LayerProgram::TextBinding& textBinding, std::string& error)
+{
+	const std::string text = TextValueForBinding(state, textBinding.parameterId);
+	if (text == textBinding.renderedText && textBinding.renderedWidth == kTextTextureWidth && textBinding.renderedHeight == kTextTextureHeight)
+		return true;
+
+	auto definitionIt = std::find_if(state.parameterDefinitions.begin(), state.parameterDefinitions.end(),
+		[&textBinding](const ShaderParameterDefinition& definition) { return definition.id == textBinding.parameterId; });
+	if (definitionIt == state.parameterDefinitions.end())
+		return true;
+
+	const ShaderFontAsset* fontAsset = FindFontAssetForParameter(state, *definitionIt);
+	std::filesystem::path fontPath;
+	if (fontAsset)
+		fontPath = fontAsset->path;
+
+	std::vector<unsigned char> sdf;
+	if (!RasterizeTextSdf(text, fontPath, sdf, error))
+		return false;
+
+	GLint previousActiveTexture = 0;
+	GLint previousUnpackBuffer = 0;
+	glGetIntegerv(GL_ACTIVE_TEXTURE, &previousActiveTexture);
+	glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING, &previousUnpackBuffer);
+	glActiveTexture(GL_TEXTURE0);
+	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+	glBindTexture(GL_TEXTURE_2D, textBinding.texture);
+	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, kTextTextureWidth, kTextTextureHeight, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, sdf.data());
+	glBindTexture(GL_TEXTURE_2D, 0);
+	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, static_cast<GLuint>(previousUnpackBuffer));
+	glActiveTexture(static_cast<GLenum>(previousActiveTexture));
+
+	textBinding.renderedText = text;
+	textBinding.renderedWidth = kTextTextureWidth;
+	textBinding.renderedHeight = kTextTextureHeight;
+	return true;
+}
+
 void OpenGLComposite::bindLayerTextureAssets(const LayerProgram& layerProgram)
 {
-	const unsigned historyCap = mRuntimeHost ? mRuntimeHost->GetMaxTemporalHistoryFrames() : 0;
-	const GLuint shaderTextureBase = kSourceHistoryTextureUnitBase + historyCap + historyCap;
+	const GLuint shaderTextureBase = layerProgram.shaderTextureBase != 0 ? layerProgram.shaderTextureBase : kSourceHistoryTextureUnitBase;
 	for (std::size_t index = 0; index < layerProgram.textureBindings.size(); ++index)
 	{
 		glActiveTexture(GL_TEXTURE0 + shaderTextureBase + static_cast<GLuint>(index));
 		glBindTexture(GL_TEXTURE_2D, layerProgram.textureBindings[index].texture);
 	}
+	const GLuint textTextureBase = shaderTextureBase + static_cast<GLuint>(layerProgram.textureBindings.size());
+	for (std::size_t index = 0; index < layerProgram.textBindings.size(); ++index)
+	{
+		glActiveTexture(GL_TEXTURE0 + textTextureBase + static_cast<GLuint>(index));
+		glBindTexture(GL_TEXTURE_2D, layerProgram.textBindings[index].texture);
+	}
 	glActiveTexture(GL_TEXTURE0);
 }

@@ -1795,15 +2210,22 @@ void OpenGLComposite::destroyDecodeShaderProgram()
 bool OpenGLComposite::validateTemporalTextureUnitBudget(const std::vector<RuntimeRenderState>& layerStates, std::string& error) const
 {
 	const unsigned historyCap = mRuntimeHost ? mRuntimeHost->GetMaxTemporalHistoryFrames() : 0;
-	unsigned maxAssetTextures = 0;
+	unsigned requiredUnits = kSourceHistoryTextureUnitBase;
 	for (const RuntimeRenderState& state : layerStates)
 	{
-		if (state.textureAssets.size() > maxAssetTextures)
-			maxAssetTextures = static_cast<unsigned>(state.textureAssets.size());
+		unsigned textTextureCount = 0;
+		for (const ShaderParameterDefinition& definition : state.parameterDefinitions)
+		{
+			if (definition.type == ShaderParameterType::Text)
+				++textTextureCount;
+		}
+		const unsigned totalShaderTextures = static_cast<unsigned>(state.textureAssets.size()) + textTextureCount;
+		const unsigned layerRequiredUnits = kSourceHistoryTextureUnitBase + (state.isTemporal ? historyCap + historyCap : 0u) + totalShaderTextures;
+		if (layerRequiredUnits > requiredUnits)
+			requiredUnits = layerRequiredUnits;
 	}
 	GLint maxTextureUnits = 0;
 	glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits);
-	const unsigned requiredUnits = kSourceHistoryTextureUnitBase + historyCap + historyCap + maxAssetTextures;
 	const unsigned availableUnits = maxTextureUnits > 0 ? static_cast<unsigned>(maxTextureUnits) : 0u;
 	if (requiredUnits > availableUnits)
 	{
@@ -2062,8 +2484,15 @@ void OpenGLComposite::renderEffect()
 		VideoFrameTransfer::endTextureInUse(VideoFrameTransfer::CPUtoGPU);
 }

-void OpenGLComposite::renderShaderProgram(GLuint sourceTexture, GLuint destinationFrameBuffer, const LayerProgram& layerProgram, const RuntimeRenderState& state)
+void OpenGLComposite::renderShaderProgram(GLuint sourceTexture, GLuint destinationFrameBuffer, LayerProgram& layerProgram, const RuntimeRenderState& state)
 {
+	for (LayerProgram::TextBinding& textBinding : layerProgram.textBindings)
+	{
+		std::string textError;
+		if (!renderTextBindingTexture(state, textBinding, textError))
+			OutputDebugStringA((textError + "\n").c_str());
+	}
+
 	glBindFramebuffer(GL_FRAMEBUFFER, destinationFrameBuffer);
 	glViewport(0, 0, mInputFrameWidth, mInputFrameHeight);
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -2085,8 +2514,8 @@ void OpenGLComposite::renderShaderProgram(GLuint sourceTexture, GLuint destinati
 		glActiveTexture(GL_TEXTURE0 + kSourceHistoryTextureUnitBase + historyCap + index);
 		glBindTexture(GL_TEXTURE_2D, 0);
 	}
-	const GLuint shaderTextureBase = kSourceHistoryTextureUnitBase + historyCap + historyCap;
-	for (std::size_t index = 0; index < layerProgram.textureBindings.size(); ++index)
+	const GLuint shaderTextureBase = layerProgram.shaderTextureBase != 0 ? layerProgram.shaderTextureBase : kSourceHistoryTextureUnitBase;
+	for (std::size_t index = 0; index < layerProgram.textureBindings.size() + layerProgram.textBindings.size(); ++index)
 	{
 		glActiveTexture(GL_TEXTURE0 + shaderTextureBase + static_cast<GLuint>(index));
 		glBindTexture(GL_TEXTURE_2D, 0);
@@ -2223,6 +2652,8 @@ bool OpenGLComposite::updateGlobalParamsBuffer(const RuntimeRenderState& state,
 			AppendStd140Int(buffer, selectedIndex);
 			break;
 		}
+		case ShaderParameterType::Text:
+			break;
 		}
 	}

--- a/apps/LoopThroughWithOpenGLCompositing/OpenGLComposite.h
+++ b/apps/LoopThroughWithOpenGLCompositing/OpenGLComposite.h
@@ -167,12 +167,25 @@ private:
 			GLuint texture = 0;
 		};

+		struct TextBinding
+		{
+			std::string parameterId;
+			std::string samplerName;
+			std::string fontId;
+			GLuint texture = 0;
+			std::string renderedText;
+			unsigned renderedWidth = 0;
+			unsigned renderedHeight = 0;
+		};
+
 		std::string layerId;
 		std::string shaderId;
+		GLuint shaderTextureBase = 0;
 		GLuint program = 0;
 		GLuint vertexShader = 0;
 		GLuint fragmentShader = 0;
 		std::vector<TextureBinding> textureBindings;
+		std::vector<TextBinding> textBindings;
 	};
 	std::vector<LayerProgram>				mLayerPrograms;

@@ -203,8 +216,9 @@ private:
 	void destroySingleLayerProgram(LayerProgram& layerProgram);
 	void destroyDecodeShaderProgram();
 	void renderDecodePass();
-	void renderShaderProgram(GLuint sourceTexture, GLuint destinationFrameBuffer, const LayerProgram& layerProgram, const RuntimeRenderState& state);
+	void renderShaderProgram(GLuint sourceTexture, GLuint destinationFrameBuffer, LayerProgram& layerProgram, const RuntimeRenderState& state);
 	bool loadTextureAsset(const ShaderTextureAsset& textureAsset, GLuint& textureId, std::string& error);
+	bool renderTextBindingTexture(const RuntimeRenderState& state, LayerProgram::TextBinding& textBinding, std::string& error);
 	void bindLayerTextureAssets(const LayerProgram& layerProgram);
 	void renderEffect();
 	bool PollRuntimeChanges();
--- a/apps/LoopThroughWithOpenGLCompositing/RuntimeHost.cpp
+++ b/apps/LoopThroughWithOpenGLCompositing/RuntimeHost.cpp
@@ -133,6 +133,7 @@ std::string ShaderParameterTypeToString(ShaderParameterType type)
 	case ShaderParameterType::Color: return "color";
 	case ShaderParameterType::Boolean: return "bool";
 	case ShaderParameterType::Enum: return "enum";
+	case ShaderParameterType::Text: return "text";
 	}
 	return "unknown";
 }
@@ -179,6 +180,11 @@ bool ParseShaderParameterType(const std::string& typeName, ShaderParameterType&
 		type = ShaderParameterType::Enum;
 		return true;
 	}
+	if (typeName == "text")
+	{
+		type = ShaderParameterType::Text;
+		return true;
+	}
 	return false;
 }

@@ -200,6 +206,24 @@ bool TextureAssetsEqual(const std::vector<ShaderTextureAsset>& left, const std::
 	return true;
 }

+bool FontAssetsEqual(const std::vector<ShaderFontAsset>& left, const std::vector<ShaderFontAsset>& right)
+{
+	if (left.size() != right.size())
+		return false;
+
+	for (std::size_t index = 0; index < left.size(); ++index)
+	{
+		if (left[index].id != right[index].id ||
+			left[index].path != right[index].path ||
+			left[index].writeTime != right[index].writeTime)
+		{
+			return false;
+		}
+	}
+
+	return true;
+}
+
 std::string ManifestPathMessage(const std::filesystem::path& manifestPath)
 {
 	return manifestPath.string();
@@ -379,6 +403,49 @@ bool ParseTextureAssets(const JsonValue& manifestJson, ShaderPackage& shaderPack
 	return true;
 }

+bool ParseFontAssets(const JsonValue& manifestJson, ShaderPackage& shaderPackage, const std::filesystem::path& manifestPath, std::string& error)
+{
+	const JsonValue* fontsValue = nullptr;
+	if (!OptionalArrayField(manifestJson, "fonts", fontsValue, manifestPath, error))
+		return false;
+	if (!fontsValue)
+		return true;
+
+	for (const JsonValue& fontJson : fontsValue->asArray())
+	{
+		if (!fontJson.isObject())
+		{
+			error = "Shader font entry must be an object in: " + ManifestPathMessage(manifestPath);
+			return false;
+		}
+
+		std::string fontId;
+		std::string fontPath;
+		if (!RequireNonEmptyStringField(fontJson, "id", fontId, manifestPath, error) ||
+			!RequireNonEmptyStringField(fontJson, "path", fontPath, manifestPath, error))
+		{
+			error = "Shader font is missing required 'id' or 'path' in: " + ManifestPathMessage(manifestPath);
+			return false;
+		}
+		if (!ValidateShaderIdentifier(fontId, "fonts[].id", manifestPath, error))
+			return false;
+
+		ShaderFontAsset fontAsset;
+		fontAsset.id = fontId;
+		fontAsset.path = shaderPackage.directoryPath / fontPath;
+		if (!std::filesystem::exists(fontAsset.path))
+		{
+			error = "Shader font asset not found for package " + shaderPackage.id + ": " + fontAsset.path.string();
+			return false;
+		}
+
+		fontAsset.writeTime = std::filesystem::last_write_time(fontAsset.path);
+		shaderPackage.fontAssets.push_back(fontAsset);
+	}
+
+	return true;
+}
+
 bool ParseTemporalSettings(const JsonValue& manifestJson, ShaderPackage& shaderPackage, unsigned maxTemporalHistoryFrames, const std::filesystem::path& manifestPath, std::string& error)
 {
 	const JsonValue* temporalValue = nullptr;
@@ -461,6 +528,17 @@ bool ParseParameterDefault(const JsonValue& parameterJson, ShaderParameterDefini
 		return true;
 	}

+	if (definition.type == ShaderParameterType::Text)
+	{
+		if (!defaultValue->isString())
+		{
+			error = "Text parameter default must be a string for: " + definition.id;
+			return false;
+		}
+		definition.defaultTextValue = defaultValue->asString();
+		return true;
+	}
+
 	return NumberListFromJsonValue(*defaultValue, definition.defaultNumbers, "default", manifestPath, error);
 }

@@ -543,6 +621,30 @@ bool ParseParameterDefinition(const JsonValue& parameterJson, ShaderParameterDef
 		return false;
 	}

+	if (definition.type == ShaderParameterType::Text)
+	{
+		if (const JsonValue* fontValue = parameterJson.find("font"))
+		{
+			if (!fontValue->isString())
+			{
+				error = "Text parameter 'font' must be a string for: " + definition.id;
+				return false;
+			}
+			definition.fontId = fontValue->asString();
+			if (!definition.fontId.empty() && !ValidateShaderIdentifier(definition.fontId, "parameters[].font", manifestPath, error))
+				return false;
+		}
+		if (const JsonValue* maxLengthValue = parameterJson.find("maxLength"))
+		{
+			if (!maxLengthValue->isNumber() || maxLengthValue->asNumber() < 1.0 || maxLengthValue->asNumber() > 256.0)
+			{
+				error = "Text parameter 'maxLength' must be a number from 1 to 256 for: " + definition.id;
+				return false;
+			}
+			definition.maxLength = static_cast<unsigned>(maxLengthValue->asNumber());
+		}
+	}
+
 	if (definition.type == ShaderParameterType::Enum)
 		return ParseParameterOptions(parameterJson, definition, manifestPath, error);

@@ -693,7 +795,8 @@ bool RuntimeHost::PollFileChanges(bool& registryChanged, bool& reloadRequested,
 				}
 				if (previous->second.shaderWriteTime != item.second.shaderWriteTime ||
 					previous->second.manifestWriteTime != item.second.manifestWriteTime ||
-					!TextureAssetsEqual(previous->second.textureAssets, item.second.textureAssets))
+					!TextureAssetsEqual(previous->second.textureAssets, item.second.textureAssets) ||
+					!FontAssetsEqual(previous->second.fontAssets, item.second.fontAssets))
 				{
 					registryChanged = true;
 					break;
@@ -714,7 +817,8 @@ bool RuntimeHost::PollFileChanges(bool& registryChanged, bool& reloadRequested,
 				if (previous->second.first != active->second.shaderWriteTime ||
 					previous->second.second != active->second.manifestWriteTime ||
 					(previousPackage != previousPackages.end() &&
-						!TextureAssetsEqual(previousPackage->second.textureAssets, active->second.textureAssets)))
+						(!TextureAssetsEqual(previousPackage->second.textureAssets, active->second.textureAssets) ||
+							!FontAssetsEqual(previousPackage->second.fontAssets, active->second.fontAssets))))
 				{
 					mReloadRequested = true;
 				}
@@ -1143,6 +1247,7 @@ std::vector<RuntimeRenderState> RuntimeHost::GetLayerRenderStates(unsigned outpu
 		state.outputHeight = outputHeight;
 		state.parameterDefinitions = shaderIt->second.parameters;
 		state.textureAssets = shaderIt->second.textureAssets;
+		state.fontAssets = shaderIt->second.fontAssets;
 		state.isTemporal = shaderIt->second.temporal.enabled;
 		state.temporalHistorySource = shaderIt->second.temporal.historySource;
 		state.requestedTemporalHistoryLength = shaderIt->second.temporal.requestedHistoryLength;
@@ -1447,6 +1552,7 @@ bool RuntimeHost::ParseShaderManifest(const std::filesystem::path& manifestPath,
 	shaderPackage.manifestWriteTime = std::filesystem::last_write_time(shaderPackage.manifestPath);

 	return ParseTextureAssets(manifestJson, shaderPackage, manifestPath, error) &&
+		ParseFontAssets(manifestJson, shaderPackage, manifestPath, error) &&
 		ParseTemporalSettings(manifestJson, shaderPackage, mConfig.maxTemporalHistoryFrames, manifestPath, error) &&
 		ParseParameterDefinitions(manifestJson, shaderPackage, manifestPath, error);
 }
@@ -1465,8 +1571,62 @@ void RuntimeHost::EnsureLayerDefaultsLocked(LayerPersistentState& layerState, co
 {
 	for (const ShaderParameterDefinition& definition : shaderPackage.parameters)
 	{
-		if (layerState.parameterValues.find(definition.id) == layerState.parameterValues.end())
+		auto valueIt = layerState.parameterValues.find(definition.id);
+		if (valueIt == layerState.parameterValues.end())
+		{
 			layerState.parameterValues[definition.id] = DefaultValueForDefinition(definition);
+			continue;
+		}
+
+		JsonValue valueJson;
+		bool shouldNormalize = true;
+		switch (definition.type)
+		{
+		case ShaderParameterType::Float:
+			if (valueIt->second.numberValues.empty())
+				shouldNormalize = false;
+			else
+				valueJson = JsonValue(valueIt->second.numberValues.front());
+			break;
+		case ShaderParameterType::Vec2:
+		case ShaderParameterType::Color:
+			valueJson = JsonValue::MakeArray();
+			for (double number : valueIt->second.numberValues)
+				valueJson.pushBack(JsonValue(number));
+			break;
+		case ShaderParameterType::Boolean:
+			valueJson = JsonValue(valueIt->second.booleanValue);
+			break;
+		case ShaderParameterType::Enum:
+			valueJson = JsonValue(valueIt->second.enumValue);
+			break;
+		case ShaderParameterType::Text:
+		{
+			const std::string textValue = !valueIt->second.textValue.empty()
+				? valueIt->second.textValue
+				: valueIt->second.enumValue;
+			if (textValue.empty())
+			{
+				valueIt->second = DefaultValueForDefinition(definition);
+				shouldNormalize = false;
+			}
+			else
+			{
+				valueJson = JsonValue(textValue);
+			}
+			break;
+		}
+		}
+
+		if (!shouldNormalize)
+			continue;
+
+		ShaderParameterValue normalizedValue;
+		std::string normalizeError;
+		if (NormalizeAndValidateValue(definition, valueJson, normalizedValue, normalizeError))
+			valueIt->second = normalizedValue;
+		else
+			valueIt->second = DefaultValueForDefinition(definition);
 	}
 }

@@ -1692,6 +1852,12 @@ JsonValue RuntimeHost::SerializeLayerStackLocked() const
 				}
 				parameter.set("options", options);
 			}
+			if (definition.type == ShaderParameterType::Text)
+			{
+				parameter.set("maxLength", JsonValue(static_cast<double>(definition.maxLength)));
+				if (!definition.fontId.empty())
+					parameter.set("font", JsonValue(definition.fontId));
+			}

 			ShaderParameterValue value = DefaultValueForDefinition(definition);
 			auto valueIt = layer.parameterValues.find(definition.id);
@@ -1830,6 +1996,8 @@ JsonValue RuntimeHost::SerializeParameterValue(const ShaderParameterDefinition&
 		return JsonValue(value.booleanValue);
 	case ShaderParameterType::Enum:
 		return JsonValue(value.enumValue);
+	case ShaderParameterType::Text:
+		return JsonValue(value.textValue);
 	case ShaderParameterType::Float:
 		return JsonValue(value.numberValues.empty() ? 0.0 : value.numberValues.front());
 	case ShaderParameterType::Vec2:
--- a/apps/LoopThroughWithOpenGLCompositing/RuntimeParameterUtils.cpp
+++ b/apps/LoopThroughWithOpenGLCompositing/RuntimeParameterUtils.cpp
@@ -36,6 +36,21 @@ std::vector<double> JsonArrayToNumbers(const JsonValue& value)
 	}
 	return numbers;
 }
+
+std::string NormalizeTextValue(const std::string& text, unsigned maxLength)
+{
+	std::string normalized;
+	normalized.reserve(std::min<std::size_t>(text.size(), maxLength));
+	for (unsigned char ch : text)
+	{
+		if (ch < 32 || ch > 126)
+			continue;
+		if (normalized.size() >= maxLength)
+			break;
+		normalized.push_back(static_cast<char>(ch));
+	}
+	return normalized;
+}
 }

 std::string MakeSafePresetFileStem(const std::string& presetName)
@@ -82,6 +97,9 @@ ShaderParameterValue DefaultValueForDefinition(const ShaderParameterDefinition&
 	case ShaderParameterType::Enum:
 		value.enumValue = definition.defaultEnumValue;
 		break;
+	case ShaderParameterType::Text:
+		value.textValue = NormalizeTextValue(definition.defaultTextValue, definition.maxLength);
+		break;
 	}
 	return value;
 }
@@ -164,6 +182,14 @@ bool NormalizeAndValidateParameterValue(const ShaderParameterDefinition& definit
 		error = "Enum parameter '" + definition.id + "' received unsupported option '" + selectedValue + "'.";
 		return false;
 	}
+	case ShaderParameterType::Text:
+		if (!value.isString())
+		{
+			error = "Expected string value for text parameter '" + definition.id + "'.";
+			return false;
+		}
+		normalizedValue.textValue = NormalizeTextValue(value.asString(), definition.maxLength);
+		return true;
 	}

 	return false;
--- a/apps/LoopThroughWithOpenGLCompositing/ShaderCompiler.cpp
+++ b/apps/LoopThroughWithOpenGLCompositing/ShaderCompiler.cpp
@@ -4,6 +4,7 @@
 #include "NativeHandles.h"

 #include <fstream>
+#include <cctype>
 #include <regex>
 #include <sstream>
 #include <vector>
@@ -30,15 +31,29 @@ std::string SlangCBufferTypeForParameter(ShaderParameterType type)
 	case ShaderParameterType::Color: return "float4";
 	case ShaderParameterType::Boolean: return "bool";
 	case ShaderParameterType::Enum: return "int";
+	case ShaderParameterType::Text: return "";
 	}
 	return "float";
 }

+std::string CapitalizeIdentifier(const std::string& identifier)
+{
+	if (identifier.empty())
+		return identifier;
+	std::string text = identifier;
+	text[0] = static_cast<char>(std::toupper(static_cast<unsigned char>(text[0])));
+	return text;
+}
+
 std::string BuildParameterUniforms(const std::vector<ShaderParameterDefinition>& parameters)
 {
 	std::ostringstream source;
 	for (const ShaderParameterDefinition& definition : parameters)
+	{
+		if (definition.type == ShaderParameterType::Text)
+			continue;
 		source << "\t" << SlangCBufferTypeForParameter(definition.type) << " " << definition.id << ";\n";
+	}
 	return source.str();
 }

@@ -60,6 +75,44 @@ std::string BuildTextureSamplerDeclarations(const std::vector<ShaderTextureAsset
 	return source.str();
 }

+std::string BuildTextSamplerDeclarations(const std::vector<ShaderParameterDefinition>& parameters)
+{
+	std::ostringstream source;
+	for (const ShaderParameterDefinition& definition : parameters)
+	{
+		if (definition.type != ShaderParameterType::Text)
+			continue;
+		source << "Sampler2D<float4> " << definition.id << "Texture;\n";
+	}
+	if (source.tellp() > 0)
+		source << "\n";
+	return source.str();
+}
+
+std::string BuildTextHelpers(const std::vector<ShaderParameterDefinition>& parameters)
+{
+	std::ostringstream source;
+	for (const ShaderParameterDefinition& definition : parameters)
+	{
+		if (definition.type != ShaderParameterType::Text)
+			continue;
+		const std::string suffix = CapitalizeIdentifier(definition.id);
+		source
+			<< "float sample" << suffix << "(float2 uv)\n"
+			<< "{\n"
+			<< "\tif (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0)\n"
+			<< "\t\treturn 0.0;\n"
+			<< "\treturn " << definition.id << "Texture.Sample(uv).r;\n"
+			<< "}\n\n"
+			<< "float4 draw" << suffix << "(float2 uv, float4 fillColor)\n"
+			<< "{\n"
+			<< "\tfloat alpha = sample" << suffix << "(uv) * fillColor.a;\n"
+			<< "\treturn float4(fillColor.rgb * alpha, alpha);\n"
+			<< "}\n\n";
+	}
+	return source.str();
+}
+
 std::string BuildHistorySwitchCases(const std::string& samplerPrefix, unsigned historyLength)
 {
 	std::ostringstream source;
@@ -115,11 +168,14 @@ bool ShaderCompiler::BuildWrapperSlangSource(const ShaderPackage& shaderPackage,
 		return false;

 	wrapperSource = ReplaceAll(wrapperSource, "{{PARAMETER_UNIFORMS}}", BuildParameterUniforms(shaderPackage.parameters));
-	wrapperSource = ReplaceAll(wrapperSource, "{{SOURCE_HISTORY_SAMPLERS}}", BuildHistorySamplerDeclarations("gSourceHistory", mMaxTemporalHistoryFrames));
-	wrapperSource = ReplaceAll(wrapperSource, "{{TEMPORAL_HISTORY_SAMPLERS}}", BuildHistorySamplerDeclarations("gTemporalHistory", mMaxTemporalHistoryFrames));
+	const unsigned historySamplerCount = shaderPackage.temporal.enabled ? mMaxTemporalHistoryFrames : 0;
+	wrapperSource = ReplaceAll(wrapperSource, "{{SOURCE_HISTORY_SAMPLERS}}", BuildHistorySamplerDeclarations("gSourceHistory", historySamplerCount));
+	wrapperSource = ReplaceAll(wrapperSource, "{{TEMPORAL_HISTORY_SAMPLERS}}", BuildHistorySamplerDeclarations("gTemporalHistory", historySamplerCount));
 	wrapperSource = ReplaceAll(wrapperSource, "{{TEXTURE_SAMPLERS}}", BuildTextureSamplerDeclarations(shaderPackage.textureAssets));
-	wrapperSource = ReplaceAll(wrapperSource, "{{SOURCE_HISTORY_SWITCH_CASES}}", BuildHistorySwitchCases("gSourceHistory", mMaxTemporalHistoryFrames));
-	wrapperSource = ReplaceAll(wrapperSource, "{{TEMPORAL_HISTORY_SWITCH_CASES}}", BuildHistorySwitchCases("gTemporalHistory", mMaxTemporalHistoryFrames));
+	wrapperSource = ReplaceAll(wrapperSource, "{{TEXT_SAMPLERS}}", BuildTextSamplerDeclarations(shaderPackage.parameters));
+	wrapperSource = ReplaceAll(wrapperSource, "{{TEXT_HELPERS}}", BuildTextHelpers(shaderPackage.parameters));
+	wrapperSource = ReplaceAll(wrapperSource, "{{SOURCE_HISTORY_SWITCH_CASES}}", BuildHistorySwitchCases("gSourceHistory", historySamplerCount));
+	wrapperSource = ReplaceAll(wrapperSource, "{{TEMPORAL_HISTORY_SWITCH_CASES}}", BuildHistorySwitchCases("gTemporalHistory", historySamplerCount));
 	wrapperSource = ReplaceAll(wrapperSource, "{{USER_SHADER_INCLUDE}}", shaderPackage.shaderPath.generic_string());
 	wrapperSource = ReplaceAll(wrapperSource, "{{ENTRY_POINT_CALL}}", shaderPackage.entryPoint + "(context)");
 	return true;
--- a/apps/LoopThroughWithOpenGLCompositing/ShaderPackageRegistry.cpp
+++ b/apps/LoopThroughWithOpenGLCompositing/ShaderPackageRegistry.cpp
@@ -67,6 +67,11 @@ bool ParseShaderParameterType(const std::string& typeName, ShaderParameterType&
 		type = ShaderParameterType::Enum;
 		return true;
 	}
+	if (typeName == "text")
+	{
+		type = ShaderParameterType::Text;
+		return true;
+	}
 	return false;
 }

@@ -283,6 +288,49 @@ bool ParseTextureAssets(const JsonValue& manifestJson, ShaderPackage& shaderPack
 	return true;
 }

+bool ParseFontAssets(const JsonValue& manifestJson, ShaderPackage& shaderPackage, const std::filesystem::path& manifestPath, std::string& error)
+{
+	const JsonValue* fontsValue = nullptr;
+	if (!OptionalArrayField(manifestJson, "fonts", fontsValue, manifestPath, error))
+		return false;
+	if (!fontsValue)
+		return true;
+
+	for (const JsonValue& fontJson : fontsValue->asArray())
+	{
+		if (!fontJson.isObject())
+		{
+			error = "Shader font entry must be an object in: " + ManifestPathMessage(manifestPath);
+			return false;
+		}
+
+		std::string fontId;
+		std::string fontPath;
+		if (!RequireNonEmptyStringField(fontJson, "id", fontId, manifestPath, error) ||
+			!RequireNonEmptyStringField(fontJson, "path", fontPath, manifestPath, error))
+		{
+			error = "Shader font is missing required 'id' or 'path' in: " + ManifestPathMessage(manifestPath);
+			return false;
+		}
+		if (!ValidateShaderIdentifier(fontId, "fonts[].id", manifestPath, error))
+			return false;
+
+		ShaderFontAsset fontAsset;
+		fontAsset.id = fontId;
+		fontAsset.path = shaderPackage.directoryPath / fontPath;
+		if (!std::filesystem::exists(fontAsset.path))
+		{
+			error = "Shader font asset not found for package " + shaderPackage.id + ": " + fontAsset.path.string();
+			return false;
+		}
+
+		fontAsset.writeTime = std::filesystem::last_write_time(fontAsset.path);
+		shaderPackage.fontAssets.push_back(fontAsset);
+	}
+
+	return true;
+}
+
 bool ParseTemporalSettings(const JsonValue& manifestJson, ShaderPackage& shaderPackage, unsigned maxTemporalHistoryFrames, const std::filesystem::path& manifestPath, std::string& error)
 {
 	const JsonValue* temporalValue = nullptr;
@@ -365,6 +413,17 @@ bool ParseParameterDefault(const JsonValue& parameterJson, ShaderParameterDefini
 		return true;
 	}

+	if (definition.type == ShaderParameterType::Text)
+	{
+		if (!defaultValue->isString())
+		{
+			error = "Text parameter default must be a string for: " + definition.id;
+			return false;
+		}
+		definition.defaultTextValue = defaultValue->asString();
+		return true;
+	}
+
 	return NumberListFromJsonValue(*defaultValue, definition.defaultNumbers, "default", manifestPath, error);
 }

@@ -447,6 +506,30 @@ bool ParseParameterDefinition(const JsonValue& parameterJson, ShaderParameterDef
 		return false;
 	}

+	if (definition.type == ShaderParameterType::Text)
+	{
+		if (const JsonValue* fontValue = parameterJson.find("font"))
+		{
+			if (!fontValue->isString())
+			{
+				error = "Text parameter 'font' must be a string for: " + definition.id;
+				return false;
+			}
+			definition.fontId = fontValue->asString();
+			if (!definition.fontId.empty() && !ValidateShaderIdentifier(definition.fontId, "parameters[].font", manifestPath, error))
+				return false;
+		}
+		if (const JsonValue* maxLengthValue = parameterJson.find("maxLength"))
+		{
+			if (!maxLengthValue->isNumber() || maxLengthValue->asNumber() < 1.0 || maxLengthValue->asNumber() > 256.0)
+			{
+				error = "Text parameter 'maxLength' must be a number from 1 to 256 for: " + definition.id;
+				return false;
+			}
+			definition.maxLength = static_cast<unsigned>(maxLengthValue->asNumber());
+		}
+	}
+
 	if (definition.type == ShaderParameterType::Enum)
 		return ParseParameterOptions(parameterJson, definition, manifestPath, error);

@@ -544,6 +627,7 @@ bool ShaderPackageRegistry::ParseManifest(const std::filesystem::path& manifestP
 	shaderPackage.manifestWriteTime = std::filesystem::last_write_time(shaderPackage.manifestPath);

 	return ParseTextureAssets(manifestJson, shaderPackage, manifestPath, error) &&
+		ParseFontAssets(manifestJson, shaderPackage, manifestPath, error) &&
 		ParseTemporalSettings(manifestJson, shaderPackage, mMaxTemporalHistoryFrames, manifestPath, error) &&
 		ParseParameterDefinitions(manifestJson, shaderPackage, manifestPath, error);
 }
--- a/apps/LoopThroughWithOpenGLCompositing/ShaderTypes.h
+++ b/apps/LoopThroughWithOpenGLCompositing/ShaderTypes.h
@@ -11,7 +11,8 @@ enum class ShaderParameterType
 	Vec2,
 	Color,
 	Boolean,
-	Enum
+	Enum,
+	Text
 };

 struct ShaderParameterOption
@@ -31,6 +32,9 @@ struct ShaderParameterDefinition
 	std::vector<double> stepNumbers;
 	bool defaultBoolean = false;
 	std::string defaultEnumValue;
+	std::string defaultTextValue;
+	std::string fontId;
+	unsigned maxLength = 64;
 	std::vector<ShaderParameterOption> enumOptions;
 };

@@ -39,6 +43,7 @@ struct ShaderParameterValue
 	std::vector<double> numberValues;
 	bool booleanValue = false;
 	std::string enumValue;
+	std::string textValue;
 };

 enum class TemporalHistorySource
@@ -63,6 +68,13 @@ struct ShaderTextureAsset
 	std::filesystem::file_time_type writeTime;
 };

+struct ShaderFontAsset
+{
+	std::string id;
+	std::filesystem::path path;
+	std::filesystem::file_time_type writeTime;
+};
+
 struct ShaderPackage
 {
 	std::string id;
@@ -75,6 +87,7 @@ struct ShaderPackage
 	std::filesystem::path manifestPath;
 	std::vector<ShaderParameterDefinition> parameters;
 	std::vector<ShaderTextureAsset> textureAssets;
+	std::vector<ShaderFontAsset> fontAssets;
 	TemporalSettings temporal;
 	std::filesystem::file_time_type shaderWriteTime;
 	std::filesystem::file_time_type manifestWriteTime;
@@ -87,6 +100,7 @@ struct RuntimeRenderState
 	std::vector<ShaderParameterDefinition> parameterDefinitions;
 	std::map<std::string, ShaderParameterValue> parameterValues;
 	std::vector<ShaderTextureAsset> textureAssets;
+	std::vector<ShaderFontAsset> fontAssets;
 	double timeSeconds = 0.0;
 	double frameCount = 0.0;
 	double mixAmount = 1.0;
--- a/image.png
+++ b/image.png
--- a/runtime/templates/shader_wrapper.slang.in
+++ b/runtime/templates/shader_wrapper.slang.in
@@ -32,6 +32,7 @@ cbuffer GlobalParams

 Sampler2D<float4> gVideoInput;
 {{SOURCE_HISTORY_SAMPLERS}}{{TEMPORAL_HISTORY_SAMPLERS}}{{TEXTURE_SAMPLERS}}
+{{TEXT_SAMPLERS}}
 float4 sampleVideo(float2 tc)
 {
 	return gVideoInput.Sample(tc);
@@ -67,6 +68,7 @@ float4 sampleTemporalHistory(int framesAgo, float2 tc)
 	}
 }

+{{TEXT_HELPERS}}
 #include "{{USER_SHADER_INCLUDE}}"

 [shader("fragment")]
--- a/shaders/studio-color/shader.json
+++ b/shaders/studio-color/shader.json
@@ -1,50 +0,0 @@
-{
-  "id": "studio-color",
-  "name": "Studio Color",
-  "description": "A built-in sample shader package that demonstrates the runtime parameter contract.",
-  "category": "Color",
-  "entryPoint": "shadeVideo",
-  "parameters": [
-    {
-      "id": "brightness",
-      "label": "Brightness",
-      "type": "float",
-      "default": 1.0,
-      "min": 0.0,
-      "max": 2.0,
-      "step": 0.01
-    },
-    {
-      "id": "offset",
-      "label": "Offset",
-      "type": "vec2",
-      "default": [0.0, 0.0],
-      "min": [-0.2, -0.2],
-      "max": [0.2, 0.2],
-      "step": [0.001, 0.001]
-    },
-    {
-      "id": "tint",
-      "label": "Tint",
-      "type": "color",
-      "default": [1.0, 1.0, 1.0, 1.0]
-    },
-    {
-      "id": "invert",
-      "label": "Invert",
-      "type": "bool",
-      "default": false
-    },
-    {
-      "id": "mode",
-      "label": "Mode",
-      "type": "enum",
-      "default": "normal",
-      "options": [
-        { "value": "normal", "label": "Normal" },
-        { "value": "luma", "label": "Luma" },
-        { "value": "posterize", "label": "Posterize" }
-      ]
-    }
-  ]
-}
--- a/shaders/studio-color/shader.slang
+++ b/shaders/studio-color/shader.slang
@@ -1,23 +0,0 @@
-float4 shadeVideo(ShaderContext context)
-{
-	float2 uv = clamp(context.uv + offset, float2(0.0, 0.0), float2(1.0, 1.0));
-	float4 color = sampleVideo(uv);
-
-	color.rgb *= brightness;
-	color *= tint;
-
-	if (invert)
-		color.rgb = 1.0 - color.rgb;
-
-	if (mode == 1)
-	{
-		float luma = dot(color.rgb, float3(0.2126, 0.7152, 0.0722));
-		color.rgb = float3(luma, luma, luma);
-	}
-	else if (mode == 2)
-	{
-		color.rgb = floor(color.rgb * 4.0) / 4.0;
-	}
-
-	return saturate(color);
-}
--- a/shaders/text-overlay/fonts/OFL.txt
+++ b/shaders/text-overlay/fonts/OFL.txt
@@ -0,0 +1,93 @@
+Copyright 2011 The Roboto Project Authors (https://github.com/googlefonts/roboto-classic)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://openfontlicense.org
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
--- a/shaders/text-overlay/fonts/Roboto-Regular.ttf
+++ b/shaders/text-overlay/fonts/Roboto-Regular.ttf
--- a/shaders/text-overlay/shader.json
+++ b/shaders/text-overlay/shader.json
@@ -0,0 +1,71 @@
+{
+  "id": "text-overlay",
+  "name": "Text Overlay",
+  "description": "Single-line live text overlay using the runtime text SDF helper functions.",
+  "category": "Scopes & Guides",
+  "entryPoint": "shadeVideo",
+  "fonts": [
+    {
+      "id": "roboto",
+      "path": "fonts/Roboto-Regular.ttf"
+    }
+  ],
+  "parameters": [
+    {
+      "id": "titleText",
+      "label": "Text",
+      "type": "text",
+      "default": "VIDEO SHADER",
+      "font": "roboto",
+      "maxLength": 64
+    },
+    {
+      "id": "position",
+      "label": "Position",
+      "type": "vec2",
+      "default": [0.08, 0.12],
+      "min": [0.0, 0.0],
+      "max": [1.0, 1.0],
+      "step": [0.001, 0.001]
+    },
+    {
+      "id": "scale",
+      "label": "Scale",
+      "type": "float",
+      "default": 0.42,
+      "min": 0.1,
+      "max": 1.5,
+      "step": 0.01
+    },
+    {
+      "id": "fillColor",
+      "label": "Fill",
+      "type": "color",
+      "default": [1.0, 1.0, 1.0, 1.0]
+    },
+    {
+      "id": "outlineColor",
+      "label": "Outline",
+      "type": "color",
+      "default": [0.0, 0.0, 0.0, 0.8]
+    },
+    {
+      "id": "outlineWidth",
+      "label": "Outline Width",
+      "type": "float",
+      "default": 0.12,
+      "min": 0.0,
+      "max": 0.5,
+      "step": 0.01
+    },
+    {
+      "id": "softness",
+      "label": "Softness",
+      "type": "float",
+      "default": 0.04,
+      "min": 0.0,
+      "max": 0.3,
+      "step": 0.01
+    }
+  ]
+}
--- a/shaders/text-overlay/shader.slang
+++ b/shaders/text-overlay/shader.slang
@@ -0,0 +1,46 @@
+float alphaOver(float baseAlpha, float overAlpha)
+{
+	return overAlpha + baseAlpha * (1.0 - overAlpha);
+}
+
+float4 compositeOver(float4 baseColor, float4 overColor)
+{
+	float outAlpha = alphaOver(baseColor.a, overColor.a);
+	float3 outRgb = overColor.rgb + baseColor.rgb * (1.0 - overColor.a);
+	return float4(outRgb, outAlpha);
+}
+
+float4 shadeVideo(ShaderContext context)
+{
+	float2 resolution = max(context.outputResolution, float2(1.0, 1.0));
+	float aspect = resolution.x / resolution.y;
+	float2 textSize = float2(0.72 * scale, 0.09 * scale * aspect);
+	float2 safeTextSize = max(textSize, float2(0.0001, 0.0001));
+	float2 textUv = (context.uv - position) / safeTextSize;
+	bool insideTextRect = textUv.x >= 0.0 && textUv.x <= 1.0 && textUv.y >= 0.0 && textUv.y <= 1.0;
+
+	float mask = insideTextRect ? sampleTitleText(textUv) : 0.0;
+	float edge = 0.02;
+	float aa = max(fwidth(mask) * 1.5, 0.002);
+	float fill = smoothstep(edge - aa, edge + aa, mask);
+	float shadowRadius = min((outlineWidth + softness) * 0.025, 0.018);
+	float shadow = 0.0;
+	if (shadowRadius > 0.0001)
+	{
+		shadow = max(shadow, sampleTitleText(textUv + float2(shadowRadius, shadowRadius)));
+		shadow = max(shadow, sampleTitleText(textUv + float2(-shadowRadius, shadowRadius)));
+		shadow = max(shadow, sampleTitleText(textUv + float2(shadowRadius, -shadowRadius)));
+		shadow = max(shadow, sampleTitleText(textUv + float2(-shadowRadius, -shadowRadius)));
+	}
+	shadow = smoothstep(edge - aa, edge + aa, shadow) * (0.35 + softness);
+	float outlineAlpha = saturate(shadow * (1.0 - fill)) * outlineColor.a;
+	float fillAlpha = fill * fillColor.a;
+	float textAlpha = max(fillAlpha, outlineAlpha);
+	if (textAlpha <= 0.0001)
+		return context.sourceColor;
+
+	float4 base = context.sourceColor;
+	float4 outlineLayer = float4(outlineColor.rgb * outlineAlpha, outlineAlpha);
+	float4 fillLayer = float4(fillColor.rgb * fillAlpha, fillAlpha);
+	return saturate(compositeOver(compositeOver(base, outlineLayer), fillLayer));
+}
--- a/tests/RuntimeParameterUtilsTests.cpp
+++ b/tests/RuntimeParameterUtilsTests.cpp
@@ -100,6 +100,26 @@ void TestEnumAndDefaults()
 	error.clear();
 	Expect(!NormalizeAndValidateParameterValue(definition, JsonValue("other"), value, error), "enum rejects unknown options");
 }
+
+void TestTextNormalization()
+{
+	ShaderParameterDefinition definition;
+	definition.id = "titleText";
+	definition.type = ShaderParameterType::Text;
+	definition.defaultTextValue = "DEFAULT";
+	definition.maxLength = 6;
+
+	ShaderParameterValue defaultValue = DefaultValueForDefinition(definition);
+	Expect(defaultValue.textValue == "DEFAUL", "text default is clamped to max length");
+
+	ShaderParameterValue value;
+	std::string error;
+	Expect(NormalizeAndValidateParameterValue(definition, JsonValue("ABC\tDEF\x01GHI"), value, error), "text accepts string values");
+	Expect(value.textValue == "ABCDEF", "text drops non-printable characters and clamps length");
+
+	error.clear();
+	Expect(!NormalizeAndValidateParameterValue(definition, JsonValue(12.0), value, error), "text rejects non-string values");
+}
 }

 int main()
@@ -108,6 +128,7 @@ int main()
 	TestFloatNormalization();
 	TestVectorNormalization();
 	TestEnumAndDefaults();
+	TestTextNormalization();

 	if (gFailures != 0)
 	{
--- a/tests/ShaderPackageRegistryTests.cpp
+++ b/tests/ShaderPackageRegistryTests.cpp
@@ -47,6 +47,7 @@ void TestValidManifest()
 {
 	const std::filesystem::path root = MakeTestRoot();
 	WriteFile(root / "look" / "mask.png", "not a real png, but enough for existence checks");
+	WriteFile(root / "look" / "Inter.ttf", "not a real font, but enough for existence checks");
 	WriteShaderPackage(root, "look", R"({
 		"id": "look-01",
 		"name": "Look 01",
@@ -54,9 +55,11 @@ void TestValidManifest()
 		"category": "Tests",
 		"entryPoint": "shadeVideo",
 		"textures": [{ "id": "maskTex", "path": "mask.png" }],
+		"fonts": [{ "id": "inter", "path": "Inter.ttf" }],
 		"temporal": { "enabled": true, "historySource": "source", "historyLength": 8 },
 		"parameters": [
 			{ "id": "gain", "label": "Gain", "type": "float", "default": 0.5, "min": 0, "max": 1 },
+			{ "id": "titleText", "label": "Title", "type": "text", "default": "LIVE", "font": "inter", "maxLength": 32 },
 			{ "id": "mode", "label": "Mode", "type": "enum", "default": "soft", "options": [
 				{ "value": "soft", "label": "Soft" },
 				{ "value": "hard", "label": "Hard" }
@@ -70,8 +73,29 @@ void TestValidManifest()
 	Expect(registry.ParseManifest(root / "look" / "shader.json", package, error), "valid manifest parses");
 	Expect(package.id == "look-01", "manifest id is preserved");
 	Expect(package.textureAssets.size() == 1 && package.textureAssets[0].id == "maskTex", "texture assets parse");
+	Expect(package.fontAssets.size() == 1 && package.fontAssets[0].id == "inter", "font assets parse");
 	Expect(package.temporal.enabled && package.temporal.effectiveHistoryLength == 4, "temporal history is capped");
-	Expect(package.parameters.size() == 2, "parameters parse");
+	Expect(package.parameters.size() == 3, "parameters parse");
+	Expect(package.parameters[1].type == ShaderParameterType::Text && package.parameters[1].defaultTextValue == "LIVE", "text parameter parses");
+
+	std::filesystem::remove_all(root);
+}
+
+void TestMissingFontAsset()
+{
+	const std::filesystem::path root = MakeTestRoot();
+	WriteShaderPackage(root, "bad-font", R"({
+		"id": "bad-font",
+		"name": "Bad Font",
+		"fonts": [{ "id": "missingFont", "path": "missing.ttf" }],
+		"parameters": []
+	})");
+
+	ShaderPackageRegistry registry(4);
+	ShaderPackage package;
+	std::string error;
+	Expect(!registry.ParseManifest(root / "bad-font" / "shader.json", package, error), "missing font asset is rejected");
+	Expect(error.find("font asset not found") != std::string::npos, "missing font error is clear");

 	std::filesystem::remove_all(root);
 }
@@ -115,6 +139,7 @@ void TestDuplicateScan()
 int main()
 {
 	TestValidManifest();
+	TestMissingFontAsset();
 	TestInvalidManifest();
 	TestDuplicateScan();

--- a/ui/src/components/ParameterField.jsx
+++ b/ui/src/components/ParameterField.jsx
@@ -273,5 +273,23 @@ export function ParameterField({ layer, parameter, onParameterChange }) {
    );
  }

+  if (parameter.type === "text") {
+    return (
+      <section className="parameter">
+        {header}
+        <input
+          type="text"
+          maxLength={parameter.maxLength ?? 64}
+          placeholder={parameter.defaultValue ? `Default: ${parameter.defaultValue}` : ""}
+          value={draftValue ?? ""}
+          onFocus={beginInteraction}
+          onChange={(event) => sendValue(event.target.value)}
+          onBlur={endInteraction}
+        />
+        <ParameterValueDisplay parameterType={parameter.type} value={appliedValue} pending={isPending} />
+      </section>
+    );
+  }
+
  return null;
 }
--- a/ui/src/hooks/useThrottledParameterValue.js
+++ b/ui/src/hooks/useThrottledParameterValue.js
@@ -5,33 +5,34 @@ function valuesMatch(left, right) {
 }

 export function useThrottledParameterValue(parameter, onParameterChange) {
-  const [draftValue, setDraftValue] = useState(parameter.value);
-  const [appliedValue, setAppliedValue] = useState(parameter.value);
+  const currentValue = parameter.value === undefined ? parameter.defaultValue : parameter.value;
+  const [draftValue, setDraftValue] = useState(currentValue);
+  const [appliedValue, setAppliedValue] = useState(currentValue);
  const pendingTimeoutRef = useRef(null);
-  const latestDraftRef = useRef(parameter.value);
+  const latestDraftRef = useRef(currentValue);
  const lastSentAtRef = useRef(0);
  const isInteractingRef = useRef(false);
  const isDirtyRef = useRef(false);

  useEffect(() => {
-    setDraftValue(parameter.value);
-    setAppliedValue(parameter.value);
-    latestDraftRef.current = parameter.value;
+    setDraftValue(currentValue);
+    setAppliedValue(currentValue);
+    latestDraftRef.current = currentValue;
    lastSentAtRef.current = 0;
    isInteractingRef.current = false;
    isDirtyRef.current = false;
  }, [parameter.id]);

  useEffect(() => {
-    setAppliedValue(parameter.value);
+    setAppliedValue(currentValue);
    latestDraftRef.current = draftValue;
-    if (isDirtyRef.current && valuesMatch(parameter.value, latestDraftRef.current)) {
+    if (isDirtyRef.current && valuesMatch(currentValue, latestDraftRef.current)) {
      isDirtyRef.current = false;
    }
    if (!isInteractingRef.current && !isDirtyRef.current) {
-      setDraftValue(parameter.value);
+      setDraftValue(currentValue);
    }
-  }, [draftValue, parameter.value]);
+  }, [draftValue, currentValue]);

  useEffect(() => {
    return () => {