diff --git a/CrossPlatformUI/ViewModels/GenerateRomViewModel.cs b/CrossPlatformUI/ViewModels/GenerateRomViewModel.cs
index 20e1c532..b5b4fe56 100644
--- a/CrossPlatformUI/ViewModels/GenerateRomViewModel.cs
+++ b/CrossPlatformUI/ViewModels/GenerateRomViewModel.cs
@@ -4,6 +4,7 @@
 using System.Reactive;
 using System.Reactive.Disposables;
 using System.Reactive.Subjects;
+using System.IO;
 using System.Reflection;
 using System.Text.Json.Serialization;
 using System.Threading;
@@ -96,8 +97,14 @@ async void GenerateSeed()
                     if(!tokenSource.IsCancellationRequested && output.success)
                     {
                         var flags = config.SerializeFlags();
-                        var basename = $"Z2_{config.Seed}_{flags}";
-                        var filename = basename + ".nes";
+                        var version = Assembly.GetEntryAssembly()!.GetName().Version!;
+                        var versionstr = $"{version.Major}.{version.Minor}.{version.Build}";
+                        var filename = OutputFilenameFormatter.Format(config.OutputFilenameTemplate, flags, config.Seed, randomizer.Hash, version: versionstr);
+                        var basename = Path.GetFileNameWithoutExtension(filename);
+                        if (string.IsNullOrEmpty(basename))
+                        {
+                            basename = filename;
+                        }
                         await files.SaveGeneratedBinaryFile(filename, output.romdata!, Main.OutputFilePath);
 #if DEBUG
                         var debugfile = basename + ".mlb";
diff --git a/CrossPlatformUI/ViewModels/RandomizerViewModel.cs b/CrossPlatformUI/ViewModels/RandomizerViewModel.cs
index 8e45f03f..17c42d72 100644
--- a/CrossPlatformUI/ViewModels/RandomizerViewModel.cs
+++ b/CrossPlatformUI/ViewModels/RandomizerViewModel.cs
@@ -28,22 +28,28 @@ public class RandomizerViewModel : ReactiveValidationObject, IRoutableViewModel,
     [JsonIgnore]
     public BehaviorSubject<bool> FlagsValidSubject = new(true);
 
-    private bool IsFlagStringValid(string flags)
+    private static bool IsFlagStringValid(string flags) => FlagPasteParser.IsValidFlagString(flags);
+
+    private string flagInput = "";
+
+    [JsonIgnore]
+    public string FlagInput
     {
-        try
-        {
-            _ = new RandomizerConfiguration(flags);
-            return true;
-        }
-        catch
+        get => flagInput;
+        set
         {
-            return false;
+            var trimmedValue = value?.Trim() ?? "";
+            var (extractedFlags, extractedSeed) = FlagPasteParser.Parse(trimmedValue);
+
+            if (Main is not null && !string.IsNullOrEmpty(extractedSeed))
+            {
+                Main.Config.Seed = extractedSeed;
+            }
+
+            this.RaiseAndSetIfChanged(ref flagInput, extractedFlags ?? trimmedValue);
         }
     }
 
-    [JsonIgnore]
-    public string FlagInput { get; set { field = value.Trim(); this.RaisePropertyChanged(); } } = "";
-
     [JsonIgnore]
     public string Seed
     {
diff --git a/CrossPlatformUI/ViewModels/Tabs/SpritePreviewViewModel.cs b/CrossPlatformUI/ViewModels/Tabs/SpritePreviewViewModel.cs
index 782fe83b..ab7bdf28 100644
--- a/CrossPlatformUI/ViewModels/Tabs/SpritePreviewViewModel.cs
+++ b/CrossPlatformUI/ViewModels/Tabs/SpritePreviewViewModel.cs
@@ -63,6 +63,12 @@ public BeamSprites BeamSprite
         set { Main.Config.BeamSprite = value; this.RaisePropertyChanged(); }
     }
 
+    public string OutputFilenameTemplate
+    {
+        get => Main.Config.OutputFilenameTemplate;
+        set { Main.Config.OutputFilenameTemplate = value; this.RaisePropertyChanged(); }
+    }
+
     public byte spriteTunicColor { get; private set; }
     public byte spriteSkinTone { get; private set; }
     public byte spriteOutlineColor { get; private set; }
diff --git a/CrossPlatformUI/Views/RandomizerView.axaml b/CrossPlatformUI/Views/RandomizerView.axaml
index 9918c202..43dc2d82 100644
--- a/CrossPlatformUI/Views/RandomizerView.axaml
+++ b/CrossPlatformUI/Views/RandomizerView.axaml
@@ -19,7 +19,7 @@
     <StackPanel Orientation="Vertical">
         <Grid ColumnDefinitions="2*, *, 196" RowDefinitions="Auto" Margin="0">
             <StackPanel Grid.Column="0" Margin="4 8 0 8">
-                <TextBox UseFloatingPlaceholder="True" PlaceholderText="Paste Flags Here" p1:TextFieldAssist.Label="Flag String" Text="{Binding FlagInput}">
+                <TextBox Name="FlagInputTextBox" UseFloatingPlaceholder="True" PlaceholderText="Paste Flags Here" p1:TextFieldAssist.Label="Flag String" Text="{Binding FlagInput}">
                     <TextBox.InnerRightContent>
                         <Button Name="PresetsButton" ToolTip.Tip="Presets" Classes="Flat" Padding="4" Width="{Binding $self.Bounds.Height}">
                             <Button.Content>
diff --git a/CrossPlatformUI/Views/RandomizerView.axaml.cs b/CrossPlatformUI/Views/RandomizerView.axaml.cs
index 7e5cf9f9..55b8db85 100644
--- a/CrossPlatformUI/Views/RandomizerView.axaml.cs
+++ b/CrossPlatformUI/Views/RandomizerView.axaml.cs
@@ -1,9 +1,12 @@
 using System;
 using System.Diagnostics.CodeAnalysis;
+using System.Reactive.Disposables;
 using System.Reactive.Disposables.Fluent;
 using System.Reactive.Linq;
 using Avalonia.Controls;
+using Avalonia.Interactivity;
 using Avalonia.Markup.Xaml;
+using Avalonia.Threading;
 using ReactiveUI;
 using ReactiveUI.Avalonia;
 using CrossPlatformUI.ViewModels;
@@ -20,6 +23,27 @@ public RandomizerView()
         this.WhenActivated(disposables => {
             if (DataContext is RandomizerViewModel vm)
             {
+                var flagInputTextBox = this.FindControl<TextBox>("FlagInputTextBox");
+                if (flagInputTextBox is not null)
+                {
+                    EventHandler<RoutedEventArgs> pasteHandler = (_, _) =>
+                    {
+                        Dispatcher.UIThread.Post(() =>
+                        {
+                            vm.FlagInput = flagInputTextBox.Text ?? "";
+                            if (flagInputTextBox.Text != vm.FlagInput)
+                            {
+                                flagInputTextBox.Text = vm.FlagInput;
+                                flagInputTextBox.CaretIndex = vm.FlagInput.Length;
+                            }
+                        }, DispatcherPriority.Background);
+                    };
+
+                    flagInputTextBox.PastingFromClipboard += pasteHandler;
+                    Disposable.Create(() => flagInputTextBox.PastingFromClipboard -= pasteHandler)
+                        .DisposeWith(disposables);
+                }
+
                 vm.SaveAsPreset.Subscribe(_ =>
                 {
                     Button presetsButton = this.FindControl<Button>("PresetsButton") ?? throw new System.Exception("Missing Required Validation Element");
diff --git a/CrossPlatformUI/Views/Tabs/SpritePreviewView.axaml b/CrossPlatformUI/Views/Tabs/SpritePreviewView.axaml
index 5a0f117e..3bfcaefc 100644
--- a/CrossPlatformUI/Views/Tabs/SpritePreviewView.axaml
+++ b/CrossPlatformUI/Views/Tabs/SpritePreviewView.axaml
@@ -63,6 +63,18 @@
                       SelectedItem="{Binding BeamSprite, Converter={x:Static ui:Util.EnumConvert}}">
                 <ToolTip.Tip><TextBlock Text="{x:Static lang:Resources.BeamSpriteToolTip}"/></ToolTip.Tip>
             </ComboBox>
+
+            <Separator Margin="0 8 0 0"/>
+
+            <TextBox
+                Margin="0 8 0 0"
+                UseFloatingPlaceholder="True"
+                PlaceholderText="Z2-%f-%s-%h.nes"
+                assists:TextFieldAssist.Label="Output Filename"
+                Text="{Binding OutputFilenameTemplate}"
+            >
+                <ToolTip.Tip><TextBlock Text="%f = flags, %s = seed, %h = hash, %d = date/time, %v = version"/></ToolTip.Tip>
+            </TextBox>
         </StackPanel>
         <StackPanel Grid.Column="1" Orientation="Vertical">
             <TextBlock>Sprite Preview</TextBlock>
diff --git a/RandomizerCore/FlagPasteParser.cs b/RandomizerCore/FlagPasteParser.cs
new file mode 100644
index 00000000..91628fb1
--- /dev/null
+++ b/RandomizerCore/FlagPasteParser.cs
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Z2Randomizer.RandomizerCore.Flags;
+
+namespace Z2Randomizer.RandomizerCore;
+
+public static class FlagPasteParser
+{
+    private static readonly HashSet<char> ValidFlagCharacters = [.. FlagBuilder.ENCODING_TABLE, '$'];
+
+    public static string? ExtractFlags(string input) => Parse(input).Flags;
+
+    public static string? ExtractSeed(string input) => Parse(input).Seed;
+
+    public static bool IsValidFlagString(string flags) => TryNormalizeFlagString(flags, out _);
+
+    // Replace anything that isn't a valid flag string character with a space,
+    // tokenize on the resulting whitespace, then pick out the flags and seed.
+    public static (string? Flags, string? Seed) Parse(string input)
+    {
+        if (string.IsNullOrWhiteSpace(input))
+        {
+            return (null, null);
+        }
+
+        var cleaned = string.Concat(
+            input.Select(character => ValidFlagCharacters.Contains(character) ? character : ' '));
+        var tokens = cleaned.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+
+        string? flags = null;
+        var flagIndex = -1;
+        for (var i = 0; i < tokens.Length; i++)
+        {
+            if (TryNormalizeFlagString(tokens[i], out var normalizedFlags))
+            {
+                flags = normalizedFlags;
+                flagIndex = i;
+                break;
+            }
+        }
+
+        // A seed is only meaningful alongside flags, so don't look for one until
+        // the flags have been found.
+        if (flags is null)
+        {
+            return (null, null);
+        }
+
+        for (var i = 0; i < tokens.Length; i++)
+        {
+            if (i != flagIndex && tokens[i].Length >= 6 && tokens[i].All(char.IsDigit))
+            {
+                return (flags, tokens[i]);
+            }
+        }
+
+        return (flags, null);
+    }
+
+    private static bool TryNormalizeFlagString(string flags, out string normalizedFlags)
+    {
+        normalizedFlags = string.Empty;
+        if (string.IsNullOrWhiteSpace(flags))
+        {
+            return false;
+        }
+
+        var trimmedFlags = flags.Trim();
+        if (trimmedFlags.Any(character => !ValidFlagCharacters.Contains(character)))
+        {
+            return false;
+        }
+
+        try
+        {
+            normalizedFlags = new RandomizerConfiguration(trimmedFlags).SerializeFlags();
+            return normalizedFlags == trimmedFlags;
+        }
+        catch (Exception)
+        {
+            return false;
+        }
+    }
+}
diff --git a/RandomizerCore/OutputFilenameFormatter.cs b/RandomizerCore/OutputFilenameFormatter.cs
new file mode 100644
index 00000000..09631d20
--- /dev/null
+++ b/RandomizerCore/OutputFilenameFormatter.cs
@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+
+namespace Z2Randomizer.RandomizerCore;
+
+public static class OutputFilenameFormatter
+{
+    public const string DefaultTemplate = "Z2-%f-%s-%h.nes";
+
+    // The characters Windows forbids in a filename. Linux and macOS only
+    // disallow '/' (and NUL), so honoring the Windows set produces a name that
+    // is valid on all three platforms.
+    private static readonly char[] InvalidFileNameChars =
+        ['<', '>', ':', '"', '/', '\\', '|', '?', '*'];
+
+    public static string Format(string? template, string flags, string? seed, string hash, DateTime? timestamp = null, string? version = null)
+    {
+        var resolvedTemplate = string.IsNullOrWhiteSpace(template) ? DefaultTemplate : template;
+        var resolvedTimestamp = (timestamp ?? DateTime.Now).ToString("yyyy-MM-dd-HHmm", CultureInfo.InvariantCulture);
+        var normalizedHash = string.Concat((hash ?? "").Where(c => !char.IsWhiteSpace(c)));
+
+        var formatted = resolvedTemplate
+            .Replace("%d", resolvedTimestamp, StringComparison.Ordinal)
+            .Replace("%f", flags, StringComparison.Ordinal)
+            .Replace("%s", seed ?? "", StringComparison.Ordinal)
+            .Replace("%h", normalizedHash, StringComparison.Ordinal)
+            .Replace("%v", version ?? "", StringComparison.Ordinal);
+
+        return SanitizeFileName(formatted);
+    }
+
+    // Replaces any character that wouldn't be a valid filename on Windows,
+    // Linux, or macOS so a user-supplied template can never produce a name the
+    // OS rejects.
+    public static string SanitizeFileName(string fileName)
+    {
+        var builder = new StringBuilder(fileName.Length);
+        foreach (var character in fileName)
+        {
+            var invalid = character < ' ' || Array.IndexOf(InvalidFileNameChars, character) >= 0;
+            builder.Append(invalid ? '_' : character);
+        }
+
+        // Windows rejects names that end in a space or a dot.
+        var sanitized = builder.ToString().TrimEnd(' ', '.');
+        if (sanitized.Length == 0)
+        {
+            return "_";
+        }
+
+        var dot = sanitized.IndexOf('.');
+        var baseName = dot >= 0 ? sanitized[..dot] : sanitized;
+
+        return sanitized;
+    }
+}
diff --git a/RandomizerCore/RandomizerConfiguration.cs b/RandomizerCore/RandomizerConfiguration.cs
index 9853cc6f..1803bdc6 100644
--- a/RandomizerCore/RandomizerConfiguration.cs
+++ b/RandomizerCore/RandomizerConfiguration.cs
@@ -734,6 +734,10 @@ private bool palaceStylesAnyMetastyleSelected()
     [IgnoreInFlags]
     private string spriteName;
 
+    [Reactive]
+    [IgnoreInFlags]
+    private string outputFilenameTemplate = OutputFilenameFormatter.DefaultTemplate;
+
 
     [Reactive]
     [IgnoreInFlags]
diff --git a/Tests/FlagsTests.cs b/Tests/FlagsTests.cs
index af39ddb8..2ef5017a 100644
--- a/Tests/FlagsTests.cs
+++ b/Tests/FlagsTests.cs
@@ -2,6 +2,7 @@
 using CrossPlatformUI.Presets;
 using Z2Randomizer.RandomizerCore;
 using Z2Randomizer.RandomizerCore.Flags;
+using Random = Z2Randomizer.RandomizerCore.Random;
 
 namespace Z2Randomizer.Tests;
 
@@ -237,6 +238,98 @@ public void ShareSeedAcrossDifficultyRoundTripsInFlags()
 
         Assert.IsTrue(config2.ShareSeedAcrossDifficulty);
     }
+
+    [TestMethod]
+    public void FlagPasteParserExtractsFlagsAndLongestSeedFromMessage()
+    {
+        var flags = StandardPreset.Preset.SerializeFlags();
+        var input = $"race info, seed 1234. use {flags}, tracking 001234567.";
+
+        Assert.AreEqual(flags, FlagPasteParser.ExtractFlags(input));
+        Assert.AreEqual("001234567", FlagPasteParser.ExtractSeed(input));
+    }
+
+    [TestMethod]
+    public void FlagPasteParserRejectsInvalidCharacters()
+    {
+        Assert.IsFalse(FlagPasteParser.IsValidFlagString("not-a-flag-string"));
+    }
+
+    [TestMethod]
+    public void FlagPasteParserExtractsFlagsFromSeedAndFlagsMessage()
+    {
+        const string flags = "hEAAdgKyAs6WvqAssLJidnf7xJOY+0csos1gnXRs!AAFR+h";
+        var input = $"Seed: 228401255 - Flags: {flags}";
+
+        Assert.AreEqual(flags, FlagPasteParser.ExtractFlags(input));
+        Assert.AreEqual("228401255", FlagPasteParser.ExtractSeed(input));
+    }
+
+    [TestMethod]
+    public void FlagPasteParserExtractsFlagsFromEmbeddedLabels()
+    {
+        const string flags = "hEAAdgKyAs6WvqAssLJidnf7xJOY+0csos1gnXRs!AAFR+h";
+        var input = $"Seed:228401255-Flags:{flags}";
+
+        Assert.AreEqual(flags, FlagPasteParser.ExtractFlags(input));
+        Assert.AreEqual("228401255", FlagPasteParser.ExtractSeed(input));
+    }
+
+    [TestMethod]
+    public void FlagPasteParserDoesNotExtractSeedFromPlainFlagString()
+    {
+        const string flags = "hEAAdgKyAs6WvqAssLJidnf7xJOY+0csos1gnXRs!AAFR+h";
+
+        Assert.AreEqual(flags, FlagPasteParser.ExtractFlags(flags));
+        Assert.IsNull(FlagPasteParser.ExtractSeed(flags));
+    }
+
+    [TestMethod]
+    public void FlagPasteParserRequiresDelimitedSixDigitSeedToken()
+    {
+        const string flags = "hEAAdgKyAs6WvqAssLJidnf7xJOY+0csos1gnXRs!AAFR+h";
+
+        Assert.IsNull(FlagPasteParser.ExtractSeed($"Seed: 12345 - Flags: {flags}"));
+        Assert.AreEqual("228401255", FlagPasteParser.ExtractSeed($"Seed: 228401255 - Flags: {flags}"));
+    }
+
+    [TestMethod]
+    public void OutputFilenameTemplateDefaultsAndReplacesTokens()
+    {
+        var timestamp = new DateTime(2026, 5, 31, 19, 53, 3);
+
+        var formatted = OutputFilenameFormatter.Format("%d-%f-%s-%h.nes", "FLAGS", "0123", "HA SH", timestamp);
+
+        Assert.AreEqual("2026-05-31-1953-FLAGS-0123-HASH.nes", formatted);
+        Assert.AreEqual("Z2-FLAGS-0123-HASH.nes", OutputFilenameFormatter.Format("", "FLAGS", "0123", "HASH", timestamp));
+    }
+
+    [TestMethod]
+    public void OutputFilenameSanitizesCharactersInvalidOnAnyPlatform()
+    {
+        var formatted = OutputFilenameFormatter.Format("%f:%s?.nes", "FL/AGS", "0*123", "HASH");
+
+        Assert.AreEqual("FL_AGS_0_123_.nes", formatted);
+    }
+
+    [TestMethod]
+    public void OutputFilenameTemplateReplacesVersionToken()
+    {
+        var formatted = OutputFilenameFormatter.Format("Z2-%v-%s.nes", "FLAGS", "0123", "HASH", version: "5.1.4");
+
+        Assert.AreEqual("Z2-5.1.4-0123.nes", formatted);
+    }
+
+    [TestMethod]
+    public void OutputFilenameTemplateIsIgnoredByFlags()
+    {
+        RandomizerConfiguration config = new();
+        var originalFlags = config.SerializeFlags();
+
+        config.OutputFilenameTemplate = "custom-%s-%h.nes";
+
+        Assert.AreEqual(originalFlags, config.SerializeFlags());
+    }
   
     public void TestSgl2025EncodeCycle()
     {