diff --git a/CLAUDE.md b/CLAUDE.md
index 23b8e22..20c9e80 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -23,7 +23,7 @@ dotnet run --project Coder.Editor
 ## Project Structure
 
 `ktsu.Coder` represents code as a language-agnostic AST, round-trips it through YAML, and generates
-source in five target languages. The solution uses:
+source in six target languages. The solution uses:
 
 - **ktsu.Sdk** — custom SDK providing shared build configuration
 - **MSTest.Sdk** — test project SDK with Microsoft Testing Platform
@@ -79,14 +79,17 @@ source in five target languages. The solution uses:
   C++ is the one language here that puts them on the declarator rather than the type.
   `IsConstant` is the intent rather than the keyword: C++ writes `inline constexpr` at namespace
   scope and `static constexpr` inside a type, C# writes `static readonly`, C writes `static const`
-  at file scope and a note inside a struct, having no static data member at all, and a language with no
-  spelling for it omits it the way it omits an indirection.
+  at file scope and a note inside a struct, having no static data member at all, Rust picks between
+  a `const` and a `static` with it and lets it decide whether a local is `let` or `let mut`, and a
+  language with no spelling for it omits it the way it omits an indirection.
 - `Coder/Ast/ClassDeclaration.cs`'s `SpecialisationArguments` — what makes a declaration be *for* a
   type rather than *of* one. `template<> struct Describe<RigidBody>` is how C++ attaches a fact to a
   type without touching the type, which is what a generated reflection table needs: the alternative
   is naming, and a `DescribeRigidBody` every consumer has to spell for itself is the thing a lookup
-  by type exists to avoid. Only C++ has it and the other three write a comment, the same as
-  `CompileTimeAssertion`; the arguments are `TypeReference` rather than text, though, because a
+  by type exists to avoid. C++ has it, and Rust answers it exactly — `impl Describe for RigidBody`
+  attaches facts to a type without touching the type, which is the whole of what the specialisation
+  is for; the rest write a comment, the same as `CompileTimeAssertion`. The arguments are
+  `TypeReference` rather than text, though, because a
   specialisation argument is a type and the comma in `Result<Handle, Error>` belongs to one of them
   rather than separating two.
  - `Coder/Ast/CompileTimeAssertion.cs` — what a generated type promises that the type itself cannot
@@ -94,8 +97,9 @@ source in five target languages. The solution uses:
   is language-specific in a way most of the AST is not, and there is no shared idea underneath
   `std::is_trivially_copyable_v<T>` to model. Only C++ and C have one — `static_assert` and
   `_Static_assert`, the second of which requires a message, so an assertion with none is given its
-  own condition; the others write a comment, because a file that quietly loses a guarantee looks
-  like one that still makes it.
+  own condition — and Rust, whose `const _: () = assert!(…)` needs no macro crate because a constant
+  nobody names still has to be evaluated for the program to build; the others write a comment,
+  because a file that quietly loses a guarantee looks like one that still makes it.
 - `Coder/Languages/LanguageGeneratorBase.cs` — the emitters every generator shares.
 - `Coder/Languages/StandardLanguageGenerator.cs` — owns the node dispatch, so a derived
   generator supplies only the syntax its language does not share. `CSharpGenerator` deliberately
@@ -116,6 +120,19 @@ source in five target languages. The solution uses:
   underlying type. `Coder.Test/Languages/CGeneratedSourceCompilesTests.cs` compiles what it writes,
   because C's rules about linkage, empty parameter lists and what may initialise an object with
   static storage duration are not visible in the text.
+- `Coder/Languages/RustGenerator.cs` — the target with the most to map onto, and so the one where the
+  interesting question is which feature each part of a declaration became rather than what to write
+  in place of it. Data goes in a `struct` and behaviour in an `impl` block; an interface is a `trait`
+  and a base type on one is a supertrait; a destructor is `impl Drop`, an operator is its `std::ops`
+  trait, a conversion is `impl From`, and a specialisation is `impl Trait for Type` — which is the
+  one place a target answers C++'s explicit specialisation exactly. What is left over is inheritance,
+  which Rust does not have, and the operators it supplies from another one and will not let a type
+  define by itself. `Coder.Editor/RustSyntax.cs` registers the highlighter definition, because the
+  highlighter ships fifteen languages and Rust is not one of them.
+- `Coder.Test/Languages/CompiledExemplar.cs` — one AST, compiled by two real compilers. The C and
+  Rust generators are each checked by compiling what they write, and they are checked against the
+  same declarations, which says more than two parallel fixtures could: the claim being made is that
+  the same AST comes out as valid source in each target.
 - `Coder.Graph/AstSchema.cs` — the uniform view of the AST's parent/child structure, hand-written
   rather than reflective. Adding a node type means adding it here.
 - `Coder.Graph/AstFields.cs` — a node's editable properties as named fields of a kind, which is what
diff --git a/Coder.Editor/Coder.Editor.csproj b/Coder.Editor/Coder.Editor.csproj
index 2ca9794..2325efc 100644
--- a/Coder.Editor/Coder.Editor.csproj
+++ b/Coder.Editor/Coder.Editor.csproj
@@ -14,6 +14,7 @@
     <PackageReference Include="ktsu.ImGui.App" />
     <!-- The preview pane draws the generated source highlighted rather than as flat text. -->
     <PackageReference Include="ktsu.ImGui.SyntaxHighlighting" />
+    <PackageReference Include="ktsu.SyntaxHighlighting" />
     <!-- The panes are divider containers, so the user sizes them rather than the application. -->
     <PackageReference Include="ktsu.ImGui.Widgets" />
     <!-- Remembering whether the window was maximized means naming WindowState, which lives here
diff --git a/Coder.Editor/CoderEditorApp.cs b/Coder.Editor/CoderEditorApp.cs
index 90cf89b..283e86a 100644
--- a/Coder.Editor/CoderEditorApp.cs
+++ b/Coder.Editor/CoderEditorApp.cs
@@ -418,6 +418,16 @@ private void DrawCodePane()
 	/// </remarks>
 	private static readonly SyntaxHighlightConfig CodeStyle = new() { ShowLineNumbers = true };
 
+	/// <summary>
+	/// Teaches the highlighter the one language it does not already know.
+	/// </summary>
+	/// <remarks>
+	/// A static constructor rather than a call from somewhere: the registry is process-global and the
+	/// preview reaches it from a draw call, so the registration has to have happened before any
+	/// instance of this class draws anything, whichever one draws first.
+	/// </remarks>
+	static CoderEditorApp() => RustSyntax.Register();
+
 	/// <summary>
 	/// Draws the generated source, highlighted for the language it was generated in.
 	/// </summary>
diff --git a/Coder.Editor/RustSyntax.cs b/Coder.Editor/RustSyntax.cs
new file mode 100644
index 0000000..1d328cf
--- /dev/null
+++ b/Coder.Editor/RustSyntax.cs
@@ -0,0 +1,97 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Coder.Editor;
+
+using ktsu.SyntaxHighlighting;
+
+/// <summary>
+/// Teaches the syntax highlighter to read Rust.
+/// </summary>
+/// <remarks>
+/// The highlighter ships definitions for fifteen languages and Rust is not one of them, so the
+/// preview pane would draw generated Rust as plain text — the one failure mode
+/// <c>ImGuiSyntaxHighlighting</c> has, and a silent one. Definitions are plain data and the registry
+/// takes one from an application, which is what this is.
+/// <para>
+/// It lives in the editor rather than in the library for the reason the library has no UI
+/// dependency at all: what a language looks like on a screen is the editor's business, and
+/// <c>RustGenerator</c> would not otherwise know that a highlighter exists.
+/// </para>
+/// <para>
+/// The keyword list is the language's, not the generator's. A highlighter reads whatever is in the
+/// pane — a file somebody opened, or output from a generator that has learned a new spelling since
+/// — so listing only what this generator emits today would make the pane wrong tomorrow.
+/// </para>
+/// </remarks>
+internal static class RustSyntax
+{
+	/// <summary>
+	/// The language name the generator reports and the highlighter is asked for.
+	/// </summary>
+	private const string LanguageName = "rust";
+
+	/// <summary>
+	/// Registers the definition, if it is not registered already.
+	/// </summary>
+	/// <remarks>
+	/// Idempotent, and deliberately: the registry is process-global, the editor builds more than one
+	/// application object over a test run, and registering twice would replace a definition with an
+	/// identical one for no reason.
+	/// </remarks>
+	public static void Register()
+	{
+		if (LanguageRegistry.TryGet(LanguageName, out _))
+		{
+			return;
+		}
+
+		LanguageRegistry.Register(Definition);
+	}
+
+	/// <summary>
+	/// Gets what the tokenizer needs in order to read Rust.
+	/// </summary>
+	private static LanguageDefinition Definition => new()
+	{
+		Name = LanguageName,
+		Aliases = ["rs"],
+		CaseSensitive = true,
+
+		// `///` and `//!` are documentation and are drawn as such; `//` is an ordinary comment. The
+		// documentation forms come first, because the first rule that matches wins and every one of
+		// them starts with the ordinary one.
+		LineComments =
+		[
+			new LineCommentRule { Prefix = "///", Kind = TokenKind.DocComment },
+			new LineCommentRule { Prefix = "//!", Kind = TokenKind.DocComment },
+			new LineCommentRule { Prefix = "//" },
+		],
+		BlockComments = [new BlockCommentRule { Open = "/*", Close = "*/" }],
+		Strings =
+		[
+			new StringRule { Open = "\"", Close = "\"" },
+			new StringRule { Open = "'", Close = "'" },
+		],
+
+		Keywords =
+		[
+			"as", "async", "await", "const", "crate", "dyn", "enum", "extern", "fn", "impl", "in",
+			"let", "mod", "move", "mut", "pub", "ref", "self", "Self", "static", "struct", "super",
+			"trait", "type", "union", "unsafe", "use", "where",
+		],
+		ControlKeywords = ["break", "continue", "else", "for", "if", "loop", "match", "return", "while"],
+		Types =
+		[
+			"bool", "char", "f32", "f64", "i8", "i16", "i32", "i64", "i128", "isize", "str",
+			"u8", "u16", "u32", "u64", "u128", "usize", "String", "Vec", "Box", "Option", "Result",
+			"HashMap", "HashSet",
+		],
+		Constants = ["true", "false", "None", "Some", "Ok", "Err"],
+
+		HighlightFunctionCalls = true,
+		IdentifierCharacters = "_",
+		IdentifierStartCharacters = "_",
+		OperatorCharacters = "+-*/%=<>!&|^~?:",
+		PunctuationCharacters = "(){}[];,.",
+	};
+}
diff --git a/Coder.Test/Editor/CoderEditorAppTests.cs b/Coder.Test/Editor/CoderEditorAppTests.cs
index b489076..6589546 100644
--- a/Coder.Test/Editor/CoderEditorAppTests.cs
+++ b/Coder.Test/Editor/CoderEditorAppTests.cs
@@ -61,7 +61,7 @@ private static DocumentStore NewStore() =>
 	private string PathIn(string name) => Path.Combine(root, name + DocumentStore.Extension);
 
 	private static CoderEditorApp NewApp(DocumentStore store, EditorSettings? settings = null) =>
-		new(store, [new CSharpGenerator(), new PythonGenerator(), new CppGenerator(), new CGenerator(), new JavaScriptGenerator()],
+		new(store, [new CSharpGenerator(), new PythonGenerator(), new CppGenerator(), new CGenerator(), new RustGenerator(), new JavaScriptGenerator()],
 			settings ?? new EditorSettings());
 
 	/// <summary>
diff --git a/Coder.Test/Editor/EditorWiringTests.cs b/Coder.Test/Editor/EditorWiringTests.cs
index 72a1b37..a9f7598 100644
--- a/Coder.Test/Editor/EditorWiringTests.cs
+++ b/Coder.Test/Editor/EditorWiringTests.cs
@@ -24,7 +24,7 @@ public sealed class EditorWiringTests
 {
 	private const string ConfigHomeVariable = "XDG_CONFIG_HOME";
 
-	private static readonly string[] ExpectedLanguageIds = ["python", "csharp", "javascript", "cpp", "c"];
+	private static readonly string[] ExpectedLanguageIds = ["python", "csharp", "javascript", "cpp", "c", "rust"];
 	private static readonly string[] ExpectedRecentFiles = ["/work/second.coder.yaml", "/work/first.coder.yaml"];
 
 	private string root = string.Empty;
diff --git a/Coder.Test/Editor/GeneratedCodeHighlightingTests.cs b/Coder.Test/Editor/GeneratedCodeHighlightingTests.cs
index 198e6ca..b0b4b24 100644
--- a/Coder.Test/Editor/GeneratedCodeHighlightingTests.cs
+++ b/Coder.Test/Editor/GeneratedCodeHighlightingTests.cs
@@ -3,6 +3,7 @@
 namespace ktsu.Coder.Test.Editor;
 
 using ktsu.Coder.Ast;
+using ktsu.Coder.Editor;
 using ktsu.Coder.Languages;
 using ktsu.ImGui.SyntaxHighlighting;
 using ktsu.SyntaxHighlighting;
@@ -35,8 +36,21 @@ private static FunctionDeclaration SampleFunction()
 		return function;
 	}
 
+	/// <summary>
+	/// Teaches the highlighter what the editor teaches it.
+	/// </summary>
+	/// <remarks>
+	/// The highlighter ships fifteen languages and Rust is not one of them, so the editor registers a
+	/// definition for it at startup. This is that same registration: without it the assertion below
+	/// would be checking a language nothing had told the highlighter about, and with it the
+	/// assertion checks the definition as well as the id.
+	/// </remarks>
+	/// <param name="context">The test context, which this does not read.</param>
+	[ClassInitialize]
+	public static void RegisterEditorLanguages(TestContext context) => RustSyntax.Register();
+
 	private static ILanguageGenerator[] Generators() =>
-		[new CSharpGenerator(), new PythonGenerator(), new CppGenerator(), new CGenerator(), new JavaScriptGenerator()];
+		[new CSharpGenerator(), new PythonGenerator(), new CppGenerator(), new CGenerator(), new RustGenerator(), new JavaScriptGenerator()];
 
 	/// <summary>
 	/// Tests that every generator's language id is one the highlighter recognises, by generating real
diff --git a/Coder.Test/Languages/CGeneratedSourceCompilesTests.cs b/Coder.Test/Languages/CGeneratedSourceCompilesTests.cs
index 09a8b63..2ddaaef 100644
--- a/Coder.Test/Languages/CGeneratedSourceCompilesTests.cs
+++ b/Coder.Test/Languages/CGeneratedSourceCompilesTests.cs
@@ -2,7 +2,6 @@
 
 namespace ktsu.Coder.Test.Languages;
 
-using System.Diagnostics;
 using ktsu.Coder.Ast;
 using ktsu.Coder.Languages;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -62,7 +61,7 @@ int main(void)
 		{
 			Point built = Point_create(1, 2);
 			Point zeroed = Point_zero();
-			Origin first = origins[0];
+			Origin first = ORIGINS[0];
 			Shape shape = { .draw = circle_draw, .area = circle_area };
 			Colour colour = Colour_Green;
 
@@ -80,34 +79,27 @@ int main(void)
 	[TestMethod]
 	public void GeneratedHeader_Compiles()
 	{
-		string? compiler = FindCompiler();
+		string? compiler = ToolchainHarness.FindOnPath(Compilers);
 		if (compiler is null)
 		{
 			Assert.Inconclusive("No C compiler on the path, so nothing was compiled.");
 			return;
 		}
 
-		string directory = Path.Combine(Path.GetTempPath(), $"coder-c-{Guid.NewGuid():N}");
-		Directory.CreateDirectory(directory);
-
-		try
+		ToolchainHarness.InTemporaryDirectory(directory =>
 		{
 			File.WriteAllText(
 				Path.Combine(directory, "exemplar.h"),
 				new CGenerator().Generate(Exemplar()));
 			File.WriteAllText(Path.Combine(directory, "driver.c"), Driver);
 
-			(int exitCode, string output) = Run(
+			(int exitCode, string output) = ToolchainHarness.Run(
 				compiler,
-				$"-std=c11 -Wall -Wextra -pedantic -c driver.c -o driver.o",
+				"-std=c11 -Wall -Wextra -pedantic -c driver.c -o driver.o",
 				directory);
 
 			Assert.AreEqual(0, exitCode, $"{compiler} rejected the generated header:{Environment.NewLine}{output}");
-		}
-		finally
-		{
-			Directory.Delete(directory, recursive: true);
-		}
+		});
 	}
 
 	/// <summary>
@@ -120,68 +112,11 @@ private static SourceFile Exemplar()
 		file.HeaderComment.Add("Generated by Coder. Do not edit.");
 		file.Imports.Add("<stdbool.h>");
 
-		EnumDeclaration colour = new("Colour") { UnderlyingType = "int" };
-		colour.Documentation.Add("What something is coloured.");
-		colour.Members.Add(new EnumMember("Red") { Value = "1" });
-		colour.Members.Add(new EnumMember("Green"));
-
-		ClassDeclaration point = new("Point") { Kind = TypeDeclarationKind.Struct };
-		point.Documentation.Add("Somewhere on a surface.");
-		point.Members.Add(new VariableDeclaration("x", "int"));
-		point.Members.Add(new VariableDeclaration("y", "int", new LiteralExpression<int>(1)));
-
-		FunctionDeclaration create = new("Point") { Kind = FunctionKind.Constructor };
-		create.Parameters.Add(new Parameter("x", "int"));
-		create.Parameters.Add(new Parameter("y", "int") { IsOptional = true, DefaultValue = "0" });
-		create.Initialisers.Add(new MemberInitialiser("x") { Value = new VariableReference("x") });
-		create.Initialisers.Add(new MemberInitialiser("y") { Value = new VariableReference("y") });
-		point.Members.Add(create);
-
-		ConstructionExpression origin = new(new TypeReference("Point"));
-		origin.Arguments.Add(new MemberInitialiser("x") { Value = new LiteralExpression<int>(0) });
-		origin.Arguments.Add(new MemberInitialiser("y") { Value = new LiteralExpression<int>(0) });
-
-		FunctionDeclaration zero = new("zero") { ReturnType = "Point", IsStatic = true, IsPure = true };
-		zero.Body.Add(new ReturnStatement(origin));
-		point.Members.Add(zero);
-
-		ClassDeclaration shape = new("Shape") { Kind = TypeDeclarationKind.Interface };
-		shape.Documentation.Add("What every shape can do.");
-		FunctionDeclaration draw = new("draw") { IsAbstract = true };
-		draw.Parameters.Add(new Parameter("scale", "double"));
-		shape.Members.Add(draw);
-		shape.Members.Add(new FunctionDeclaration("area")
-		{
-			ReturnType = "double",
-			IsReadOnly = true,
-			IsAbstract = true,
-		});
-
-		UsingAlias origins = new() { Name = "Origin", AliasedType = "Point" };
-
-		ConstructionExpression table = new(type: null);
-		foreach (int offset in new[] { 0, 1 })
-		{
-			ConstructionExpression row = new(new TypeReference("Point"));
-			row.Arguments.Add(new MemberInitialiser("x") { Value = new LiteralExpression<int>(offset) });
-			row.Arguments.Add(new MemberInitialiser("y") { Value = new LiteralExpression<int>(offset) });
-			table.Arguments.Add(row);
-		}
-
-		FieldDeclaration origin_table = new()
-		{
-			Name = "origins",
-			Type = new TypeReference("Point") { IsArray = true, IsReadOnly = true },
-			IsConstant = true,
-			InitialValue = table,
-		};
-		origin_table.Documentation.Add("Where each shape starts.");
-
-		file.Members.Add(colour);
-		file.Members.Add(point);
-		file.Members.Add(shape);
-		file.Members.Add(origins);
-		file.Members.Add(origin_table);
+		file.Members.Add(CompiledExemplar.Colour());
+		file.Members.Add(CompiledExemplar.Point());
+		file.Members.Add(CompiledExemplar.Shape());
+		file.Members.Add(CompiledExemplar.OriginAlias());
+		file.Members.Add(CompiledExemplar.OriginTable());
 		file.Members.Add(new CompileTimeAssertion
 		{
 			Condition = "sizeof(Point) == 2 * sizeof(int)",
@@ -190,47 +125,4 @@ private static SourceFile Exemplar()
 
 		return file;
 	}
-
-	/// <summary>
-	/// Finds the first compiler on the path.
-	/// </summary>
-	/// <returns>Its name, or null when there is none.</returns>
-	private static string? FindCompiler() =>
-		Compilers.FirstOrDefault(compiler => Run(compiler, "--version", Path.GetTempPath()).ExitCode == 0);
-
-	/// <summary>
-	/// Runs a command, waiting for it to finish.
-	/// </summary>
-	/// <param name="command">The executable to run.</param>
-	/// <param name="arguments">Its arguments.</param>
-	/// <param name="workingDirectory">Where to run it.</param>
-	/// <returns>What it exited with, and everything it wrote.</returns>
-	private static (int ExitCode, string Output) Run(string command, string arguments, string workingDirectory)
-	{
-		ProcessStartInfo start = new(command, arguments)
-		{
-			WorkingDirectory = workingDirectory,
-			RedirectStandardOutput = true,
-			RedirectStandardError = true,
-			UseShellExecute = false,
-		};
-
-		try
-		{
-			using Process? process = Process.Start(start);
-			if (process is null)
-			{
-				return (-1, string.Empty);
-			}
-
-			string output = process.StandardOutput.ReadToEnd() + process.StandardError.ReadToEnd();
-			process.WaitForExit();
-			return (process.ExitCode, output);
-		}
-		catch (System.ComponentModel.Win32Exception)
-		{
-			// The command is not on the path, which is the answer rather than a failure.
-			return (-1, string.Empty);
-		}
-	}
 }
diff --git a/Coder.Test/Languages/CompiledExemplar.cs b/Coder.Test/Languages/CompiledExemplar.cs
new file mode 100644
index 0000000..2e9b88c
--- /dev/null
+++ b/Coder.Test/Languages/CompiledExemplar.cs
@@ -0,0 +1,130 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Coder.Test.Languages;
+
+using ktsu.Coder.Ast;
+
+/// <summary>
+/// The declarations every generator that is checked by compiling its output is checked against.
+/// </summary>
+/// <remarks>
+/// One AST, two real compilers. Building a parallel one per language would say less than this does:
+/// what is being claimed is that the *same* declarations come out as valid source in each target,
+/// which is the whole premise of a language-agnostic AST and is not something two similar-looking
+/// fixtures can demonstrate.
+/// <para>
+/// What each test adds for itself is what only that language has to answer — C's struct of function
+/// pointers reached through a driver, Rust's operator traits and its implementation for a type. What
+/// is here is what both have to answer, and nothing whose spelling depends on the receiver: a body
+/// that reads a member says <c>self-&gt;x</c> in one language and <c>self.x</c> in the other, so
+/// those belong to whichever test is about that language.
+/// </para>
+/// </remarks>
+internal static class CompiledExemplar
+{
+	/// <summary>
+	/// Gets the enumeration, which fixes its representation and gives one member a value.
+	/// </summary>
+	/// <returns>The declaration.</returns>
+	public static EnumDeclaration Colour()
+	{
+		EnumDeclaration colour = new("Colour") { UnderlyingType = "int" };
+		colour.Documentation.Add("What something is coloured.");
+		colour.Members.Add(new EnumMember("Red") { Value = "1" });
+		colour.Members.Add(new EnumMember("Green"));
+		return colour;
+	}
+
+	/// <summary>
+	/// Gets the type both languages build a value of: two fields, a constructor and a static.
+	/// </summary>
+	/// <returns>The declaration, which a caller may add its own members to.</returns>
+	public static ClassDeclaration Point()
+	{
+		ClassDeclaration point = new("Point") { Kind = TypeDeclarationKind.Struct };
+		point.Documentation.Add("Somewhere on a surface.");
+		point.Members.Add(new VariableDeclaration("x", "int"));
+		point.Members.Add(new VariableDeclaration("y", "int", new LiteralExpression<int>(1)));
+
+		FunctionDeclaration create = new("Point") { Kind = FunctionKind.Constructor };
+		create.Parameters.Add(new Parameter("x", "int"));
+		create.Parameters.Add(new Parameter("y", "int") { IsOptional = true, DefaultValue = "0" });
+		create.Initialisers.Add(new MemberInitialiser("x") { Value = new VariableReference("x") });
+		create.Initialisers.Add(new MemberInitialiser("y") { Value = new VariableReference("y") });
+		point.Members.Add(create);
+
+		FunctionDeclaration zero = new("zero") { ReturnType = "Point", IsStatic = true, IsPure = true };
+		zero.Body.Add(new ReturnStatement(Origin(0)));
+		point.Members.Add(zero);
+
+		return point;
+	}
+
+	/// <summary>
+	/// Gets the set of members an implementation supplies.
+	/// </summary>
+	/// <returns>The declaration.</returns>
+	public static ClassDeclaration Shape()
+	{
+		ClassDeclaration shape = new("Shape") { Kind = TypeDeclarationKind.Interface };
+		shape.Documentation.Add("What every shape can do.");
+
+		FunctionDeclaration draw = new("draw") { IsAbstract = true };
+		draw.Parameters.Add(new Parameter("scale", "double"));
+		shape.Members.Add(draw);
+
+		shape.Members.Add(new FunctionDeclaration("area")
+		{
+			ReturnType = "double",
+			IsReadOnly = true,
+			IsAbstract = true,
+		});
+
+		return shape;
+	}
+
+	/// <summary>
+	/// Gets a second name for the type.
+	/// </summary>
+	/// <returns>The alias.</returns>
+	public static UsingAlias OriginAlias() => new() { Name = "Origin", AliasedType = "Point" };
+
+	/// <summary>
+	/// Gets the table: a constant array of rows that each name the member every value is for.
+	/// </summary>
+	/// <returns>The declaration.</returns>
+	/// <remarks>
+	/// This is the one that has caught the most. A table with no length has to be spelled as
+	/// something that can be a constant, and what that something is differs by language.
+	/// </remarks>
+	public static FieldDeclaration OriginTable()
+	{
+		ConstructionExpression table = new(type: null);
+		table.Arguments.Add(Origin(0));
+		table.Arguments.Add(Origin(1));
+
+		FieldDeclaration origins = new()
+		{
+			Name = "ORIGINS",
+			Type = new TypeReference("Point") { IsArray = true, IsReadOnly = true },
+			IsConstant = true,
+			InitialValue = table,
+		};
+		origins.Documentation.Add("Where each shape starts.");
+
+		return origins;
+	}
+
+	/// <summary>
+	/// Builds one row of the table, or the value the static answers.
+	/// </summary>
+	/// <param name="offset">What both members hold.</param>
+	/// <returns>The expression.</returns>
+	private static ConstructionExpression Origin(int offset)
+	{
+		ConstructionExpression row = new(new TypeReference("Point"));
+		row.Arguments.Add(new MemberInitialiser("x") { Value = new LiteralExpression<int>(offset) });
+		row.Arguments.Add(new MemberInitialiser("y") { Value = new LiteralExpression<int>(offset) });
+		return row;
+	}
+}
diff --git a/Coder.Test/Languages/GeneratedLineEndingTests.cs b/Coder.Test/Languages/GeneratedLineEndingTests.cs
index 43506e0..f1c5bee 100644
--- a/Coder.Test/Languages/GeneratedLineEndingTests.cs
+++ b/Coder.Test/Languages/GeneratedLineEndingTests.cs
@@ -46,6 +46,7 @@ private static FunctionDeclaration MultiLineFunction()
 	[DataRow("csharp")]
 	[DataRow("cpp")]
 	[DataRow("c")]
+	[DataRow("rust")]
 	[DataRow("javascript")]
 	public void Generators_EmitLineFeedsOnly(string languageId)
 	{
@@ -55,6 +56,7 @@ public void Generators_EmitLineFeedsOnly(string languageId)
 			"csharp" => new CSharpGenerator(),
 			"cpp" => new CppGenerator(),
 			"c" => new CGenerator(),
+			"rust" => new RustGenerator(),
 			"javascript" => new JavaScriptGenerator(),
 			_ => throw new ArgumentOutOfRangeException(nameof(languageId))
 		};
diff --git a/Coder.Test/Languages/RustGeneratedSourceCompilesTests.cs b/Coder.Test/Languages/RustGeneratedSourceCompilesTests.cs
new file mode 100644
index 0000000..b5a673a
--- /dev/null
+++ b/Coder.Test/Languages/RustGeneratedSourceCompilesTests.cs
@@ -0,0 +1,257 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Coder.Test.Languages;
+
+using ktsu.Coder.Ast;
+using ktsu.Coder.Languages;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+/// <summary>
+/// Compiles what <see cref="RustGenerator"/> writes, with a real Rust compiler.
+/// </summary>
+/// <remarks>
+/// The C generator earned a test like this because C's rules about linkage and constant expressions
+/// are invisible in the text. Rust's reason is larger: a receiver that should have been
+/// <c>&amp;mut self</c>, an associated item carrying a visibility it is not allowed, a trait
+/// implementation missing the <c>Output</c> it has to name, a <c>const</c> that cannot be one —
+/// each of those is a spelling a test can pin and a compiler rejects, and only one of them notices.
+/// <para>
+/// The exemplar is compiled as a library rather than run, because what is being checked is that the
+/// declarations are well formed, not what they compute. The lint that fires on the output is allowed
+/// by name at the top of the file rather than by silencing everything: parentheses come from the
+/// AST carrying no operator precedence, which is a property of the AST rather than a mistake in this
+/// generator.
+/// </para>
+/// <para>
+/// The test is inconclusive rather than failing where no compiler is on the path, which is the
+/// honest result: nothing was checked.
+/// </para>
+/// </remarks>
+[TestClass]
+public class RustGeneratedSourceCompilesTests
+{
+	/// <summary>
+	/// Tests that a file holding one of everything the generator writes compiles.
+	/// </summary>
+	[TestMethod]
+	public void GeneratedSource_Compiles()
+	{
+		if (ToolchainHarness.FindOnPath("rustc") is null)
+		{
+			Assert.Inconclusive("No Rust compiler on the path, so nothing was compiled.");
+			return;
+		}
+
+		ToolchainHarness.InTemporaryDirectory(directory =>
+		{
+			// The AST carries no operator precedence, so every binary expression is parenthesised and
+			// Rust says so. The lints are named rather than blanket-silenced: each one is a property
+			// of what an exemplar is — declarations nothing calls, holding values nothing reads.
+			string source = new RustGenerator().Generate(Exemplar());
+			string allowed = "#![allow(unused_parens, dead_code, unused_variables, unused_mut)]";
+
+			File.WriteAllText(
+				Path.Combine(directory, "exemplar.rs"),
+				$"{allowed}{Environment.NewLine}{source}");
+
+			(int exitCode, string output) = ToolchainHarness.Run(
+				"rustc",
+				"--crate-type lib --edition 2021 -o exemplar.rlib exemplar.rs",
+				directory);
+
+			Assert.AreEqual(0, exitCode, $"rustc rejected the generated source:{Environment.NewLine}{output}");
+		});
+	}
+
+	/// <summary>
+	/// Builds a file holding one of everything the generator has a spelling for.
+	/// </summary>
+	/// <returns>The file to generate.</returns>
+	private static SourceFile Exemplar()
+	{
+		SourceFile file = new("exemplar");
+		file.HeaderComment.Add("Generated by Coder. Do not edit.");
+
+		ClassDeclaration point = CompiledExemplar.Point();
+		point.Members.Add(Sum());
+		point.Members.Add(Shift());
+		point.Members.Add(Plus());
+		point.Members.Add(Negate());
+		point.Members.Add(ToDouble());
+
+		ClassDeclaration circle = new("Circle") { BaseType = "Point" };
+		circle.Documentation.Add("A shape with one radius.");
+		circle.Members.Add(new VariableDeclaration("radius", "double"));
+
+		FunctionDeclaration drop = new("Circle") { Kind = FunctionKind.Destructor };
+		drop.Body.Add(new VariableDeclaration("going", "bool", new LiteralExpression<bool>(true)));
+		circle.Members.Add(drop);
+
+		NamespaceDeclaration geometry = new("geo.shapes");
+		geometry.Members.Add(CompiledExemplar.Colour());
+		geometry.Members.Add(point);
+		geometry.Members.Add(CompiledExemplar.Shape());
+		geometry.Members.Add(circle);
+		geometry.Members.Add(Describe());
+		geometry.Members.Add(DescribesPoint());
+		geometry.Members.Add(CompiledExemplar.OriginAlias());
+		geometry.Members.Add(CompiledExemplar.OriginTable());
+		geometry.Members.Add(Measure());
+		geometry.Members.Add(new CompileTimeAssertion
+		{
+			Condition = "std::mem::size_of::<i32>() == 4",
+			Message = "an i32 is four bytes",
+		});
+
+		file.Members.Add(geometry);
+		return file;
+	}
+
+	/// <summary>
+	/// Builds a member that reads the instance without modifying it.
+	/// </summary>
+	/// <returns>The declaration.</returns>
+	private static FunctionDeclaration Sum()
+	{
+		FunctionDeclaration sum = new("sum") { ReturnType = "int", IsReadOnly = true, IsPure = true };
+		sum.Body.Add(new ReturnStatement(new BinaryExpression(
+			new VariableReference("self.x"), BinaryOperator.Add, new VariableReference("self.y"))));
+		return sum;
+	}
+
+	/// <summary>
+	/// Builds a member that modifies the instance, which is what earns it a mutable receiver.
+	/// </summary>
+	/// <returns>The declaration.</returns>
+	private static FunctionDeclaration Shift()
+	{
+		FunctionDeclaration shift = new("shift");
+		shift.Parameters.Add(new Parameter("dx", "int"));
+		shift.Body.Add(new AssignmentStatement(
+			new VariableReference("self.x"), new VariableReference("dx"), AssignmentOperator.AddAssign));
+		return shift;
+	}
+
+	/// <summary>
+	/// Builds the binary operator, which has to become a trait implementation naming its output.
+	/// </summary>
+	/// <returns>The declaration.</returns>
+	private static FunctionDeclaration Plus()
+	{
+		FunctionDeclaration plus = new("+") { Kind = FunctionKind.Operator, ReturnType = "Point" };
+		plus.Parameters.Add(new Parameter("rhs", "Point"));
+		plus.Body.Add(new ReturnStatement(Combined("rhs")));
+		return plus;
+	}
+
+	/// <summary>
+	/// Builds the unary operator that shares its symbol with the binary one.
+	/// </summary>
+	/// <returns>The declaration.</returns>
+	private static FunctionDeclaration Negate()
+	{
+		FunctionDeclaration negate = new("-") { Kind = FunctionKind.Operator, ReturnType = "Point" };
+		negate.Body.Add(new ReturnStatement(Combined(null)));
+		return negate;
+	}
+
+	/// <summary>
+	/// Builds the value an operator answers with.
+	/// </summary>
+	/// <param name="operand">The operand to combine each member with, or null to negate it.</param>
+	/// <returns>The expression.</returns>
+	private static ConstructionExpression Combined(string? operand)
+	{
+		ConstructionExpression built = new(new TypeReference("Point"));
+
+		foreach (string member in new[] { "x", "y" })
+		{
+			Expression value = operand is null
+				? new UnaryExpression(UnaryOperator.Negate, new VariableReference($"self.{member}"))
+				: new BinaryExpression(
+					new VariableReference($"self.{member}"),
+					BinaryOperator.Add,
+					new VariableReference($"{operand}.{member}"));
+
+			built.Arguments.Add(new MemberInitialiser(member) { Value = value });
+		}
+
+		return built;
+	}
+
+	/// <summary>
+	/// Builds the conversion, which has to become an implementation of <c>From</c>.
+	/// </summary>
+	/// <returns>The declaration.</returns>
+	private static FunctionDeclaration ToDouble()
+	{
+		FunctionDeclaration conversion = new("ignored")
+		{
+			Kind = FunctionKind.ConversionOperator,
+			ReturnType = "double",
+			IsReadOnly = true,
+		};
+		conversion.Body.Add(new ReturnStatement(new VariableReference("value.x as f64")));
+		return conversion;
+	}
+
+	/// <summary>
+	/// Builds a trait whose constant every implementation has to supply.
+	/// </summary>
+	/// <returns>The declaration.</returns>
+	private static ClassDeclaration Describe()
+	{
+		ClassDeclaration describe = new("Describe") { Kind = TypeDeclarationKind.Interface };
+		describe.Documentation.Add("What a type says about itself.");
+		describe.Members.Add(new FieldDeclaration { Name = "NAME", Type = BorrowedString() });
+		return describe;
+	}
+
+	/// <summary>
+	/// Builds the declaration that is for a type rather than of one.
+	/// </summary>
+	/// <returns>The declaration.</returns>
+	private static ClassDeclaration DescribesPoint()
+	{
+		ClassDeclaration specialisation = new("Describe")
+		{
+			SpecialisationArguments = { new TypeReference("Point") },
+		};
+
+		specialisation.Members.Add(new FieldDeclaration
+		{
+			Name = "NAME",
+			Type = BorrowedString(),
+			InitialValue = new LiteralExpression<string>("Point"),
+		});
+
+		return specialisation;
+	}
+
+	/// <summary>
+	/// Builds a free function taking a borrow and a sequence, and declaring two locals.
+	/// </summary>
+	/// <returns>The declaration.</returns>
+	private static FunctionDeclaration Measure()
+	{
+		FunctionDeclaration measure = new("measure") { ReturnType = "int" };
+		measure.Parameters.Add(new Parameter("label") { Type = BorrowedString() });
+		measure.Parameters.Add(new Parameter("sizes")
+		{
+			Type = new TypeReference("list") { TypeArguments = { new TypeReference("int") } },
+		});
+
+		measure.Body.Add(new VariableDeclaration("total", "int", new LiteralExpression<int>(0)));
+		measure.Body.Add(new VariableDeclaration("guessed", null, new LiteralExpression<int>(1)) { IsTypeInferred = true });
+		measure.Body.Add(new ReturnStatement(new VariableReference("total")));
+
+		return measure;
+	}
+
+	/// <summary>
+	/// Gets a string the holder does not own, which is the one Rust asks for wherever it is only read.
+	/// </summary>
+	/// <returns>The type.</returns>
+	private static TypeReference BorrowedString() =>
+		new("str") { Indirection = TypeIndirection.Reference, IsReadOnly = true };
+}
diff --git a/Coder.Test/Languages/RustGeneratorTests.cs b/Coder.Test/Languages/RustGeneratorTests.cs
new file mode 100644
index 0000000..6500be3
--- /dev/null
+++ b/Coder.Test/Languages/RustGeneratorTests.cs
@@ -0,0 +1,701 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Coder.Test.Languages;
+
+using ktsu.Coder.Ast;
+using ktsu.Coder.Languages;
+using ktsu.CodeBlocker;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+/// <summary>
+/// Tests for <see cref="RustGenerator"/>.
+/// </summary>
+/// <remarks>
+/// Rust answers most of what the AST says with something the language already has — a trait, a
+/// derive, an attribute — rather than with a convention, so most of what is pinned here is which
+/// feature each part of a declaration became, and the few places where the answer is still a note.
+/// </remarks>
+[TestClass]
+public class RustGeneratorTests
+{
+	private RustGenerator Generator { get; } = new();
+
+	private static string NewLine => CodeBlocker.DefaultNewLineString;
+
+	/// <summary>
+	/// Tests that the generator reports the identity the registry and file writer rely on.
+	/// </summary>
+	[TestMethod]
+	public void Identity_IsRust()
+	{
+		Assert.AreEqual("rust", Generator.LanguageId);
+		Assert.AreEqual("Rust", Generator.DisplayName);
+		Assert.AreEqual("rs", Generator.FileExtension);
+	}
+
+	/// <summary>
+	/// Tests that a function with nothing to answer writes no return type, since Rust names the unit
+	/// only when it has to and nobody writes it.
+	/// </summary>
+	[TestMethod]
+	public void EmptyFunction_WritesNoReturnType()
+	{
+		FunctionDeclaration function = new("do_nothing");
+
+		Assert.AreEqual($"pub fn do_nothing() {{{NewLine}}}{NewLine}", Generator.Generate(function));
+	}
+
+	/// <summary>
+	/// Tests that the AST's language-neutral type names are mapped to Rust spellings.
+	/// </summary>
+	[TestMethod]
+	public void Types_AreMappedToRustSpellings()
+	{
+		FunctionDeclaration function = new("greet") { ReturnType = "str" };
+		function.Parameters.Add(new Parameter("times", "long"));
+		function.Parameters.Add(new Parameter("ratio", "double"));
+
+		StringAssert.Contains(
+			Generator.Generate(function),
+			"pub fn greet(times: i64, ratio: f64) -> String",
+			StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that an unrecognized type name is passed through, so a caller can name a real Rust type.
+	/// </summary>
+	[TestMethod]
+	public void UnknownType_IsPassedThrough()
+	{
+		FunctionDeclaration function = new("make") { ReturnType = "Widget" };
+
+		StringAssert.Contains(Generator.Generate(function), "-> Widget", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that the containers the AST names are spelled from the standard library, and that one
+	/// named without arguments is a container of the most general thing there is.
+	/// </summary>
+	[TestMethod]
+	public void Containers_AreSpelledFromTheStandardLibrary()
+	{
+		FunctionDeclaration function = new("lookup")
+		{
+			ReturnType = new TypeReference("dict")
+			{
+				TypeArguments = { new TypeReference("str"), new TypeReference("int") },
+			},
+		};
+		function.Parameters.Add(new Parameter("keys")
+		{
+			Type = new TypeReference("list") { TypeArguments = { new TypeReference("str") } },
+		});
+		function.Parameters.Add(new Parameter("rest", "list"));
+
+		string code = Generator.Generate(function);
+
+		StringAssert.Contains(code, "keys: Vec<String>", StringComparison.Ordinal);
+		StringAssert.Contains(code, "rest: Vec<Box<dyn std::any::Any>>", StringComparison.Ordinal);
+		StringAssert.Contains(code, "-> std::collections::HashMap<String, i32>", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that a reference is a borrow, and that whether it is a mutable one is what the AST's
+	/// read-only flag decides.
+	/// </summary>
+	[TestMethod]
+	public void Reference_IsABorrow()
+	{
+		FunctionDeclaration function = new("touch");
+		function.Parameters.Add(new Parameter("read")
+		{
+			Type = new TypeReference("Widget") { Indirection = TypeIndirection.Reference, IsReadOnly = true },
+		});
+		function.Parameters.Add(new Parameter("written")
+		{
+			Type = new TypeReference("Widget") { Indirection = TypeIndirection.Reference },
+		});
+
+		StringAssert.Contains(
+			Generator.Generate(function),
+			"(read: &Widget, written: &mut Widget)",
+			StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that borrowing an owned type gives the borrowed type rather than a reference to the
+	/// owned one, which is the pair of spellings Rust asks you never to write.
+	/// </summary>
+	[TestMethod]
+	public void BorrowedOwnedType_IsTheBorrowedType()
+	{
+		FunctionDeclaration function = new("read");
+		function.Parameters.Add(new Parameter("text")
+		{
+			Type = new TypeReference("str") { Indirection = TypeIndirection.Reference, IsReadOnly = true },
+		});
+		function.Parameters.Add(new Parameter("items")
+		{
+			Type = new TypeReference("int") { IsArray = true, Indirection = TypeIndirection.Reference, IsReadOnly = true },
+		});
+
+		string code = Generator.Generate(function);
+
+		StringAssert.Contains(code, "text: &str", StringComparison.Ordinal);
+		StringAssert.Contains(code, "items: &[i32]", StringComparison.Ordinal);
+		Assert.IsFalse(code.Contains("&String", StringComparison.Ordinal));
+		Assert.IsFalse(code.Contains("&Vec<", StringComparison.Ordinal));
+	}
+
+	/// <summary>
+	/// Tests that a pointer is a raw pointer, which is the only thing Rust has that a pointer is.
+	/// </summary>
+	[TestMethod]
+	public void Pointer_IsARawPointer()
+	{
+		FunctionDeclaration function = new("poke");
+		function.Parameters.Add(new Parameter("mutable")
+		{
+			Type = new TypeReference("u8") { Indirection = TypeIndirection.Pointer },
+		});
+		function.Parameters.Add(new Parameter("readable")
+		{
+			Type = new TypeReference("u8") { Indirection = TypeIndirection.Pointer, IsReadOnly = true },
+		});
+
+		StringAssert.Contains(
+			Generator.Generate(function),
+			"(mutable: *mut u8, readable: *const u8)",
+			StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that a type declaration splits into the struct holding the data and the block holding
+	/// the behaviour, which is the split Rust insists on.
+	/// </summary>
+	[TestMethod]
+	public void Type_SplitsIntoAStructAndAnImplBlock()
+	{
+		ClassDeclaration point = new("Point") { Kind = TypeDeclarationKind.Struct };
+		point.Members.Add(new VariableDeclaration("x", "int"));
+		point.Members.Add(new FunctionDeclaration("sum") { ReturnType = "int", IsReadOnly = true });
+
+		string code = Generator.Generate(point);
+
+		StringAssert.Contains(code, $"pub struct Point {{{NewLine}    pub x: i32,{NewLine}}}", StringComparison.Ordinal);
+		StringAssert.Contains(code, "impl Point {", StringComparison.Ordinal);
+		StringAssert.Contains(code, "pub fn sum(&self) -> i32 {", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that a member that promises not to modify what it is called on borrows the instance,
+	/// and that one that does not borrows it mutably.
+	/// </summary>
+	[TestMethod]
+	public void Receiver_IsBorrowedMutablyUnlessTheMemberIsReadOnly()
+	{
+		ClassDeclaration point = new("Point") { Kind = TypeDeclarationKind.Struct };
+		point.Members.Add(new FunctionDeclaration("read") { IsReadOnly = true });
+		point.Members.Add(new FunctionDeclaration("write"));
+		point.Members.Add(new FunctionDeclaration("build") { ReturnType = "Point", IsStatic = true });
+
+		string code = Generator.Generate(point);
+
+		StringAssert.Contains(code, "pub fn read(&self) {", StringComparison.Ordinal);
+		StringAssert.Contains(code, "pub fn write(&mut self) {", StringComparison.Ordinal);
+		StringAssert.Contains(code, "pub fn build() -> Point {", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that a constructor is an associated function answering <c>Self</c>, built from the
+	/// initialiser list — and that a field initialised from a variable of its own name is written as
+	/// that name alone.
+	/// </summary>
+	[TestMethod]
+	public void Constructor_BuildsSelfWithTheFieldInitShorthand()
+	{
+		ClassDeclaration point = new("Point") { Kind = TypeDeclarationKind.Struct };
+		FunctionDeclaration create = new("Point") { Kind = FunctionKind.Constructor };
+		create.Parameters.Add(new Parameter("x", "int"));
+		create.Initialisers.Add(new MemberInitialiser("x") { Value = new VariableReference("x") });
+		create.Initialisers.Add(new MemberInitialiser("y") { Value = new LiteralExpression<int>(0) });
+		point.Members.Add(create);
+
+		string code = Generator.Generate(point);
+
+		StringAssert.Contains(code, "pub fn new(x: i32) -> Self {", StringComparison.Ordinal);
+		StringAssert.Contains(code, "Self { x, y: 0 }", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that a constructor with nothing to build from asks the type for its default, since Rust
+	/// has no zero value to fall back on.
+	/// </summary>
+	[TestMethod]
+	public void Constructor_WithNoInitialisers_AsksForTheDefault()
+	{
+		ClassDeclaration point = new("Point") { Kind = TypeDeclarationKind.Struct };
+		point.Members.Add(new FunctionDeclaration("Point") { Kind = FunctionKind.Constructor });
+
+		StringAssert.Contains(Generator.Generate(point), "Self::default()", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that a destructor is the <c>Drop</c> implementation Rust calls for you, and that it does
+	/// not land in the inherent block where it would be a second <c>drop</c>.
+	/// </summary>
+	[TestMethod]
+	public void Destructor_IsADropImplementation()
+	{
+		ClassDeclaration buffer = new("Buffer");
+		FunctionDeclaration destructor = new("Buffer") { Kind = FunctionKind.Destructor };
+		destructor.Body.Add(new ReturnStatement());
+		buffer.Members.Add(destructor);
+
+		string code = Generator.Generate(buffer);
+
+		StringAssert.Contains(code, $"impl Drop for Buffer {{{NewLine}    fn drop(&mut self) {{", StringComparison.Ordinal);
+		Assert.IsFalse(code.Contains("impl Buffer {", StringComparison.Ordinal));
+	}
+
+	/// <summary>
+	/// Tests that an operator is the <c>std::ops</c> trait for it, naming the output the trait
+	/// requires.
+	/// </summary>
+	[TestMethod]
+	public void BinaryOperator_IsItsStdOpsTrait()
+	{
+		ClassDeclaration point = new("Point") { Kind = TypeDeclarationKind.Struct };
+		FunctionDeclaration plus = new("+") { Kind = FunctionKind.Operator, ReturnType = "Point" };
+		plus.Parameters.Add(new Parameter("rhs", "Point"));
+		point.Members.Add(plus);
+
+		string code = Generator.Generate(point);
+
+		StringAssert.Contains(code, "impl std::ops::Add for Point {", StringComparison.Ordinal);
+		StringAssert.Contains(code, "    type Output = Point;", StringComparison.Ordinal);
+		StringAssert.Contains(code, "    fn add(self, rhs: Point) -> Point {", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that an operator taking no operand beside the instance is the unary trait rather than
+	/// the binary one that shares its symbol.
+	/// </summary>
+	[TestMethod]
+	public void UnaryOperator_IsTheUnaryTrait()
+	{
+		ClassDeclaration point = new("Point") { Kind = TypeDeclarationKind.Struct };
+		point.Members.Add(new FunctionDeclaration("-") { Kind = FunctionKind.Operator, ReturnType = "Point" });
+
+		string code = Generator.Generate(point);
+
+		StringAssert.Contains(code, "impl std::ops::Neg for Point {", StringComparison.Ordinal);
+		StringAssert.Contains(code, "    fn neg(self) -> Point {", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that equality borrows what it compares and answers a bool, rather than consuming its
+	/// operands and naming an output the way the arithmetic traits do.
+	/// </summary>
+	[TestMethod]
+	public void Equality_IsPartialEq()
+	{
+		ClassDeclaration point = new("Point") { Kind = TypeDeclarationKind.Struct };
+		FunctionDeclaration equals = new("==") { Kind = FunctionKind.Operator, ReturnType = "bool" };
+		equals.Parameters.Add(new Parameter("rhs", "Point"));
+		point.Members.Add(equals);
+
+		string code = Generator.Generate(point);
+
+		StringAssert.Contains(code, "impl PartialEq for Point {", StringComparison.Ordinal);
+		StringAssert.Contains(code, "fn eq(&self, rhs: &Point) -> bool {", StringComparison.Ordinal);
+		Assert.IsFalse(code.Contains("type Output", StringComparison.Ordinal));
+	}
+
+	/// <summary>
+	/// Tests that an operator Rust supplies from another one is a note naming the trait to implement
+	/// instead, rather than an implementation the language would reject.
+	/// </summary>
+	[TestMethod]
+	public void OperatorRustSupplies_IsANote()
+	{
+		ClassDeclaration point = new("Point") { Kind = TypeDeclarationKind.Struct };
+		FunctionDeclaration less = new("<") { Kind = FunctionKind.Operator, ReturnType = "bool" };
+		less.Parameters.Add(new Parameter("rhs", "Point"));
+		point.Members.Add(less);
+
+		string code = Generator.Generate(point);
+
+		StringAssert.Contains(code, "// operator< on Point: implement PartialOrd", StringComparison.Ordinal);
+		Assert.IsFalse(code.Contains("impl std::ops", StringComparison.Ordinal));
+	}
+
+	/// <summary>
+	/// Tests that a conversion is the <c>From</c> implementation the standard library asks for.
+	/// </summary>
+	[TestMethod]
+	public void Conversion_IsAFromImplementation()
+	{
+		ClassDeclaration weight = new("Weight") { Kind = TypeDeclarationKind.Struct };
+		weight.Members.Add(new FunctionDeclaration("ignored")
+		{
+			Kind = FunctionKind.ConversionOperator,
+			ReturnType = "double",
+			IsReadOnly = true,
+		});
+
+		string code = Generator.Generate(weight);
+
+		StringAssert.Contains(code, "impl From<Weight> for f64 {", StringComparison.Ordinal);
+		StringAssert.Contains(code, "fn from(value: Weight) -> f64 {", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that an interface is a trait, that a base type is a supertrait, and that a member with
+	/// no body is the requirement it is meant to be.
+	/// </summary>
+	[TestMethod]
+	public void Interface_IsATrait()
+	{
+		ClassDeclaration shape = new("Shape")
+		{
+			Kind = TypeDeclarationKind.Interface,
+			BaseType = "Drawable",
+		};
+		shape.Members.Add(new FunctionDeclaration("area") { ReturnType = "double", IsReadOnly = true, IsAbstract = true });
+
+		string code = Generator.Generate(shape);
+
+		StringAssert.Contains(code, "pub trait Shape: Drawable {", StringComparison.Ordinal);
+		StringAssert.Contains(code, "    fn area(&self) -> f64;", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that a trait's members say nothing about who may see them. Rust rejects a visibility on
+	/// an associated item rather than ignoring it, so this is the difference between a file that
+	/// compiles and one that does not.
+	/// </summary>
+	[TestMethod]
+	public void TraitMembers_CarryNoVisibility()
+	{
+		ClassDeclaration shape = new("Shape") { Kind = TypeDeclarationKind.Interface };
+		shape.Members.Add(new FunctionDeclaration("area")
+		{
+			ReturnType = "double",
+			Visibility = Visibility.Public,
+			IsAbstract = true,
+		});
+		shape.Members.Add(new FieldDeclaration { Name = "SIDES", Type = "int", Visibility = Visibility.Public });
+
+		string code = Generator.Generate(shape);
+
+		StringAssert.Contains(code, "    fn area(&mut self) -> f64;", StringComparison.Ordinal);
+		StringAssert.Contains(code, "    const SIDES: i32;", StringComparison.Ordinal);
+		Assert.IsFalse(code.Contains("    pub ", StringComparison.Ordinal));
+	}
+
+	/// <summary>
+	/// Tests that a declaration for a type rather than of one is the trait implementation Rust
+	/// attaches facts with — which is what C++ writes an explicit specialisation for.
+	/// </summary>
+	[TestMethod]
+	public void Specialisation_IsATraitImplementation()
+	{
+		ClassDeclaration describe = new("Describe")
+		{
+			SpecialisationArguments = { new TypeReference("RigidBody") },
+		};
+		describe.Members.Add(new FieldDeclaration
+		{
+			Name = "NAME",
+			Type = new TypeReference("str") { Indirection = TypeIndirection.Reference, IsReadOnly = true },
+			InitialValue = new LiteralExpression<string>("RigidBody"),
+			Visibility = Visibility.Public,
+		});
+
+		string code = Generator.Generate(describe);
+
+		StringAssert.Contains(code, "impl Describe for RigidBody {", StringComparison.Ordinal);
+		StringAssert.Contains(code, "    const NAME: &str = \"RigidBody\";", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that a base type on a struct is a field holding it, which is the one place Rust has
+	/// nothing better than C did.
+	/// </summary>
+	[TestMethod]
+	public void BaseType_OnAStruct_IsAFieldHoldingIt()
+	{
+		ClassDeclaration circle = new("Circle") { BaseType = "Shape" };
+		circle.Members.Add(new VariableDeclaration("radius", "double"));
+
+		string code = Generator.Generate(circle);
+
+		int baseAt = code.IndexOf("pub base: Shape,", StringComparison.Ordinal);
+		int radiusAt = code.IndexOf("pub radius: f64,", StringComparison.Ordinal);
+
+		Assert.IsTrue(baseAt >= 0, "the base should be a field");
+		Assert.IsTrue(baseAt < radiusAt, "the base should come first");
+	}
+
+	/// <summary>
+	/// Tests that an enumeration needs no prefixing, since its variants are named through it, and
+	/// that a fixed underlying type is the guarantee rather than a comment about one.
+	/// </summary>
+	[TestMethod]
+	public void Enum_IsScopedAndCanFixItsRepresentation()
+	{
+		EnumDeclaration colour = new("Colour") { UnderlyingType = "int" };
+		colour.Members.Add(new EnumMember("Red") { Value = "1" });
+		colour.Members.Add(new EnumMember("Green"));
+
+		string code = Generator.Generate(colour);
+
+		Assert.AreEqual(
+			$"#[repr(i32)]{NewLine}pub enum Colour {{{NewLine}    Red = 1,{NewLine}    Green,{NewLine}}}{NewLine}",
+			code);
+	}
+
+	/// <summary>
+	/// Tests that a constant is a <c>const</c> and an ordinary field a <c>static</c>, and that an
+	/// array one is a borrowed slice — the bound-free spelling Rust does have, which is what a table
+	/// with no length has to be.
+	/// </summary>
+	[TestMethod]
+	public void ModuleScopeField_IsAConstOrAStatic()
+	{
+		FieldDeclaration limit = new()
+		{
+			Name = "MAX_ITEMS",
+			Type = "int",
+			IsConstant = true,
+			InitialValue = new LiteralExpression<int>(16),
+		};
+
+		FieldDeclaration counter = new()
+		{
+			Name = "SEEN",
+			Type = "int",
+			InitialValue = new LiteralExpression<int>(0),
+		};
+
+		ConstructionExpression rows = new(type: null);
+		ConstructionExpression row = new(new TypeReference("Point"));
+		row.Arguments.Add(new MemberInitialiser("x") { Value = new LiteralExpression<int>(1) });
+		rows.Arguments.Add(row);
+
+		FieldDeclaration table = new()
+		{
+			Name = "ORIGINS",
+			Type = new TypeReference("Point") { IsArray = true },
+			IsConstant = true,
+			InitialValue = rows,
+		};
+
+		Assert.AreEqual($"pub const MAX_ITEMS: i32 = 16;{NewLine}", Generator.Generate(limit));
+		Assert.AreEqual($"pub static SEEN: i32 = 0;{NewLine}", Generator.Generate(counter));
+		StringAssert.Contains(Generator.Generate(table), "pub const ORIGINS: &[Point] = &[", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that a local binds mutably unless the declaration said its value never changes, which is
+	/// the opposite of every other target here and the reason it has to be said.
+	/// </summary>
+	[TestMethod]
+	public void Local_BindsMutablyUnlessConstant()
+	{
+		FunctionDeclaration function = new("run");
+		function.Body.Add(new VariableDeclaration("limit", "int", new LiteralExpression<int>(4)) { IsConstant = true });
+		function.Body.Add(new VariableDeclaration("seen", "int", new LiteralExpression<int>(0)));
+		function.Body.Add(new VariableDeclaration("guessed", "int", new LiteralExpression<int>(1)) { IsTypeInferred = true });
+
+		string code = Generator.Generate(function);
+
+		StringAssert.Contains(code, "    let limit: i32 = 4;", StringComparison.Ordinal);
+		StringAssert.Contains(code, "    let mut seen: i32 = 0;", StringComparison.Ordinal);
+		StringAssert.Contains(code, "    let mut guessed = 1;", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that a pure function earns <c>#[must_use]</c>, and that one answering nothing does not —
+	/// where there is no result, there is nothing to ignore.
+	/// </summary>
+	[TestMethod]
+	public void PureFunction_MustUseItsResult()
+	{
+		FunctionDeclaration answers = new("area") { ReturnType = "double", IsPure = true };
+		FunctionDeclaration acts = new("reset") { IsPure = true };
+
+		StringAssert.StartsWith(Generator.Generate(answers), "#[must_use]", StringComparison.Ordinal);
+		Assert.IsFalse(Generator.Generate(acts).Contains("must_use", StringComparison.Ordinal));
+	}
+
+	/// <summary>
+	/// Tests that a function whose value is fixed when the program is built is a <c>const fn</c>.
+	/// </summary>
+	[TestMethod]
+	public void CompileTimeEvaluableFunction_IsAConstFn()
+	{
+		FunctionDeclaration function = new("zero") { ReturnType = "int", IsCompileTimeEvaluable = true };
+
+		StringAssert.Contains(Generator.Generate(function), "pub const fn zero() -> i32", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that a deleted declaration is a note rather than a signature, since writing the
+	/// signature would make legal exactly what the declaration exists to forbid.
+	/// </summary>
+	[TestMethod]
+	public void DeletedFunction_IsANote()
+	{
+		FunctionDeclaration function = new("clone") { Definition = FunctionDefinition.Deleted };
+
+		string code = Generator.Generate(function);
+
+		StringAssert.Contains(code, "// clone is deleted", StringComparison.Ordinal);
+		Assert.IsFalse(code.Contains("fn clone", StringComparison.Ordinal));
+	}
+
+	/// <summary>
+	/// Tests that a defaulted declaration is a note naming the derive that supplies it.
+	/// </summary>
+	[TestMethod]
+	public void DefaultedFunction_IsANote()
+	{
+		FunctionDeclaration function = new("Point") { Kind = FunctionKind.Constructor, Definition = FunctionDefinition.Defaulted };
+
+		StringAssert.Contains(Generator.Generate(function), "// new is defaulted", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that an assertion is Rust's own, which needs no macro crate: a constant nobody names
+	/// still has to be evaluated for the program to build.
+	/// </summary>
+	[TestMethod]
+	public void CompileTimeAssertion_IsAnEvaluatedConstant()
+	{
+		CompileTimeAssertion assertion = new()
+		{
+			Condition = "std::mem::size_of::<Point>() == 8",
+			Message = "a Point is two i32s",
+		};
+
+		string code = Generator.Generate(assertion);
+
+		StringAssert.StartsWith(code, "const _: () = assert!(std::mem::size_of::<Point>() == 8,", StringComparison.Ordinal);
+		StringAssert.Contains(code, "\"a Point is two i32s\");", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that an alias is a type alias.
+	/// </summary>
+	[TestMethod]
+	public void UsingAlias_IsATypeAlias()
+	{
+		UsingAlias alias = new()
+		{
+			Name = "Radii",
+			AliasedType = new TypeReference("double") { IsArray = true },
+		};
+
+		Assert.AreEqual($"pub type Radii = Vec<f64>;{NewLine}", Generator.Generate(alias));
+	}
+
+	/// <summary>
+	/// Tests that a namespace is nested modules rather than one module with a long name, since that
+	/// is what the name says and what a caller reaching into it would write either way.
+	/// </summary>
+	[TestMethod]
+	public void Namespace_IsNestedModules()
+	{
+		NamespaceDeclaration ns = new("geo.shapes");
+		ns.Members.Add(new FunctionDeclaration("area") { ReturnType = "double" });
+
+		string code = Generator.Generate(ns);
+
+		StringAssert.StartsWith(code, $"pub mod geo {{{NewLine}    pub mod shapes {{", StringComparison.Ordinal);
+		StringAssert.Contains(code, "        pub fn area() -> f64 {", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that an import is a <c>use</c>, and that one a caller wrote in full is left alone.
+	/// </summary>
+	[TestMethod]
+	public void Imports_AreUseItems()
+	{
+		SourceFile file = new("shape");
+		file.Imports.Add("std::fmt");
+		file.Imports.Add("use std::collections::{HashMap, HashSet};");
+		file.Members.Add(new FunctionDeclaration("area") { ReturnType = "double" });
+
+		string code = Generator.Generate(file);
+
+		StringAssert.Contains(code, "use std::fmt;", StringComparison.Ordinal);
+		StringAssert.Contains(code, "use std::collections::{HashMap, HashSet};", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that the entry point is Rust's <c>main</c>, and that a program wanting its arguments
+	/// gets them from the standard library rather than from a parameter Rust does not offer.
+	/// </summary>
+	[TestMethod]
+	public void EntryPoint_IsMain()
+	{
+		EntryPoint bare = new();
+		EntryPoint withArguments = new() { AcceptsArguments = true };
+
+		StringAssert.StartsWith(Generator.Generate(bare), "fn main() {", StringComparison.Ordinal);
+		StringAssert.Contains(
+			Generator.Generate(withArguments),
+			"    let args: Vec<String> = std::env::args().collect();",
+			StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests that a program answering an exit code is written as a function that answers one and a
+	/// <c>main</c> that exits with it — which is what keeps the body's own return meaning what it
+	/// says, and the shape Python's guard takes here for the same reason.
+	/// </summary>
+	[TestMethod]
+	public void EntryPoint_ReturningAnExitCode_ExitsWithWhatItAnswered()
+	{
+		EntryPoint entryPoint = new() { ReturnsExitCode = true };
+		entryPoint.Body.Add(new ReturnStatement(new LiteralExpression<int>(0)));
+
+		string code = Generator.Generate(entryPoint);
+
+		StringAssert.Contains(code, "fn run() -> i32 {", StringComparison.Ordinal);
+		StringAssert.Contains(code, "    return 0;", StringComparison.Ordinal);
+		StringAssert.Contains(code, "    std::process::exit(run());", StringComparison.Ordinal);
+	}
+
+	/// <summary>
+	/// Tests the three shapes a construction takes, which depend on what the expression is rather
+	/// than on where it stands.
+	/// </summary>
+	[TestMethod]
+	public void Construction_IsAStructLiteralACallOrAnArray()
+	{
+		ConstructionExpression literal = new(new TypeReference("Point"));
+		literal.Arguments.Add(new MemberInitialiser("x") { Value = new LiteralExpression<int>(1) });
+
+		ConstructionExpression call = new(new TypeReference("Wrapper"));
+		call.Arguments.Add(new LiteralExpression<int>(1));
+		call.Arguments.Add(new LiteralExpression<int>(2));
+
+		ConstructionExpression array = new(type: null);
+		array.Arguments.Add(new LiteralExpression<int>(1));
+
+		Assert.AreEqual("Point { x: 1 }", Generate(literal));
+		Assert.AreEqual("Wrapper(1, 2)", Generate(call));
+		Assert.AreEqual("[ 1 ]", Generate(array));
+	}
+
+	/// <summary>
+	/// Writes one expression on its own, for the assertions that are about the expression rather than
+	/// about the declaration holding it.
+	/// </summary>
+	/// <param name="expression">The expression to write.</param>
+	/// <returns>Its Rust source.</returns>
+	private string Generate(Expression expression) => Generator.Generate(expression);
+}
diff --git a/Coder.Test/Languages/ToolchainHarness.cs b/Coder.Test/Languages/ToolchainHarness.cs
new file mode 100644
index 0000000..1d38153
--- /dev/null
+++ b/Coder.Test/Languages/ToolchainHarness.cs
@@ -0,0 +1,87 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Coder.Test.Languages;
+
+using System.Diagnostics;
+
+/// <summary>
+/// Runs a real compiler over generated source.
+/// </summary>
+/// <remarks>
+/// Two of the generators here are checked by compiling what they write, because the rules they have
+/// to obey are not visible in the text: C's about linkage and constant expressions, Rust's about
+/// receivers, associated items and what a trait implementation owes its trait. Everything those two
+/// tests share about *running* a compiler is here, so that what is left in each of them is the
+/// language.
+/// </remarks>
+internal static class ToolchainHarness
+{
+	/// <summary>
+	/// Finds the first of several commands that is on the path.
+	/// </summary>
+	/// <param name="commands">The commands to try, in the order a project would.</param>
+	/// <returns>The first one that runs, or null when none does.</returns>
+	/// <remarks>
+	/// Asked by running it rather than by looking for a file, because what matters is whether it
+	/// starts — a name on the path that cannot be executed is not a compiler.
+	/// </remarks>
+	public static string? FindOnPath(params string[] commands) =>
+		commands.FirstOrDefault(command => Run(command, "--version", Path.GetTempPath()).ExitCode == 0);
+
+	/// <summary>
+	/// Runs a command in a directory of its own, and deletes the directory afterwards.
+	/// </summary>
+	/// <param name="work">What to do in the directory, given its path.</param>
+	public static void InTemporaryDirectory(Action<string> work)
+	{
+		ArgumentNullException.ThrowIfNull(work);
+
+		string directory = Path.Combine(Path.GetTempPath(), $"coder-{Guid.NewGuid():N}");
+		Directory.CreateDirectory(directory);
+
+		try
+		{
+			work(directory);
+		}
+		finally
+		{
+			Directory.Delete(directory, recursive: true);
+		}
+	}
+
+	/// <summary>
+	/// Runs a command, waiting for it to finish.
+	/// </summary>
+	/// <param name="command">The executable to run.</param>
+	/// <param name="arguments">Its arguments.</param>
+	/// <param name="workingDirectory">Where to run it.</param>
+	/// <returns>What it exited with, and everything it wrote.</returns>
+	public static (int ExitCode, string Output) Run(string command, string arguments, string workingDirectory)
+	{
+		ProcessStartInfo start = new(command, arguments)
+		{
+			WorkingDirectory = workingDirectory,
+			RedirectStandardOutput = true,
+			RedirectStandardError = true,
+			UseShellExecute = false,
+		};
+
+		try
+		{
+			using Process? process = Process.Start(start);
+			if (process is null)
+			{
+				return (-1, string.Empty);
+			}
+
+			string output = process.StandardOutput.ReadToEnd() + process.StandardError.ReadToEnd();
+			process.WaitForExit();
+			return (process.ExitCode, output);
+		}
+		catch (System.ComponentModel.Win32Exception)
+		{
+			// The command is not on the path, which is the answer rather than a failure.
+			return (-1, string.Empty);
+		}
+	}
+}
diff --git a/Coder.Test/ServiceCollectionExtensionsTests.cs b/Coder.Test/ServiceCollectionExtensionsTests.cs
index 3b7e610..635ced3 100644
--- a/Coder.Test/ServiceCollectionExtensionsTests.cs
+++ b/Coder.Test/ServiceCollectionExtensionsTests.cs
@@ -59,8 +59,9 @@ public void AddLanguageGenerators_ShouldRegisterEveryImplementedLanguage()
 		Assert.IsInstanceOfType<JavaScriptGenerator>(generators.FirstOrDefault(g => g.LanguageId == "javascript"));
 		Assert.IsInstanceOfType<CppGenerator>(generators.FirstOrDefault(g => g.LanguageId == "cpp"));
 		Assert.IsInstanceOfType<CGenerator>(generators.FirstOrDefault(g => g.LanguageId == "c"));
+		Assert.IsInstanceOfType<RustGenerator>(generators.FirstOrDefault(g => g.LanguageId == "rust"));
 
-		Assert.AreEqual(5, generators.Count, "A new generator needs a registration and an entry here");
+		Assert.AreEqual(6, generators.Count, "A new generator needs a registration and an entry here");
 	}
 
 	/// <summary>
diff --git a/Coder/Ast/UnaryExpression.cs b/Coder/Ast/UnaryExpression.cs
index 426281b..35ad412 100644
--- a/Coder/Ast/UnaryExpression.cs
+++ b/Coder/Ast/UnaryExpression.cs
@@ -73,7 +73,7 @@ public override AstNode Clone()
 /// Defines the types of unary operators supported.
 /// </summary>
 /// <remarks>
-/// Every operator here exists in all five target languages, so no AST using them is untranslatable.
+/// Every operator here exists in all six target languages, so no AST using them is untranslatable.
 /// Only the spelling of <see cref="LogicalNot"/> differs, in Python.
 /// </remarks>
 public enum UnaryOperator
diff --git a/Coder/Languages/CFamilyGenerator.cs b/Coder/Languages/CFamilyGenerator.cs
index 965c4f0..9c6d37d 100644
--- a/Coder/Languages/CFamilyGenerator.cs
+++ b/Coder/Languages/CFamilyGenerator.cs
@@ -2,7 +2,6 @@
 
 namespace ktsu.Coder.Languages;
 
-using System.Linq;
 using ktsu.Coder.Ast;
 using ktsu.CodeBlocker;
 
@@ -152,117 +151,28 @@ protected string SpellDeclarator(TypeReference type, string name)
 		return $"{SpellType(element)} {name}{(type.IsArray ? "[]" : string.Empty)}";
 	}
 
-	/// <summary>
-	/// Writes a braced list, without whatever the language writes in front of it.
-	/// </summary>
-	/// <param name="construction">The expression whose arguments to write.</param>
-	/// <param name="code">The writer to emit into.</param>
-	/// <param name="emptyList">What to write when there are no arguments at all.</param>
+	/// <inheritdoc/>
 	/// <remarks>
-	/// The empty list is the caller's because it is the one part the two languages spell
-	/// differently: <c>{}</c> is C++'s, and C only allows it from C23.
-	/// <para>
-	/// A list of values is a value and belongs on one line; a list whose elements are themselves
-	/// lists is a table, and a table written on one line is a row of a diff nobody can read. The test
-	/// is the shape of the data rather than a column count, because a generated file has no idea how
-	/// wide anyone's editor is and a rule about that would have to be guessed.
-	/// </para>
+	/// A designated initialiser, which C invented and C++20 adopted — with the one difference that
+	/// C++ requires the designators to appear in declaration order. That is the caller's business:
+	/// the generator writes the order it is given.
 	/// </remarks>
-	protected void WriteBracedList(ConstructionExpression construction, CodeBlocker code, string emptyList)
+	protected override void WriteDesignator(string name, CodeBlocker code)
 	{
-		Ensure.NotNull(construction);
 		Ensure.NotNull(code);
-
-		if (construction.Arguments.Count == 0)
-		{
-			code.Write(emptyList);
-			return;
-		}
-
-		if (SpansLines(construction))
-		{
-			WriteStackedList(construction, code);
-			return;
-		}
-
-		code.Write("{ ");
-		for (int index = 0; index < construction.Arguments.Count; index++)
-		{
-			if (index > 0)
-			{
-				code.Write(", ");
-			}
-
-			WriteListElement(construction.Arguments[index], code);
-		}
-
-		code.Write(" }");
+		code.Write($".{name} = ");
 	}
 
 	/// <summary>
-	/// Writes a braced list one element per line.
+	/// Writes a braced list, without whatever the language writes in front of it.
 	/// </summary>
 	/// <param name="construction">The expression whose arguments to write.</param>
 	/// <param name="code">The writer to emit into.</param>
+	/// <param name="emptyList">What to write when there are no arguments at all.</param>
 	/// <remarks>
-	/// A trailing comma after the last element, which both languages allow in a braced list and which
-	/// keeps adding a row to a generated table from touching the row above it in the diff.
-	/// </remarks>
-	private void WriteStackedList(ConstructionExpression construction, CodeBlocker code)
-	{
-		code.WriteLine("{");
-		code.Indent();
-
-		foreach (AstNode argument in construction.Arguments)
-		{
-			WriteListElement(argument, code);
-			code.WriteLine(",");
-		}
-
-		code.Outdent();
-		code.Write("}");
-	}
-
-	/// <summary>
-	/// Writes one element of a braced list, which may name the member it is for.
-	/// </summary>
-	/// <param name="argument">The element to write.</param>
-	/// <param name="code">The writer to emit into.</param>
-	/// <remarks>
-	/// A <see cref="MemberInitialiser"/> is a designated initialiser, spelled the same in both
-	/// languages — C invented it and C++20 adopted it, with the one difference that C++ requires the
-	/// designators to appear in declaration order. That is the caller's business: the generator
-	/// writes the order it is given.
-	/// </remarks>
-	private void WriteListElement(AstNode argument, CodeBlocker code)
-	{
-		if (argument is MemberInitialiser designated)
-		{
-			code.Write($".{designated.Name} = ");
-			WriteListValue(designated.Value ?? new VariableReference(string.Empty), code);
-			return;
-		}
-
-		WriteListValue(argument, code);
-	}
-
-	/// <summary>
-	/// Writes what one element of a braced list is.
-	/// </summary>
-	/// <param name="value">The value to write.</param>
-	/// <param name="code">The writer to emit into.</param>
-	/// <remarks>
-	/// Ordinary generation, unless a language has something to say about a value that stands inside
-	/// a list rather than on its own — which C does, since only there may it leave the type out.
+	/// The empty list is the caller's because it is the one part the two languages spell
+	/// differently: <c>{}</c> is C++'s, and C only allows it from C23.
 	/// </remarks>
-	protected virtual void WriteListValue(AstNode value, CodeBlocker code) => GenerateInternal(value, code);
-
-	/// <summary>
-	/// Reports whether a braced list is worth breaking across lines.
-	/// </summary>
-	/// <param name="construction">The expression to judge.</param>
-	/// <returns><see langword="true"/> when it should be written one element per line.</returns>
-	private static bool SpansLines(ConstructionExpression construction) =>
-		construction.Arguments.Any(argument =>
-			argument is ConstructionExpression or MemberInitialiser { Value: ConstructionExpression });
+	protected void WriteBracedList(ConstructionExpression construction, CodeBlocker code, string emptyList) =>
+		WriteElementList(construction, code, "{", "}", emptyList);
 }
diff --git a/Coder/Languages/CGenerator.cs b/Coder/Languages/CGenerator.cs
index 6955136..814ceb7 100644
--- a/Coder/Languages/CGenerator.cs
+++ b/Coder/Languages/CGenerator.cs
@@ -501,6 +501,13 @@ protected override void GenerateClassDeclaration(ClassDeclaration classDecl, Cod
 		string name = classDecl.Name ?? "UnnamedStruct";
 		bool isInterface = classDecl.Kind == TypeDeclarationKind.Interface;
 
+		// C has no templates, so it has nothing a declaration for one type rather than of one could
+		// be. Said rather than dropped, the same as every other target that cannot spell it.
+		if (classDecl.IsSpecialisation)
+		{
+			WriteInexpressible(code, $"specialised for {string.Join(", ", classDecl.SpecialisationArguments)}");
+		}
+
 		List<AstNode> nestedTypes = [.. classDecl.Members.Where(IsTypeDeclaration)];
 		List<FunctionDeclaration> functions = isInterface
 			? []
diff --git a/Coder/Languages/RustGenerator.cs b/Coder/Languages/RustGenerator.cs
new file mode 100644
index 0000000..68cd0ab
--- /dev/null
+++ b/Coder/Languages/RustGenerator.cs
@@ -0,0 +1,1325 @@
+// Copyright (c) 2023-2026 ktsu-dev contributors
+
+namespace ktsu.Coder.Languages;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ktsu.Coder.Ast;
+using ktsu.CodeBlocker;
+
+/// <summary>
+/// Generates Rust code from AST nodes.
+/// </summary>
+/// <remarks>
+/// Rust is the first target that separates what a type *is* from what it *does* and means it: data
+/// goes in a <c>struct</c>, behaviour in an <c>impl</c> block, and a set of members an implementation
+/// supplies is a <c>trait</c>. That is the same split C forced, and the opposite of the reason — C
+/// had no member functions, while Rust has them and keeps them somewhere else on purpose.
+/// <para>
+/// It is also the first target with a real answer to most of what the AST says and the others had to
+/// approximate. An enumeration's variants are scoped by their enumeration, so nothing needs
+/// prefixing; a fixed underlying type is <c>#[repr]</c>; a compile-time assertion is
+/// <c>const _: () = assert!(…)</c>; a pure function is <c>#[must_use]</c>; a destructor is
+/// <c>impl Drop</c>; an operator is the <c>std::ops</c> trait for it; a conversion is
+/// <c>impl From</c>. What is left over is inheritance, which Rust does not have.
+/// </para>
+/// <para>
+/// The AST's type names are the same language-neutral set the other generators consume (<c>str</c>,
+/// <c>int</c>, <c>bool</c>, …), so they are mapped to Rust spellings; anything unrecognised is
+/// emitted verbatim on the assumption the caller meant a Rust type. Names are written as they are
+/// given rather than recased, for the reason every generator here leaves names alone: renaming a
+/// declaration would not rename the references to it.
+/// </para>
+/// </remarks>
+public class RustGenerator : StandardLanguageGenerator
+{
+	/// <summary>
+	/// What a declaration that never said what type it is gets.
+	/// </summary>
+	/// <remarks>
+	/// A type is optional on every node that carries one, because a half-built AST is a thing the
+	/// editor has to be able to hold. Rust's most general type is a boxed <c>Any</c>, which keeps the
+	/// output compiling while making it obvious which declaration was never finished.
+	/// </remarks>
+	private const string UnknownTypeName = "object";
+
+	/// <summary>
+	/// The name a derived struct holds its base in.
+	/// </summary>
+	/// <remarks>
+	/// Rust has no inheritance, and the nearest thing a struct can do is hold one. The member is
+	/// named for what it is rather than for the type, so it is the same word whatever it derives
+	/// from and renaming the base does not rename the member.
+	/// </remarks>
+	private const string BaseMemberName = "base";
+
+	private static readonly Dictionary<string, string> TypeMappings = new(StringComparer.OrdinalIgnoreCase)
+	{
+		{ "str", "String" },
+		{ "string", "String" },
+		{ "int", "i32" },
+		{ "long", "i64" },
+		{ "float", "f32" },
+		{ "double", "f64" },
+		{ "bool", "bool" },
+		{ "void", "()" },
+		{ "object", "Box<dyn std::any::Any>" }
+	};
+
+	/// <summary>
+	/// The owned types whose borrowed form is a different type rather than a reference to them.
+	/// </summary>
+	/// <remarks>
+	/// <c>&amp;String</c> and <c>&amp;Vec&lt;T&gt;</c> are the two types Rust asks you not to write:
+	/// a borrow of a string is a <c>&amp;str</c> and a borrow of a sequence is a <c>&amp;[T]</c>,
+	/// which every caller of the owned form can also produce. Keyed by the owned spelling, since
+	/// that is what the mapping has already produced by the time a borrow is being written.
+	/// </remarks>
+	private static readonly Dictionary<string, string> BorrowedForms = new(StringComparer.Ordinal)
+	{
+		{ "String", "str" }
+	};
+
+	/// <summary>
+	/// How many type declarations enclose what is being written.
+	/// </summary>
+	/// <remarks>
+	/// A depth rather than a flag, so a type declared inside a type leaves the count right when it
+	/// closes. It decides what a field is: inside a struct it is a member, and at module scope it is
+	/// a <c>const</c> or a <c>static</c>, which Rust spells differently and requires a value for.
+	/// </remarks>
+	private int insideType;
+
+	/// <summary>
+	/// Whether what is being written is a member of a trait declaration.
+	/// </summary>
+	/// <remarks>
+	/// A member with no body is a requirement rather than a mistake, which is the whole point of
+	/// declaring it there.
+	/// </remarks>
+	private bool insideTrait;
+
+	/// <summary>
+	/// Whether what is being written is a member of a trait implementation.
+	/// </summary>
+	private bool insideTraitImplementation;
+
+	/// <summary>
+	/// Whether a member should say nothing about who may see it.
+	/// </summary>
+	/// <remarks>
+	/// An associated item is exactly as visible as the trait it belongs to, and Rust rejects a
+	/// visibility on one rather than ignoring it — which makes this the difference between a file
+	/// that compiles and one that does not, not a matter of style.
+	/// </remarks>
+	private bool IsAssociatedItem => insideTrait || insideTraitImplementation;
+
+	/// <summary>
+	/// The <c>std::ops</c> trait each binary operator is spelled through.
+	/// </summary>
+	/// <remarks>
+	/// Rust has operator overloading and spells it as a trait implementation, so an operator
+	/// declaration is not a function with an odd name — it is <c>impl Add for Point</c> with a method
+	/// called <c>add</c>. Each of these is one operator to one trait method, which is what makes them
+	/// mechanical; see <see cref="ComparisonOperators"/> for the ones that are not.
+	/// </remarks>
+	private static readonly Dictionary<string, OperatorTrait> BinaryOperatorTraits = new(StringComparer.Ordinal)
+	{
+		{ "+", new("std::ops::Add", "add") },
+		{ "-", new("std::ops::Sub", "sub") },
+		{ "*", new("std::ops::Mul", "mul") },
+		{ "/", new("std::ops::Div", "div") },
+		{ "%", new("std::ops::Rem", "rem") },
+		{ "&", new("std::ops::BitAnd", "bitand") },
+		{ "|", new("std::ops::BitOr", "bitor") },
+		{ "^", new("std::ops::BitXor", "bitxor") },
+		{ "<<", new("std::ops::Shl", "shl") },
+		{ ">>", new("std::ops::Shr", "shr") },
+		{ "==", new("PartialEq", "eq", ReturnsBool: true) },
+	};
+
+	/// <summary>
+	/// The <c>std::ops</c> trait each unary operator is spelled through.
+	/// </summary>
+	/// <remarks>
+	/// Kept apart from the binary ones because <c>-</c> is in both, and which one a declaration means
+	/// is decided by whether it takes an operand beside the instance.
+	/// </remarks>
+	private static readonly Dictionary<string, OperatorTrait> UnaryOperatorTraits = new(StringComparer.Ordinal)
+	{
+		{ "-", new("std::ops::Neg", "neg") },
+		{ "!", new("std::ops::Not", "not") },
+	};
+
+	/// <summary>
+	/// The operators Rust supplies from another one and will not let a type define by itself.
+	/// </summary>
+	/// <remarks>
+	/// <c>!=</c> comes from <c>PartialEq</c> and the four orderings from <c>PartialOrd</c>'s
+	/// <c>partial_cmp</c>; <c>&amp;&amp;</c> and <c>||</c> short-circuit and are not overloadable at
+	/// all. A declaration of one of these is not dropped — it is written as a note naming the trait
+	/// the type should implement instead, because the alternative is a generated file that silently
+	/// lost a comparison somebody asked for.
+	/// </remarks>
+	private static readonly Dictionary<string, string> ComparisonOperators = new(StringComparer.Ordinal)
+	{
+		{ "!=", "PartialEq, which supplies != from ==" },
+		{ "<", Ordering },
+		{ "<=", Ordering },
+		{ ">", Ordering },
+		{ ">=", Ordering },
+		{ "&&", ShortCircuit },
+		{ "||", ShortCircuit },
+	};
+
+	/// <summary>
+	/// What to implement instead of one of the orderings, which are four spellings of one decision.
+	/// </summary>
+	private const string Ordering = "PartialOrd, which supplies the orderings from partial_cmp";
+
+	/// <summary>
+	/// What to implement instead of a short-circuiting operator, which is nothing.
+	/// </summary>
+	private const string ShortCircuit = "nothing: a short-circuiting operator is not overloadable";
+
+	/// <summary>
+	/// A trait an operator is spelled through.
+	/// </summary>
+	/// <param name="Name">The trait's path.</param>
+	/// <param name="Method">The method the operator calls.</param>
+	/// <param name="ReturnsBool">
+	/// Whether the method answers <c>bool</c> and borrows its operands, as <c>PartialEq::eq</c> does,
+	/// rather than consuming them and naming an <c>Output</c>, as the arithmetic traits do.
+	/// </param>
+	private sealed record OperatorTrait(string Name, string Method, bool ReturnsBool = false);
+
+	/// <summary>
+	/// Gets the unique identifier for this language generator.
+	/// </summary>
+	public override string LanguageId => "rust";
+
+	/// <summary>
+	/// Gets the display name for this language generator.
+	/// </summary>
+	public override string DisplayName => "Rust";
+
+	/// <summary>
+	/// Gets the file extension (without the dot) used for this language.
+	/// </summary>
+	public override string FileExtension => "rs";
+
+	/// <inheritdoc/>
+	/// <remarks>
+	/// <c>use</c>, which is what Rust writes where the others write an include or an import. A path
+	/// that already ends in a semicolon is left alone, so a caller who wrote the whole item — a
+	/// grouped <c>use a::{b, c};</c>, or an attribute — gets what they wrote.
+	/// </remarks>
+	protected override string? SpellImport(string import)
+	{
+		Ensure.NotNull(import);
+		return import.EndsWith(';') ? import : $"use {import};";
+	}
+
+	/// <inheritdoc/>
+	/// <remarks>
+	/// Rust has modules, so a namespace is one — and a dotted name is nested modules rather than one
+	/// module with a long name, because that is what the name says and what a caller reaching into it
+	/// would have to write either way.
+	/// </remarks>
+	protected override void GenerateNamespaceDeclaration(NamespaceDeclaration namespaceDecl, CodeBlocker code)
+	{
+		Ensure.NotNull(namespaceDecl);
+		Ensure.NotNull(code);
+
+		GenerateDocumentation(namespaceDecl, code);
+		WriteModule([.. NamespaceDeclaration.Split(namespaceDecl.Name)], namespaceDecl.Members, code);
+	}
+
+	/// <summary>
+	/// Writes one module, and whatever modules are nested inside it.
+	/// </summary>
+	/// <param name="path">The names left to open, outermost first.</param>
+	/// <param name="members">What the innermost module holds.</param>
+	/// <param name="code">The writer to emit into.</param>
+	private void WriteModule(IReadOnlyList<string> path, IReadOnlyCollection<AstNode> members, CodeBlocker code)
+	{
+		if (path.Count == 0)
+		{
+			WriteMembers(members, code);
+			return;
+		}
+
+		// The line is left open, so the scope's brace lands on it: Rust braces hang.
+		code.Write($"pub mod {path[0]} ");
+
+		using Scope module = new(code);
+		WriteModule([.. path.Skip(1)], members, code);
+	}
+
+	/// <summary>
+	/// Writes a run of declarations, separated as this language separates them.
+	/// </summary>
+	/// <param name="members">The declarations to write.</param>
+	/// <param name="code">The writer to emit into.</param>
+	private void WriteMembers(IReadOnlyCollection<AstNode> members, CodeBlocker code)
+	{
+		AstNode? previous = null;
+		foreach (AstNode member in members)
+		{
+			if (previous is not null && NeedsSeparation(previous, member))
+			{
+				code.NewLine();
+			}
+
+			previous = member;
+			GenerateInternal(member, code);
+		}
+	}
+
+	/// <inheritdoc/>
+	/// <remarks>
+	/// Two of a kind that say nothing about themselves stay together, which keeps a run of type
+	/// aliases or of constants reading as one block rather than as a paragraph each.
+	/// </remarks>
+	protected override bool NeedsSeparation(AstNode previous, AstNode member)
+	{
+		Ensure.NotNull(previous);
+		Ensure.NotNull(member);
+
+		return previous.GetType() != member.GetType()
+			|| IsDocumented(previous)
+			|| IsDocumented(member);
+	}
+
+	/// <summary>
+	/// Reports whether a declaration carries documentation.
+	/// </summary>
+	/// <param name="member">The declaration to test.</param>
+	/// <returns>True when it does.</returns>
+	private static bool IsDocumented(AstNode member) =>
+		member is IHasDocumentation documented && documented.Documentation.Count > 0;
+
+	/// <inheritdoc/>
+	/// <remarks>
+	/// A type declaration becomes a <c>struct</c> holding the data and an <c>impl</c> block holding
+	/// the behaviour, which is the split Rust insists on. What does not go in the inherent block goes
+	/// in a trait implementation of its own: a destructor is <c>impl Drop</c>, an operator is the
+	/// <c>std::ops</c> trait for it, and a conversion is <c>impl From</c>.
+	/// <para>
+	/// An interface is a <c>trait</c> instead, which is the one mapping here that needs no
+	/// explaining: a set of members an implementation supplies is what a trait is, and a base type is
+	/// a supertrait.
+	/// </para>
+	/// <para>
+	/// <see cref="ClassDeclaration.BaseType"/> on a struct is a field holding the base, and that is
+	/// the one place Rust has nothing better. Inheritance is what Rust deliberately left out, so the
+	/// field is written with a note rather than pretending <c>Deref</c> makes it inheritance.
+	/// </para>
+	/// <para>
+	/// Nothing is derived. <c>#[derive(Clone, Debug)]</c> would be the obvious thing to write on a
+	/// generated data type and would stop it compiling the moment one field does not implement them,
+	/// which is a decision about the type rather than about the declaration.
+	/// </para>
+	/// </remarks>
+	protected override void GenerateClassDeclaration(ClassDeclaration classDecl, CodeBlocker code)
+	{
+		Ensure.NotNull(classDecl);
+		Ensure.NotNull(code);
+
+		string name = classDecl.Name ?? "UnnamedStruct";
+
+		foreach (AstNode nested in classDecl.Members.Where(IsTypeDeclaration))
+		{
+			GenerateInternal(nested, code);
+			code.NewLine();
+		}
+
+		if (classDecl.IsSpecialisation)
+		{
+			GenerateSpecialisation(classDecl, name, code);
+			return;
+		}
+
+		if (classDecl.Kind == TypeDeclarationKind.Interface)
+		{
+			GenerateTrait(classDecl, name, code);
+			return;
+		}
+
+		GenerateStruct(classDecl, name, code);
+
+		List<FunctionDeclaration> functions =
+		[
+			.. classDecl.Members.OfType<FunctionDeclaration>().Where(member => member.Kind is not FunctionKind.Destructor),
+		];
+
+		List<FunctionDeclaration> inherent =
+		[
+			.. functions.Where(member => member.Kind is FunctionKind.Method or FunctionKind.Constructor),
+		];
+
+		if (inherent.Count > 0)
+		{
+			code.NewLine();
+			code.Write($"impl {name} ");
+
+			using Scope block = new(code);
+			bool first = true;
+			foreach (FunctionDeclaration function in inherent)
+			{
+				if (!first)
+				{
+					code.NewLine();
+				}
+
+				first = false;
+				GenerateFunction(function, code, name);
+			}
+		}
+
+		foreach (FunctionDeclaration function in functions.Except(inherent))
+		{
+			code.NewLine();
+			GenerateTraitImplementation(function, name, code);
+		}
+
+		foreach (FunctionDeclaration destructor in classDecl.Members
+			.OfType<FunctionDeclaration>()
+			.Where(member => member.Kind == FunctionKind.Destructor))
+		{
+			code.NewLine();
+			GenerateDrop(destructor, name, code);
+		}
+	}
+
+	/// <summary>
+	/// Writes a declaration that is for a type rather than of one.
+	/// </summary>
+	/// <param name="classDecl">The declaration to emit.</param>
+	/// <param name="name">The name being specialised.</param>
+	/// <param name="code">The writer to emit into.</param>
+	/// <remarks>
+	/// This is the one place Rust answers C++ exactly. An explicit specialisation attaches facts to a
+	/// type without touching the type, and <c>impl Describe for RigidBody</c> is how Rust does that —
+	/// so a specialisation is a trait implementation, its fields are associated constants and its
+	/// functions are its methods.
+	/// <para>
+	/// Rust's own <c>specialization</c> feature is a different thing and is not what this needs: that
+	/// one is about a more specific implementation overriding a blanket one, and is unstable. This
+	/// needs no feature at all.
+	/// </para>
+	/// </remarks>
+	private void GenerateSpecialisation(ClassDeclaration classDecl, string name, CodeBlocker code)
+	{
+		GenerateDocumentation(classDecl, code);
+
+		string arguments = string.Join(", ", classDecl.SpecialisationArguments.Select(SpellType));
+		code.Write($"impl {name} for {arguments} ");
+
+		using Scope body = new(code);
+
+		insideTraitImplementation = true;
+		WriteMembers(classDecl.Members, code);
+		insideTraitImplementation = false;
+	}
+
+	/// <summary>
+	/// Reports whether a member declares a type rather than data or behaviour.
+	/// </summary>
+	/// <param name="member">The member to test.</param>
+	/// <returns>True when it declares a type.</returns>
+	/// <remarks>
+	/// A type declared inside another is written beside it. Rust nests modules rather than types, so
+	/// a type declared within a type has nowhere to go except the module they are both in.
+	/// </remarks>
+	private static bool IsTypeDeclaration(AstNode member) =>
+		member is ClassDeclaration or EnumDeclaration or UsingAlias;
+
+	/// <summary>
+	/// Writes the data half of a type declaration.
+	/// </summary>
+	/// <param name="classDecl">The declaration to emit.</param>
+	/// <param name="name">The name it is written under.</param>
+	/// <param name="code">The writer to emit into.</param>
+	private void GenerateStruct(ClassDeclaration classDecl, string name, CodeBlocker code)
+	{
+		GenerateDocumentation(classDecl, code);
+		code.Write($"{SpellVisibilityOf(classDecl)}struct {name} ");
+
+		using Scope body = new(code);
+
+		insideType++;
+
+		if (classDecl.BaseType is TypeReference baseType)
+		{
+			WriteInexpressible(code, "the base: Rust has no inheritance, so it is held rather than derived from");
+			code.WriteLine($"pub {BaseMemberName}: {SpellType(baseType)},");
+		}
+
+		foreach (AstNode member in classDecl.Members)
+		{
+			switch (member)
+			{
+				case VariableDeclaration field:
+					WriteStructMember(field.Name, field.Type, VisibilityOf(field), code);
+					break;
+
+				case FieldDeclaration field:
+					GenerateDocumentation(field, code);
+					WriteStructMember(field.Name, field.Type, field.Visibility, code);
+					break;
+
+				default:
+					break;
+			}
+		}
+
+		insideType--;
+	}
+
+	/// <summary>
+	/// Writes one field of a struct.
+	/// </summary>
+	/// <param name="name">The field's name.</param>
+	/// <param name="type">The field's type.</param>
+	/// <param name="visibility">What the declaration said about who may see it.</param>
+	/// <param name="code">The writer to emit into.</param>
+	/// <remarks>
+	/// A field's initial value is not written, and unlike C that is not a gap to apologise for: a
+	/// Rust struct is built by naming every field at once, so what a field starts at is the
+	/// constructor's business rather than the declaration's.
+	/// </remarks>
+	private static void WriteStructMember(string? name, TypeReference? type, Visibility visibility, CodeBlocker code) =>
+		code.WriteLine($"{SpellVisibilityKeyword(visibility)}{name}: {SpellType(type ?? new TypeReference(UnknownTypeName))},");
+
+	/// <summary>
+	/// Writes an interface as the trait it is.
+	/// </summary>
+	/// <param name="classDecl">The declaration to emit.</param>
+	/// <param name="name">The name it is written under.</param>
+	/// <param name="code">The writer to emit into.</param>
+	private void GenerateTrait(ClassDeclaration classDecl, string name, CodeBlocker code)
+	{
+		GenerateDocumentation(classDecl, code);
+		code.Write($"{SpellVisibilityOf(classDecl)}trait {name}");
+
+		// A base type is a supertrait: something every implementation of this one must also be.
+		if (classDecl.BaseType is TypeReference baseType)
+		{
+			code.Write($": {SpellType(baseType)}");
+		}
+
+		code.Write(" ");
+
+		using Scope body = new(code);
+
+		insideTrait = true;
+
+		bool first = true;
+		foreach (AstNode member in classDecl.Members.Where(member => member is FunctionDeclaration or FieldDeclaration))
+		{
+			if (!first)
+			{
+				code.NewLine();
+			}
+
+			first = false;
+
+			if (member is FunctionDeclaration function)
+			{
+				GenerateFunction(function, code, name);
+				continue;
+			}
+
+			GenerateInternal(member, code);
+		}
+
+		insideTrait = false;
+	}
+
+	/// <summary>
+	/// Writes an operator or a conversion as the trait implementation Rust spells it through.
+	/// </summary>
+	/// <param name="funcDecl">The declaration to emit.</param>
+	/// <param name="typeName">The type it belongs to.</param>
+	/// <param name="code">The writer to emit into.</param>
+	private void GenerateTraitImplementation(FunctionDeclaration funcDecl, string typeName, CodeBlocker code)
+	{
+		if (funcDecl.Kind == FunctionKind.ConversionOperator)
+		{
+			GenerateConversion(funcDecl, typeName, code);
+			return;
+		}
+
+		string symbol = funcDecl.Name ?? string.Empty;
+		bool unary = funcDecl.Parameters.Count == 0;
+		Dictionary<string, OperatorTrait> traits = unary ? UnaryOperatorTraits : BinaryOperatorTraits;
+
+		if (!traits.TryGetValue(symbol, out OperatorTrait? op))
+		{
+			string reason = ComparisonOperators.TryGetValue(symbol, out string? supplied)
+				? supplied
+				: "no std::ops trait";
+			GenerateDocumentation(funcDecl, code);
+			WriteInexpressible(code, $"operator{symbol} on {typeName}: implement {reason}");
+			return;
+		}
+
+		GenerateDocumentation(funcDecl, code);
+		code.Write($"impl {op.Name} for {typeName} ");
+
+		using Scope block = new(code);
+
+		string result = SpellType(funcDecl.ReturnType ?? new TypeReference(typeName));
+
+		if (!op.ReturnsBool)
+		{
+			code.WriteLine($"type Output = {result};");
+			code.NewLine();
+		}
+
+		// A comparison borrows what it compares and answers a bool; an arithmetic operator consumes
+		// its operands and answers the type it named as its Output.
+		string self = op.ReturnsBool ? "&self" : "self";
+		code.Write($"fn {op.Method}({self}");
+
+		foreach (Parameter parameter in funcDecl.Parameters)
+		{
+			code.Write(", ");
+			code.Write($"{parameter.Name ?? "rhs"}: {SpellOperandType(parameter, op, typeName)}");
+		}
+
+		code.Write($") -> {(op.ReturnsBool ? "bool" : result)} ");
+
+		using Scope body = new(code);
+		WriteBody(funcDecl.Body, code);
+	}
+
+	/// <summary>
+	/// Spells the type of the operand beside the instance.
+	/// </summary>
+	/// <param name="parameter">The operand as the declaration carries it.</param>
+	/// <param name="op">The trait being implemented.</param>
+	/// <param name="typeName">The type the operator belongs to.</param>
+	/// <returns>The type as Rust writes it.</returns>
+	/// <remarks>
+	/// A comparison borrows its operand for the same reason it borrows the instance — answering
+	/// whether two values are equal is not a reason to consume either of them.
+	/// </remarks>
+	private static string SpellOperandType(Parameter parameter, OperatorTrait op, string typeName)
+	{
+		string spelled = SpellType(parameter.Type ?? new TypeReference(typeName));
+		return op.ReturnsBool ? $"&{spelled}" : spelled;
+	}
+
+	/// <summary>
+	/// Writes a conversion as the <c>From</c> implementation Rust spells it through.
+	/// </summary>
+	/// <param name="funcDecl">The declaration to emit.</param>
+	/// <param name="typeName">The type being converted from.</param>
+	/// <param name="code">The writer to emit into.</param>
+	/// <remarks>
+	/// <c>From</c> rather than <c>Into</c>: implementing one gives the other for free, and this is
+	/// the direction the standard library asks to be implemented.
+	/// </remarks>
+	private void GenerateConversion(FunctionDeclaration funcDecl, string typeName, CodeBlocker code)
+	{
+		string target = SpellType(funcDecl.ReturnType ?? new TypeReference(UnknownTypeName));
+
+		GenerateDocumentation(funcDecl, code);
+		code.Write($"impl From<{typeName}> for {target} ");
+
+		using Scope block = new(code);
+		code.Write($"fn from(value: {typeName}) -> {target} ");
+
+		using Scope body = new(code);
+		WriteBody(funcDecl.Body, code);
+	}
+
+	/// <summary>
+	/// Writes a destructor as the <c>Drop</c> implementation Rust spells it through.
+	/// </summary>
+	/// <param name="funcDecl">The declaration to emit.</param>
+	/// <param name="typeName">The type being dropped.</param>
+	/// <param name="code">The writer to emit into.</param>
+	/// <remarks>
+	/// A destructor is the one member whose name Rust fixes: <c>drop</c>, taking <c>&amp;mut self</c>,
+	/// called for you. It cannot go in the inherent block, because a type that both implements
+	/// <c>Drop</c> and has its own <c>drop</c> has two of them.
+	/// </remarks>
+	private void GenerateDrop(FunctionDeclaration funcDecl, string typeName, CodeBlocker code)
+	{
+		GenerateDocumentation(funcDecl, code);
+		code.Write($"impl Drop for {typeName} ");
+
+		using Scope block = new(code);
+		code.Write("fn drop(&mut self) ");
+
+		using Scope body = new(code);
+		WriteBody(funcDecl.Body, code);
+	}
+
+	/// <inheritdoc/>
+	protected override void GenerateFunctionDeclaration(FunctionDeclaration funcDecl, CodeBlocker code) =>
+		GenerateFunction(funcDecl, code, null);
+
+	/// <summary>
+	/// Emits a function, which may have been declared as a member of a type.
+	/// </summary>
+	/// <param name="funcDecl">The declaration to emit.</param>
+	/// <param name="code">The writer to emit into.</param>
+	/// <param name="enclosingType">The name of the type it belongs to, when it belongs to one.</param>
+	/// <remarks>
+	/// A member takes a receiver, and which one it takes is what
+	/// <see cref="FunctionDeclaration.IsReadOnly"/> decides: a member that promises not to modify
+	/// what it is called on takes <c>&amp;self</c> and one that does not takes <c>&amp;mut self</c>.
+	/// That is the same promise C++ spells as a trailing <c>const</c>, and the one modifier here that
+	/// Rust states more strongly than the language it came from.
+	/// <para>
+	/// Nothing is written for <see cref="FunctionDeclaration.IsNoThrow"/>,
+	/// <see cref="FunctionDeclaration.IsExplicit"/> or <see cref="FunctionDeclaration.IsFriend"/>:
+	/// Rust has no exceptions, no converting constructors, and no way to make an exception to privacy
+	/// for one named friend.
+	/// </para>
+	/// </remarks>
+	private void GenerateFunction(FunctionDeclaration funcDecl, CodeBlocker code, string? enclosingType)
+	{
+		Ensure.NotNull(funcDecl);
+		Ensure.NotNull(code);
+
+		GenerateDocumentation(funcDecl, code);
+
+		// A deleted declaration exists to make a call illegal, and Rust has no way to say that of one
+		// member. Writing the signature would do the opposite of what it asks for.
+		if (funcDecl.Definition == FunctionDefinition.Deleted)
+		{
+			WriteInexpressible(code, $"{SpellFunctionName(funcDecl)} is deleted: Rust cannot refuse a call");
+			return;
+		}
+
+		// A defaulted declaration is one the language supplies. Rust supplies it too, through a
+		// derive rather than through the declaration, which is the caller's line to write.
+		if (funcDecl.Definition == FunctionDefinition.Defaulted)
+		{
+			WriteInexpressible(code, $"{SpellFunctionName(funcDecl)} is defaulted: derive it, or implement Default");
+			return;
+		}
+
+		// #[must_use] says what a pure function's purity means to a caller, and is worth nothing on
+		// one that answers nothing.
+		if ((funcDecl.IsPure || funcDecl.MustUseResult) && ReturnsAValue(funcDecl))
+		{
+			code.WriteLine("#[must_use]");
+		}
+
+		if (!IsAssociatedItem)
+		{
+			code.Write(SpellVisibilityOf(funcDecl));
+		}
+
+		if (funcDecl.IsCompileTimeEvaluable)
+		{
+			code.Write("const ");
+		}
+
+		code.Write($"fn {SpellFunctionName(funcDecl)}(");
+		WriteReceiver(funcDecl, enclosingType, code);
+		GenerateParameterList(funcDecl.Parameters, code);
+		code.Write(")");
+
+		if (funcDecl.Kind == FunctionKind.Constructor)
+		{
+			code.Write(" -> Self");
+		}
+		else if (ReturnsAValue(funcDecl))
+		{
+			code.Write($" -> {SpellType(funcDecl.ReturnType!)}");
+		}
+
+		// A declaration with no definition is a requirement, which is a thing only a trait can hold:
+		// an abstract member of a struct has nowhere to be implemented.
+		if (funcDecl.IsAbstract || (insideTrait && funcDecl.Body.Count == 0))
+		{
+			code.WriteLine(";");
+			return;
+		}
+
+		// The line is left open, so the scope's brace lands on it: Rust braces hang.
+		code.Write(" ");
+
+		using Scope body = new(code);
+
+		if (funcDecl.Kind == FunctionKind.Constructor)
+		{
+			WriteConstructorBody(funcDecl, code);
+			return;
+		}
+
+		WriteBody(funcDecl.Body, code);
+	}
+
+	/// <summary>
+	/// Writes a function's statements.
+	/// </summary>
+	/// <param name="statements">The statements to write.</param>
+	/// <param name="code">The writer to emit into.</param>
+	private void WriteBody(IEnumerable<AstNode> statements, CodeBlocker code)
+	{
+		foreach (AstNode statement in statements)
+		{
+			GenerateInternal(statement, code);
+		}
+	}
+
+	/// <summary>
+	/// Writes what a constructor builds.
+	/// </summary>
+	/// <param name="funcDecl">The declaration being emitted.</param>
+	/// <param name="code">The writer to emit into.</param>
+	/// <remarks>
+	/// A Rust value is built by naming every field at once, so the initialiser list is the whole of
+	/// the constructor rather than a preamble to it — and it is the function's tail expression, which
+	/// is how Rust returns without saying so.
+	/// <para>
+	/// A field initialised from a name of its own spelling is written as that name alone, which is
+	/// Rust's field-init shorthand and what anybody would have written by hand.
+	/// </para>
+	/// </remarks>
+	private void WriteConstructorBody(FunctionDeclaration funcDecl, CodeBlocker code)
+	{
+		WriteBody(funcDecl.Body, code);
+
+		if (funcDecl.Initialisers.Count == 0)
+		{
+			// There is nothing to build from, and Rust has no zero value to fall back on. Default is
+			// the one thing a type can ask for without naming its fields.
+			code.WriteLine("Self::default()");
+			return;
+		}
+
+		ConstructionExpression value = new(new TypeReference("Self"));
+		foreach (MemberInitialiser initialiser in funcDecl.Initialisers)
+		{
+			value.Arguments.Add(initialiser);
+		}
+
+		GenerateConstructionExpression(value, code);
+		code.WriteLine();
+	}
+
+	/// <summary>
+	/// Writes the instance a member function acts on, when it acts on one.
+	/// </summary>
+	/// <param name="funcDecl">The declaration being emitted.</param>
+	/// <param name="enclosingType">The name of the type it belongs to, when it belongs to one.</param>
+	/// <param name="code">The writer to emit into.</param>
+	private static void WriteReceiver(FunctionDeclaration funcDecl, string? enclosingType, CodeBlocker code)
+	{
+		// A static member acts on no instance, and a constructor has none to act on yet.
+		if (enclosingType is null || funcDecl.IsStatic || funcDecl.Kind == FunctionKind.Constructor)
+		{
+			return;
+		}
+
+		code.Write(funcDecl.IsReadOnly ? "&self" : "&mut self");
+
+		if (funcDecl.Parameters.Count > 0)
+		{
+			code.Write(", ");
+		}
+	}
+
+	/// <summary>
+	/// Reports whether a function answers with something.
+	/// </summary>
+	/// <param name="funcDecl">The declaration to test.</param>
+	/// <returns>True when it has a return type that is not the unit.</returns>
+	/// <remarks>
+	/// Rust writes no return type for a function that answers nothing, rather than naming the unit:
+	/// <c>-&gt; ()</c> is legal and nobody writes it.
+	/// </remarks>
+	private static bool ReturnsAValue(FunctionDeclaration funcDecl) =>
+		funcDecl.ReturnType is TypeReference declared && SpellType(declared) != "()";
+
+	/// <summary>
+	/// Spells the name a declaration is written under.
+	/// </summary>
+	/// <param name="funcDecl">The declaration being emitted.</param>
+	/// <returns>The name as Rust writes it.</returns>
+	/// <remarks>
+	/// A constructor is <c>new</c>, which is a convention rather than a keyword — Rust has no
+	/// constructors, and an associated function returning <c>Self</c> is what every type writes
+	/// instead.
+	/// </remarks>
+	private static string SpellFunctionName(FunctionDeclaration funcDecl) => funcDecl.Kind switch
+	{
+		FunctionKind.Constructor => "new",
+		FunctionKind.Destructor => "drop",
+		_ => funcDecl.Name ?? "unnamed_function",
+	};
+
+	/// <inheritdoc/>
+	/// <remarks>
+	/// A parameter's default value is written beside it as a comment. Rust has no default arguments,
+	/// so the caller has to pass one — and the value the declaration chose is exactly what they need
+	/// in order to pass the same thing.
+	/// </remarks>
+	protected override void GenerateParameter(Parameter parameter, CodeBlocker code, int position)
+	{
+		Ensure.NotNull(parameter);
+		Ensure.NotNull(code);
+
+		code.Write($"{parameter.Name ?? $"param{position}"}: ");
+		code.Write(SpellType(parameter.Type ?? new TypeReference(UnknownTypeName)));
+
+		if (parameter.IsOptional && !string.IsNullOrEmpty(parameter.DefaultValue))
+		{
+			code.Write($" /* = {parameter.DefaultValue} */");
+		}
+	}
+
+	/// <inheritdoc/>
+	/// <remarks>
+	/// <c>let</c> binds immutably in Rust, which is the opposite of every other target here, so an
+	/// ordinary declaration is written <c>let mut</c> and a constant one plain <c>let</c>. The
+	/// warning an unneeded <c>mut</c> earns is a better outcome than the error a missing one causes,
+	/// and the AST says whether a value is constant rather than whether it is ever assigned again.
+	/// <para>
+	/// An inferred declaration writes no type at all, which is the one thing on this list Rust does
+	/// better than the language the node was modelled on: <c>let x = 5;</c> needs no <c>auto</c> and
+	/// no <c>var</c>.
+	/// </para>
+	/// </remarks>
+	protected override void GenerateVariableDeclaration(VariableDeclaration varDecl, CodeBlocker code)
+	{
+		Ensure.NotNull(varDecl);
+		Ensure.NotNull(code);
+
+		code.Write(varDecl.IsConstant ? "let " : "let mut ");
+		code.Write(varDecl.Name);
+
+		bool inferred = varDecl.IsTypeInferred || varDecl.Type is null;
+		if (!inferred || varDecl.InitialValue is null)
+		{
+			code.Write($": {SpellType(varDecl.Type ?? new TypeReference(UnknownTypeName))}");
+		}
+
+		if (varDecl.InitialValue is not null)
+		{
+			code.Write(" = ");
+			GenerateInternal(varDecl.InitialValue, code);
+		}
+
+		EndStatement(code);
+	}
+
+	/// <inheritdoc/>
+	/// <remarks>
+	/// Inside a struct this is a field; at module scope it is a <c>const</c> when the declaration
+	/// says its value never changes and a <c>static</c> otherwise. The difference is real rather than
+	/// stylistic: a <c>const</c> is substituted wherever it is named and a <c>static</c> is one
+	/// object with an address, which is what a large table wants to be.
+	/// <para>
+	/// Both require a value, and an array one requires a length that
+	/// <see cref="TypeReference.IsArray"/> deliberately does not carry — so a constant array is
+	/// written as a borrowed slice, <c>&amp;[T]</c>, which is the bound-free spelling Rust does have
+	/// and the one a generated table wants anyway.
+	/// </para>
+	/// </remarks>
+	protected override void GenerateFieldDeclaration(FieldDeclaration field, CodeBlocker code)
+	{
+		Ensure.NotNull(field);
+		Ensure.NotNull(code);
+
+		if (insideType > 0)
+		{
+			GenerateDocumentation(field, code);
+			WriteStructMember(field.Name, field.Type, field.Visibility, code);
+			return;
+		}
+
+		GenerateDocumentation(field, code);
+
+		TypeReference type = field.Type ?? new TypeReference(UnknownTypeName);
+
+		// A trait's constant may say only what it is, leaving every implementation to say what it
+		// holds. That is a requirement rather than a value with something missing.
+		if (insideTrait && field.InitialValue is null)
+		{
+			code.Write($"const {field.Name}: {SpellStorageType(type)}");
+			EndStatement(code);
+			return;
+		}
+
+		if (field.InitialValue is null)
+		{
+			WriteInexpressible(code, $"{field.Name}: Rust gives a const or a static no value of its own");
+			return;
+		}
+
+		string visibility = IsAssociatedItem ? string.Empty : SpellVisibilityKeyword(field.Visibility);
+		string storage = IsAssociatedItem || field.IsConstant ? "const" : "static";
+
+		code.Write($"{visibility}{storage} ");
+		code.Write($"{field.Name}: {SpellStorageType(type)} = ");
+
+		// A slice borrows the array literal it is written from, which is what makes a table with no
+		// length a constant at all.
+		if (type.IsArray)
+		{
+			code.Write("&");
+		}
+
+		GenerateInternal(field.InitialValue, code);
+		EndStatement(code);
+	}
+
+	/// <summary>
+	/// Spells the type a constant or a static is declared with.
+	/// </summary>
+	/// <param name="type">The declared type.</param>
+	/// <returns>The type as Rust writes it in that position.</returns>
+	private static string SpellStorageType(TypeReference type)
+	{
+		if (!type.IsArray)
+		{
+			return SpellType(type);
+		}
+
+		TypeReference element = type.Clone();
+		element.IsArray = false;
+		return $"&[{SpellType(element)}]";
+	}
+
+	/// <inheritdoc/>
+	/// <remarks>
+	/// An enumeration's variants are named through it — <c>Colour::Red</c> — so nothing has to be
+	/// prefixed to keep two enumerations with a <c>None</c> each apart, which is the thing C cannot
+	/// do. A fixed underlying type is <c>#[repr]</c>, which is the guarantee rather than a comment
+	/// about one.
+	/// </remarks>
+	protected override void GenerateEnumDeclaration(EnumDeclaration enumDecl, CodeBlocker code)
+	{
+		Ensure.NotNull(enumDecl);
+		Ensure.NotNull(code);
+
+		GenerateDocumentation(enumDecl, code);
+
+		if (enumDecl.UnderlyingType is TypeReference underlying)
+		{
+			code.WriteLine($"#[repr({SpellType(underlying)})]");
+		}
+
+		code.Write($"{SpellVisibilityOf(enumDecl)}enum {enumDecl.Name ?? "UnnamedEnum"} ");
+
+		using Scope body = new(code);
+		foreach (EnumMember member in enumDecl.Members)
+		{
+			code.Write(member.Name ?? "Unnamed");
+
+			if (member.Value is not null)
+			{
+				code.Write($" = {member.Value}");
+			}
+
+			// A trailing comma on the last variant too, so adding one after it is a one-line diff.
+			code.WriteLine(",");
+		}
+	}
+
+	/// <inheritdoc/>
+	protected override void GenerateUsingAlias(UsingAlias usingAlias, CodeBlocker code)
+	{
+		Ensure.NotNull(usingAlias);
+		Ensure.NotNull(code);
+
+		GenerateDocumentation(usingAlias, code);
+		code.Write($"{SpellVisibilityOf(usingAlias)}type {usingAlias.Name} = ");
+		code.Write(SpellType(usingAlias.AliasedType ?? new TypeReference(UnknownTypeName)));
+		EndStatement(code);
+	}
+
+	/// <inheritdoc/>
+	/// <remarks>
+	/// <c>const _: () = assert!(…)</c>, which is Rust's own compile-time assertion and needs no
+	/// macro crate: a constant nobody names still has to be evaluated for the program to build, and
+	/// a failed <c>assert!</c> in that position is a compile error naming the message.
+	/// </remarks>
+	protected override void GenerateCompileTimeAssertion(CompileTimeAssertion assertion, CodeBlocker code)
+	{
+		Ensure.NotNull(assertion);
+		Ensure.NotNull(code);
+
+		string condition = assertion.Condition ?? "false";
+
+		code.Write($"const _: () = assert!({condition}");
+
+		if (assertion.Message is not null)
+		{
+			code.WriteLine(",");
+			code.Indent();
+			code.Write($"\"{EscapeString(assertion.Message)}\"");
+			code.Outdent();
+		}
+
+		code.Write(")");
+		EndStatement(code);
+	}
+
+	/// <inheritdoc/>
+	/// <remarks>
+	/// Three shapes, and which one is written depends on what the expression is rather than on where
+	/// it stands: a construction naming its members is a struct literal, one that does not is a call,
+	/// and one with no type at all is an array literal — which is what initialises a declaration that
+	/// has already said its type, a constant table most of all.
+	/// <para>
+	/// Rust needs no distinction between an initialiser and a value the way C does. A struct literal
+	/// is an expression everywhere, including in the constant that a table has to be.
+	/// </para>
+	/// </remarks>
+	protected override void GenerateConstructionExpression(ConstructionExpression construction, CodeBlocker code)
+	{
+		Ensure.NotNull(construction);
+		Ensure.NotNull(code);
+
+		if (construction.Type is null)
+		{
+			WriteElementList(construction, code, "[", "]", "[]");
+			return;
+		}
+
+		string type = SpellType(construction.Type);
+
+		if (construction.Arguments.Any(argument => argument is MemberInitialiser))
+		{
+			code.Write($"{type} ");
+			WriteElementList(construction, code, "{", "}", "{}");
+			return;
+		}
+
+		code.Write(type);
+		WriteCallArguments(construction, code);
+	}
+
+	/// <summary>
+	/// Writes the arguments of a construction that names none of its members.
+	/// </summary>
+	/// <param name="construction">The expression whose arguments to write.</param>
+	/// <param name="code">The writer to emit into.</param>
+	/// <remarks>
+	/// A call rather than a list: a tuple struct and a function are built the same way, and neither
+	/// is a table, so the arguments stay on one line however many there are.
+	/// </remarks>
+	private void WriteCallArguments(ConstructionExpression construction, CodeBlocker code)
+	{
+		code.Write("(");
+
+		for (int index = 0; index < construction.Arguments.Count; index++)
+		{
+			if (index > 0)
+			{
+				code.Write(", ");
+			}
+
+			GenerateInternal(construction.Arguments[index], code);
+		}
+
+		code.Write(")");
+	}
+
+	/// <inheritdoc/>
+	/// <remarks>
+	/// A field initialised from a variable of its own name is written as that name alone, which is
+	/// Rust's field-init shorthand and what the same line would look like written by hand. It is not
+	/// only shorter: <c>x: x</c> is what clippy's <c>redundant_field_names</c> exists to complain
+	/// about, so writing it would make every generated constructor a lint.
+	/// </remarks>
+	protected override void WriteListElement(AstNode argument, CodeBlocker code)
+	{
+		Ensure.NotNull(code);
+
+		if (argument is MemberInitialiser { Value: VariableReference reference } designated
+			&& string.Equals(designated.Name, reference.Name, StringComparison.Ordinal))
+		{
+			code.Write(reference.Name);
+			return;
+		}
+
+		base.WriteListElement(argument, code);
+	}
+
+	/// <inheritdoc/>
+	/// <remarks>
+	/// Rust's <c>main</c> takes no arguments and returns nothing, so a program that wants either
+	/// reaches for the standard library: the arguments come from <c>std::env::args</c>, and an exit
+	/// code is handed to <c>std::process::exit</c>.
+	/// <para>
+	/// A program that returns an exit code is written as a <c>run</c> answering one and a
+	/// <c>main</c> exiting with what it answered — the same shape Python's <c>__main__</c> guard
+	/// takes here, and for the same reason: it is what keeps the body's own <c>return</c> meaning
+	/// what it says.
+	/// </para>
+	/// </remarks>
+	protected override void GenerateEntryPoint(EntryPoint entryPoint, CodeBlocker code)
+	{
+		Ensure.NotNull(entryPoint);
+		Ensure.NotNull(code);
+
+		string arguments = entryPoint.AcceptsArguments ? "args: Vec<String>" : string.Empty;
+		string collect = entryPoint.AcceptsArguments ? "std::env::args().collect()" : string.Empty;
+
+		if (entryPoint.ReturnsExitCode)
+		{
+			code.Write($"fn run({arguments}) -> i32 ");
+
+			using (Scope run = new(code))
+			{
+				WriteBody(entryPoint.Body, code);
+			}
+
+			code.NewLine();
+			code.Write("fn main() ");
+
+			using Scope main = new(code);
+			code.WriteLine($"std::process::exit(run({collect}));");
+			return;
+		}
+
+		code.Write("fn main() ");
+
+		using Scope body = new(code);
+
+		if (entryPoint.AcceptsArguments)
+		{
+			code.WriteLine($"let args: Vec<String> = {collect};");
+		}
+
+		WriteBody(entryPoint.Body, code);
+	}
+
+	/// <summary>
+	/// Spells what a declaration said about who may see it, with a trailing space.
+	/// </summary>
+	/// <param name="node">The declaration to read.</param>
+	/// <returns>The keyword and a space, or nothing.</returns>
+	private static string SpellVisibilityOf(AstNode node) => SpellVisibilityKeyword(VisibilityOf(node));
+
+	/// <summary>
+	/// Spells a visibility, with a trailing space.
+	/// </summary>
+	/// <param name="visibility">The visibility to spell.</param>
+	/// <returns>The keyword and a space, or nothing.</returns>
+	/// <remarks>
+	/// Rust's default is private to the module, so <c>pub</c> has to be written wherever anything
+	/// outside is meant to reach the declaration — including on every field, which is what makes a
+	/// generated data type usable at all. That is why <see cref="Visibility.Unspecified"/> is public
+	/// here: a type nothing can read is not what a declaration that said nothing asked for.
+	/// <para>
+	/// <see cref="Visibility.Protected"/> is <c>pub(crate)</c>, which is the nearest Rust has and is
+	/// not very near. Protected means visible to whatever derives from this, and nothing derives from
+	/// anything here.
+	/// </para>
+	/// </remarks>
+	private static string SpellVisibilityKeyword(Visibility visibility) => visibility switch
+	{
+		Visibility.Private => string.Empty,
+		Visibility.Internal or Visibility.Protected => "pub(crate) ",
+		_ => "pub ",
+	};
+
+	/// <summary>
+	/// Spells a type in Rust.
+	/// </summary>
+	/// <param name="type">The type to spell.</param>
+	/// <returns>The Rust source for it.</returns>
+	/// <remarks>
+	/// A reference is <c>&amp;</c>, and whether it is a <c>&amp;mut</c> is what
+	/// <see cref="TypeReference.IsReadOnly"/> decides — which is the same question C++ answers with
+	/// <c>const T&amp;</c> against <c>T&amp;</c>, asked in the other order. A pointer is a raw
+	/// pointer, which is the only thing Rust has that a pointer is, and is <c>*const</c> or
+	/// <c>*mut</c> for the same reason.
+	/// <para>
+	/// Borrowing an owned type gives the borrowed one rather than a reference to the owned one:
+	/// <c>&amp;str</c> and <c>&amp;[T]</c>, never <c>&amp;String</c> or <c>&amp;Vec&lt;T&gt;</c>.
+	/// </para>
+	/// </remarks>
+	private static string SpellType(TypeReference type)
+	{
+		string core = SpellCoreType(type);
+
+		if (type.Indirection == TypeIndirection.Pointer)
+		{
+			return $"*{(type.IsReadOnly ? "const" : "mut")} {core}";
+		}
+
+		if (type.Indirection == TypeIndirection.Reference)
+		{
+			return $"&{(type.IsReadOnly ? string.Empty : "mut ")}{Borrow(core)}";
+		}
+
+		return core;
+	}
+
+	/// <summary>
+	/// Spells a type without saying how it is reached.
+	/// </summary>
+	/// <param name="type">The type to spell.</param>
+	/// <returns>The owned form.</returns>
+	private static string SpellCoreType(TypeReference type)
+	{
+		string core = SpellTypeName(type);
+		return type.IsArray ? $"Vec<{core}>" : core;
+	}
+
+	/// <summary>
+	/// Spells a type's name and its arguments.
+	/// </summary>
+	/// <param name="type">The type whose name to spell.</param>
+	/// <returns>The name as Rust writes it.</returns>
+	/// <remarks>
+	/// <c>list</c> and <c>dict</c> are the two names the AST has that Rust spells from the standard
+	/// library rather than from the name. A container named without arguments is a container of the
+	/// most general thing there is, which is what the caller left unsaid.
+	/// </remarks>
+	private static string SpellTypeName(TypeReference type)
+	{
+		string unknown = TypeMappings[UnknownTypeName];
+
+		if (string.Equals(type.Name, "list", StringComparison.OrdinalIgnoreCase))
+		{
+			return $"Vec<{(type.TypeArguments.Count == 1 ? SpellType(type.TypeArguments[0]) : unknown)}>";
+		}
+
+		if (string.Equals(type.Name, "dict", StringComparison.OrdinalIgnoreCase))
+		{
+			return type.TypeArguments.Count == 2
+				? $"std::collections::HashMap<{SpellType(type.TypeArguments[0])}, {SpellType(type.TypeArguments[1])}>"
+				: $"std::collections::HashMap<String, {unknown}>";
+		}
+
+		string name = TypeMappings.TryGetValue(type.Name, out string? mapped) ? mapped : type.Name;
+
+		return type.TypeArguments.Count == 0
+			? name
+			: $"{name}<{string.Join(", ", type.TypeArguments.Select(SpellType))}>";
+	}
+
+	/// <summary>
+	/// Gives the form a type takes when it is borrowed rather than owned.
+	/// </summary>
+	/// <param name="owned">The owned spelling.</param>
+	/// <returns>The borrowed spelling, which is usually the same one.</returns>
+	private static string Borrow(string owned)
+	{
+		if (BorrowedForms.TryGetValue(owned, out string? borrowed))
+		{
+			return borrowed;
+		}
+
+		// A borrowed sequence is a slice, whatever it is a sequence of.
+		return owned.StartsWith("Vec<", StringComparison.Ordinal) && owned.EndsWith('>')
+			? $"[{owned[4..^1]}]"
+			: owned;
+	}
+}
diff --git a/Coder/Languages/StandardLanguageGenerator.cs b/Coder/Languages/StandardLanguageGenerator.cs
index 9c24c9c..87c297f 100644
--- a/Coder/Languages/StandardLanguageGenerator.cs
+++ b/Coder/Languages/StandardLanguageGenerator.cs
@@ -4,6 +4,7 @@ namespace ktsu.Coder.Languages;
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using ktsu.Coder.Ast;
 using ktsu.CodeBlocker;
 
@@ -281,6 +282,144 @@ protected void GenerateParameterList(IReadOnlyList<Parameter> parameters, CodeBl
 		}
 	}
 
+	/// <summary>
+	/// Writes a list of elements between delimiters, one per line when the elements are themselves
+	/// lists.
+	/// </summary>
+	/// <param name="construction">The expression whose arguments to write.</param>
+	/// <param name="code">The writer to emit into.</param>
+	/// <param name="open">What opens the list.</param>
+	/// <param name="close">What closes it.</param>
+	/// <param name="empty">What to write instead when there are no elements at all.</param>
+	/// <remarks>
+	/// Every language that writes a list of values writes it the same way — the delimiters differ,
+	/// and where a value names the member it is for, so does that spelling. Both are the caller's,
+	/// through the parameters and through <see cref="WriteDesignator"/>.
+	/// <para>
+	/// A list of values is a value and belongs on one line; a list whose elements are themselves
+	/// lists is a table, and a table written on one line is a row of a diff nobody can read. The test
+	/// is the shape of the data rather than a column count, because a generated file has no idea how
+	/// wide anyone's editor is and a rule about that would have to be guessed.
+	/// </para>
+	/// </remarks>
+	protected void WriteElementList(
+		ConstructionExpression construction,
+		CodeBlocker code,
+		string open,
+		string close,
+		string empty)
+	{
+		Ensure.NotNull(construction);
+		Ensure.NotNull(code);
+
+		if (construction.Arguments.Count == 0)
+		{
+			code.Write(empty);
+			return;
+		}
+
+		if (SpansLines(construction))
+		{
+			WriteStackedList(construction, code, open, close);
+			return;
+		}
+
+		code.Write($"{open} ");
+		for (int index = 0; index < construction.Arguments.Count; index++)
+		{
+			if (index > 0)
+			{
+				code.Write(", ");
+			}
+
+			WriteListElement(construction.Arguments[index], code);
+		}
+
+		code.Write($" {close}");
+	}
+
+	/// <summary>
+	/// Writes a list one element per line.
+	/// </summary>
+	/// <param name="construction">The expression whose arguments to write.</param>
+	/// <param name="code">The writer to emit into.</param>
+	/// <param name="open">What opens the list.</param>
+	/// <param name="close">What closes it.</param>
+	/// <remarks>
+	/// A trailing comma after the last element, which every target language allows in a list and
+	/// which keeps adding a row to a generated table from touching the row above it in the diff.
+	/// </remarks>
+	private void WriteStackedList(ConstructionExpression construction, CodeBlocker code, string open, string close)
+	{
+		code.WriteLine(open);
+		code.Indent();
+
+		foreach (AstNode argument in construction.Arguments)
+		{
+			WriteListElement(argument, code);
+			code.WriteLine(",");
+		}
+
+		code.Outdent();
+		code.Write(close);
+	}
+
+	/// <summary>
+	/// Writes one element of a list, which may name the member it is for.
+	/// </summary>
+	/// <param name="argument">The element to write.</param>
+	/// <param name="code">The writer to emit into.</param>
+	/// <remarks>
+	/// Overridable for a language with a shorter way to say one of these — Rust's field-init
+	/// shorthand is the one that exists here.
+	/// </remarks>
+	protected virtual void WriteListElement(AstNode argument, CodeBlocker code)
+	{
+		if (argument is MemberInitialiser designated)
+		{
+			WriteDesignator(designated.Name ?? string.Empty, code);
+			WriteListValue(designated.Value ?? new VariableReference(string.Empty), code);
+			return;
+		}
+
+		WriteListValue(argument, code);
+	}
+
+	/// <summary>
+	/// Writes the part of an element that says which member it is for.
+	/// </summary>
+	/// <param name="name">The member's name.</param>
+	/// <param name="code">The writer to emit into.</param>
+	/// <remarks>
+	/// <c>name: value</c> is what a language whose lists are keyed writes — Rust's struct literal
+	/// and JavaScript's object literal both. C and C++ write a designator instead, and override this.
+	/// </remarks>
+	protected virtual void WriteDesignator(string name, CodeBlocker code)
+	{
+		Ensure.NotNull(code);
+		code.Write($"{name}: ");
+	}
+
+	/// <summary>
+	/// Writes what one element of a list is.
+	/// </summary>
+	/// <param name="value">The value to write.</param>
+	/// <param name="code">The writer to emit into.</param>
+	/// <remarks>
+	/// Ordinary generation, unless a language has something to say about a value that stands inside
+	/// a list rather than on its own — which C does, since only there may it leave the type out.
+	/// </remarks>
+	protected virtual void WriteListValue(AstNode value, CodeBlocker code) => GenerateInternal(value, code);
+
+	/// <summary>
+	/// Reports whether a list is worth breaking across lines.
+	/// </summary>
+	/// <param name="construction">The expression to judge.</param>
+	/// <returns><see langword="true"/> when it should be written one element per line.</returns>
+	private static bool SpansLines(ConstructionExpression construction) =>
+		construction.Arguments.Any(argument =>
+			argument is ConstructionExpression or MemberInitialiser { Value: ConstructionExpression });
+
 	/// <summary>
 	/// Spells a binary operator in the target language.
 	/// </summary>
diff --git a/Coder/ServiceCollectionExtensions.cs b/Coder/ServiceCollectionExtensions.cs
index 0bc6551..1775b61 100644
--- a/Coder/ServiceCollectionExtensions.cs
+++ b/Coder/ServiceCollectionExtensions.cs
@@ -25,6 +25,7 @@ public static IServiceCollection AddLanguageGenerators(this IServiceCollection s
 		services.AddSingleton<ILanguageGenerator, JavaScriptGenerator>();
 		services.AddSingleton<ILanguageGenerator, CppGenerator>();
 		services.AddSingleton<ILanguageGenerator, CGenerator>();
+		services.AddSingleton<ILanguageGenerator, RustGenerator>();
 
 		return services;
 	}
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 39b31f0..be05c8d 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -14,6 +14,7 @@
     <PackageVersion Include="ktsu.UndoRedo.Core" Version="1.0.19" />
     <PackageVersion Include="ktsu.ImGui.App.Testing" Version="3.32.0" />
     <PackageVersion Include="ktsu.ImGui.SyntaxHighlighting" Version="3.32.0" />
+    <PackageVersion Include="ktsu.SyntaxHighlighting" Version="3.32.0" />
     <PackageVersion Include="ktsu.ImGui.Probes" Version="3.32.0" />
     <PackageVersion Include="ktsu.ImGui.Widgets" Version="3.32.0" />
     <PackageVersion Include="Silk.NET.Windowing.Common" Version="2.23.0" />
diff --git a/README.md b/README.md
index 6490c26..49286a4 100644
--- a/README.md
+++ b/README.md
@@ -45,7 +45,7 @@ This makes it ideal for code generation tools, transpilers, and any application
 -   **LiteralExpression<T>**: Typed literals (string, int, bool, double)
 -   **AstLeafNode<T>**: Generic leaf nodes for literals (strings, numbers, booleans)
 
-Every operator in `UnaryOperator` and `BinaryOperator` exists in all five target languages, so no
+Every operator in `UnaryOperator` and `BinaryOperator` exists in all six target languages, so no
 AST built from them is untranslatable. Only the spelling varies — Python's `not`/`and`/`or`,
 JavaScript's strict `===`/`!==` — and each generator overrides just the operators it spells
 differently.
@@ -66,6 +66,7 @@ rather than the modifier's text because no two languages spell visibility the sa
 | C# | The keyword, in front of the declaration; a class or function with none is `public` |
 | C++ | An access label (`public:`, `protected:`, `private:`) the members are grouped under; `Internal` becomes `public:` |
 | C | Nothing inside a struct, which has no access control; a `Private` declaration at file scope is `static`, which is the internal linkage C has instead |
+| Rust | `pub`, or `pub(crate)` for `Internal` and `Protected`; `Private` writes nothing, which is already Rust's default. `Unspecified` is `pub`, since a generated type nothing outside the module can read is not what saying nothing asked for |
 | JavaScript | A private class member takes the `#` prefix, which is JavaScript's own private syntax; nothing for the rest |
 | Python | Nothing — Python has no access modifiers, and its leading-underscore convention renames the declaration rather than modifying it |
 
@@ -78,11 +79,18 @@ header declaring one and included twice would not link — JavaScript writes `co
 `static` for a class member, and Python writes a plain assignment, having no constant declaration to
 spell.
 
+Rust is the one target where the flag decides more than a keyword. A `let` binds immutably there, so
+a declaration that is *not* constant is written `let mut` — the warning an unneeded `mut` earns is a
+better outcome than the error a missing one causes. At module scope the flag picks between a `const`,
+which is substituted wherever it is named, and a `static`, which is one object with an address.
+
 An `EntryPoint` holds the statements a program runs. Each generator writes the spelling its language
 looks for: C#'s `static Main`, C++'s free `int main`, C's `int main(void)` — an empty parameter list
 in C declares a function whose parameters are unspecified rather than one that takes none — Python's
 `main` with the `__main__` guard that calls it (and the `import sys` its arguments and exit code
-need), and JavaScript's `main` with the call that runs it.
+need), JavaScript's `main` with the call that runs it, and Rust's `fn main`, which takes no arguments
+and returns nothing, so a program wanting either reaches for `std::env::args` and
+`std::process::exit`.
 
 ### Visual graph editor
 
@@ -175,6 +183,7 @@ directly.
 | `javascript` | `JavaScriptGenerator` | `js` | Untyped; `const`/`let`; strict `===` and `!==`; method, `static` and `#private` syntax inside a class |
 | `cpp` | `CppGenerator` | `cpp` | Mapped type spellings (`str` → `std::string`); `auto` for inferred declarations; access labels, `static constexpr` members and a terminating `;` on a class |
 | `c` | `CGenerator` | `c` | `typedef struct` for every kind of type; a member function is a free `Type_name(Type* self, …)`; an interface is a struct of function pointers; a base type is the first member; enumeration members are qualified by their enumeration; `_Static_assert`, `main(void)`, and `static const` for a constant |
+| `rust` | `RustGenerator` | `rs` | A `struct` for the data and an `impl` block for the behaviour; an interface is a `trait` and a base type on one is a supertrait; a destructor is `impl Drop`, an operator is its `std::ops` trait, a conversion is `impl From`, and a specialisation is `impl Trait for Type`; `#[repr]`, `#[must_use]`, `const fn`, and `const _: () = assert!(…)` |
 
 ## Installation
 
diff --git a/docs/design.md b/docs/design.md
index 0cf6a13..d4802fb 100644
--- a/docs/design.md
+++ b/docs/design.md
@@ -62,7 +62,7 @@ functionDeclaration:
    * Base implementation (`LanguageGeneratorBase`) provides common functionality.
    * Four generators, each with proper indentation and language-appropriate type handling:
      Python (type hints), C#, JavaScript (untyped, strict equality), and C++ (mapped type spellings).
-   * Dependency injection configuration (`ServiceCollectionExtensions`) registers all five.
+   * Dependency injection configuration (`ServiceCollectionExtensions`) registers all six.
 
 4. **Applications** ✅ **IMPLEMENTED**:
 
@@ -228,7 +228,7 @@ string pythonCode = pythonGenerator.Generate(astLoaded);
 3. **Expression system** — function calls (binary operators are implemented)
 
 ### Medium Priority
-4. **Further language generators** beyond the five that exist
+4. **Further language generators** beyond the six that exist
 5. **Error handling and validation** improvements
 6. **Performance optimization** and benchmarking
 
@@ -239,6 +239,6 @@ string pythonCode = pythonGenerator.Generate(astLoaded);
 
 ## Conclusion
 
-This .NET-based design has successfully implemented a robust, flexible foundation for AST-based code generation. The core infrastructure adheres to SOLID principles and provides working serialization and code generation for five target languages. The CLI and TUI applications demonstrate practical usage. 
+This .NET-based design has successfully implemented a robust, flexible foundation for AST-based code generation. The core infrastructure adheres to SOLID principles and provides working serialization and code generation for six target languages. The CLI and TUI applications demonstrate practical usage. 
 
 The next development phase should focus on completing the dependency injection infrastructure and expanding the AST node types to support more complex code structures.