Merge feat/opengl-vulkan: settings for the OpenGL 4.6 and Vulkan 1.4 simulator

A transitional variant, since the exe a player runs may not have the new renderers. The old renderers stay in the list and the old keys are still written next to the new ones. A new exe without Vulkan starts OpenGL by itself, an old one reads the word as its legacy renderer, and both pass over the keys they do not know. Taken from Hirek193's branch: - the new keys as rows of a section of their own, with their texts - their values on the graphics levels, in steps over the six levels here, with High as what the simulator does with nothing set - Vulkan 1.4 in the list of renderers, and its own keys marked as idle without it - gfx.buffer.percent next to the old buffer keys, read before them - gfx.antialiasing saved below multisampling, for the later line to count Keys checked against feat/gl46-migration of the simulator. Left out, as this branch has its own or does not need them: the rewritten settings page and its five levels, GraphicsRules, the DLSS library check, eu07.ini import and export, and the removal of the old renderers.
2026-11-02 12:49:12 +01:00 · 2026-11-01 19:43:46 +01:00
parent 212e11278f f8617942ea
commit b60c176533
20 changed files with 913 additions and 25 deletions
--- a/StarterNG.Tests/ConfigFileTests.cs
+++ b/StarterNG.Tests/ConfigFileTests.cs
@@ -17,6 +17,31 @@ public class ConfigFileTests
        Assert.Equal($"a 1{nl}b 2{nl}", ConfigFile.Parse("a 1\r\nb 2\r\n").ToText());
    }

+    [Fact]
+    public void A_line_above_another_moves_right_below_it()
+    {
+        var config = ConfigFile.Parse("gfx.antialiasing taa\nwidth 800\nmultisampling 2\nheight 600\n");
+
+        config.MoveAfter("gfx.antialiasing", "multisampling");
+
+        Assert.Equal(new[] { "width 800", "multisampling 2", "gfx.antialiasing taa", "height 600", "" }, Lines(config));
+        Assert.Equal("taa", config.GetRaw("gfx.antialiasing"));
+        Assert.Equal("600", config.GetRaw("height"));
+    }
+
+    [Theory]
+    [InlineData("multisampling 2\nwidth 800\ngfx.antialiasing taa\n")]
+    [InlineData("multisampling 2\n")]
+    [InlineData("gfx.antialiasing taa\n")]
+    public void A_line_below_or_alone_stays_where_it_is(string text)
+    {
+        var config = ConfigFile.Parse(text);
+
+        config.MoveAfter("gfx.antialiasing", "multisampling");
+
+        Assert.Equal(ConfigFile.Parse(text).ToText(), config.ToText());
+    }
+
    [Fact]
    public void Removing_a_key_comments_every_line_that_sets_it()
    {
--- a/StarterNG.Tests/GraphicsPresetTests.cs
+++ b/StarterNG.Tests/GraphicsPresetTests.cs
@@ -33,7 +33,7 @@ public class GraphicsPresetTests
        var topKeys = store.Render(top);
        var differing = lowKeys.Keys.Union(topKeys.Keys)
            .Where(key => lowKeys.GetValueOrDefault(key) != topKeys.GetValueOrDefault(key))
-            .Where(key => !key.StartsWith("gfx.framebuffer", StringComparison.Ordinal));
+            .Where(key => !key.StartsWith("gfx.framebuffer", StringComparison.Ordinal) && key != "gfx.buffer.percent");

        Assert.Equal(GraphicsPreset.Keys.OrderBy(k => k), differing.OrderBy(k => k));
    }
@@ -103,7 +103,7 @@ public class GraphicsPresetTests
        var differing = own.Keys.Union(high.Keys)
            .Where(key => own.GetValueOrDefault(key) != high.GetValueOrDefault(key))
            .Where(key => !GraphicsPreset.RowKeys.Contains(key))
-            .Where(key => !key.StartsWith("gfx.framebuffer", StringComparison.Ordinal));
+            .Where(key => !key.StartsWith("gfx.framebuffer", StringComparison.Ordinal) && key != "gfx.buffer.percent");

        Assert.Equal(new[] { "gfx.reflections.fidelity", "gfx.reflections.framerate", "gfx.shadows.cab.range",
                             "gfx.smoke.fidelity", "splinefidelity" }, differing.OrderBy(k => k));
@@ -144,6 +144,113 @@ public class GraphicsPresetTests
        Assert.Same(GraphicsPreset.Low, GraphicsPreset.Matching(again.Settings));
    }

+    [Fact]
+    public void High_is_what_the_new_simulator_does_with_nothing_set()
+    {
+        Assert.Equal(GraphicsPreset.High.NewRenderer, GraphicsNewRenderer.Of(Defaults()));
+    }
+
+    [Fact]
+    public void The_new_renderers_scales_never_go_down()
+    {
+        void WordsClimb(string name, Func<GraphicsNewRenderer, string> word)
+        {
+            var words = SimulatorKeys.Named(name).Words!;
+            var places = GraphicsPreset.All.Select(p => Array.IndexOf(words, word(p.NewRenderer))).ToList();
+            Assert.DoesNotContain(-1, places);
+            Assert.Equal(places.OrderBy(place => place), places);
+        }
+
+        void TurnsOn(Func<GraphicsNewRenderer, bool> on)
+        {
+            var values = GraphicsPreset.All.Select(p => on(p.NewRenderer)).ToList();
+            Assert.Equal(values.OrderBy(value => value), values);
+        }
+
+        WordsClimb("gfx.lights.shadows", r => r.LampShadows);
+        WordsClimb("gfx.contactshadows", r => r.ContactShadows);
+        WordsClimb("gfx.postfx.ao", r => r.Occlusion);
+        WordsClimb("gfx.postfx.ao.quality", r => r.OcclusionQuality);
+        WordsClimb("gfx.cabprobe", r => r.CabProbe);
+        WordsClimb("gfx.ssr", r => r.ScreenReflections);
+        WordsClimb("gfx.fog", r => r.Fog);
+        WordsClimb("gfx.fog.quality", r => r.FogQuality);
+        WordsClimb("gfx.clouds", r => r.Clouds);
+
+        TurnsOn(r => r.OcclusionLighting);
+        TurnsOn(r => r.CabProbeReflections);
+        TurnsOn(r => r.RayTracing);
+        TurnsOn(r => r.CloudShadows);
+        TurnsOn(r => r.Grass);
+        TurnsOn(r => r.Bloom);
+
+        Climbs(p => p.NewRenderer.GrassDistance, 0);
+        Climbs(p => p.NewRenderer.GrassFade, 0);
+        Climbs(p => p.NewRenderer.GrassDensity, 0);
+        Climbs(p => p.NewRenderer.Precipitation, 0);
+        // Frames between refreshes, so the dearer the fewer.
+        Climbs(p => -p.NewRenderer.CabProbeInterval, 2);
+    }
+
+    [Fact]
+    public void Ultra_is_the_top_of_the_new_renderers_scales()
+    {
+        var ultra = GraphicsPreset.Ultra.NewRenderer;
+        double Top(string key) => SimulatorKeys.Named(key).Maximum;
+        string TopWord(string key) => SimulatorKeys.Named(key).Words!.Last();
+
+        Assert.Equal(TopWord("gfx.lights.shadows"), ultra.LampShadows);
+        Assert.Equal(TopWord("gfx.contactshadows"), ultra.ContactShadows);
+        Assert.Equal(TopWord("gfx.postfx.ao"), ultra.Occlusion);
+        Assert.Equal(TopWord("gfx.postfx.ao.quality"), ultra.OcclusionQuality);
+        Assert.Equal(TopWord("gfx.cabprobe"), ultra.CabProbe);
+        Assert.Equal(TopWord("gfx.ssr"), ultra.ScreenReflections);
+        Assert.Equal(TopWord("gfx.fog"), ultra.Fog);
+        Assert.Equal(TopWord("gfx.fog.quality"), ultra.FogQuality);
+        Assert.Equal(TopWord("gfx.clouds"), ultra.Clouds);
+        Assert.Equal(Top("gfx.grass.distance"), ultra.GrassDistance);
+        Assert.Equal(Top("gfx.grass.fadedistance"), ultra.GrassFade);
+        Assert.Equal(Top("gfx.grass.density"), ultra.GrassDensity);
+        Assert.Equal(Top("gfx.precipitation.particles"), ultra.Precipitation);
+    }
+
+    [Fact]
+    public void Grass_fades_out_beyond_where_it_is_drawn_in_full()
+    {
+        Assert.All(GraphicsPreset.All, p => Assert.True(p.NewRenderer.GrassFade > p.NewRenderer.GrassDistance, p.NameKey));
+    }
+
+    [Fact]
+    public void A_level_set_in_the_new_renderers_rows_is_told_from_the_others()
+    {
+        var settings = Defaults().Copy();
+        GraphicsPreset.Medium.ApplyTo(settings);
+        Assert.Same(GraphicsPreset.Medium, GraphicsPreset.Matching(settings));
+
+        settings.Extra["gfx.fog.quality"] = "ultra";
+
+        Assert.Null(GraphicsPreset.Matching(settings));
+    }
+
+    [Fact]
+    public void What_is_left_to_the_player_stays_through_a_level()
+    {
+        var settings = Defaults().Copy();
+        settings.Extra["gfx.antialiasing"] = "taa";
+        settings.Extra["gfx.framegeneration"] = "x2";
+        settings.Extra["gfx.vulkan.device"] = "RTX";
+
+        foreach (var preset in GraphicsPreset.All)
+        {
+            preset.ApplyTo(settings);
+
+            Assert.Same(preset, GraphicsPreset.Matching(settings));
+            Assert.Equal("taa", settings.Extra["gfx.antialiasing"]);
+            Assert.Equal("x2", settings.Extra["gfx.framegeneration"]);
+            Assert.Equal("RTX", settings.Extra["gfx.vulkan.device"]);
+        }
+    }
+
    [Fact]
    public void Ultra_is_the_top_of_everything_the_screen_offers()
    {
@@ -503,6 +610,11 @@ public class GraphicsPresetTests
            OnSteps(preset.SleeperDistance, GraphicsPreset.SleeperKey);
            OnSteps(preset.ReflectedInstances, GraphicsPreset.ReflectedInstancesKey);
            OnSteps(preset.ReflectedVehicles, GraphicsPreset.ReflectedVehiclesKey);
+            OnSteps(preset.NewRenderer.CabProbeInterval, "gfx.cabprobe.interval");
+            OnSteps(preset.NewRenderer.GrassDistance, "gfx.grass.distance");
+            OnSteps(preset.NewRenderer.GrassFade, "gfx.grass.fadedistance");
+            OnSteps(preset.NewRenderer.GrassDensity, "gfx.grass.density");
+            OnSteps(preset.NewRenderer.Precipitation, "gfx.precipitation.particles");
            Assert.True(Steps.IndexOf(Steps.Anisotropy, preset.Anisotropy) >= 0, preset.NameKey);
            Assert.True(Steps.IndexOf(Steps.MultisamplingLevels, preset.Multisampling) >= 0, preset.NameKey);
            Assert.True(Steps.IndexOf(Steps.ReflectionUpdates, preset.ReflectionsRate) >= 0, preset.NameKey);
--- a/StarterNG.Tests/SettingReachTests.cs
+++ b/StarterNG.Tests/SettingReachTests.cs
@@ -72,6 +72,32 @@ public class SettingReachTests
        Assert.Equal(expected, SettingReach.Why("sleeperdistance", Linux(renderer)));
    }

+    [Theory]
+    [InlineData("vulkan", IdleReason.None)]
+    [InlineData("vulkan14", IdleReason.None)]
+    [InlineData("full", IdleReason.VulkanOnly)]
+    [InlineData("gl46", IdleReason.VulkanOnly)]
+    [InlineData("legacy", IdleReason.VulkanOnly)]
+    public void What_only_vulkan_reads_follows_the_renderer(string renderer, IdleReason expected)
+    {
+        Assert.Equal(expected, SettingReach.Why("gfx.dlss.preset", Linux(renderer)));
+        Assert.Equal(expected, SettingReach.Why("gfx.framegeneration", Linux(renderer)));
+        Assert.Equal(expected, SettingReach.Why("gfx.raytracing", Linux(renderer)));
+        // Both renderers of the new simulator read this one.
+        Assert.Equal(IdleReason.None, SettingReach.Why("gfx.postfx.ao", Linux(renderer)));
+    }
+
+    [Theory]
+    [InlineData("vulkan")]
+    [InlineData("vulkan14")]
+    [InlineData("opengl")]
+    [InlineData("gl46")]
+    public void The_new_simulators_renderers_read_what_the_full_one_does(string renderer)
+    {
+        Assert.Equal(IdleReason.None, SettingReach.Why("gfx.envmap.enabled", Linux(renderer)));
+        Assert.Equal(IdleReason.None, SettingReach.Why("multisampling", Linux(renderer)));
+    }
+
    [Theory]
    [InlineData("full", IdleReason.None)]
    [InlineData("legacy", IdleReason.None)]
--- a/StarterNG.Tests/SettingsStoreTests.cs
+++ b/StarterNG.Tests/SettingsStoreTests.cs
@@ -858,6 +858,9 @@ public class SettingsStoreTests
    [InlineData("default")]
    [InlineData("simpleshader")]
    [InlineData("off")]
+    [InlineData("opengl")]
+    [InlineData("gl46")]
+    [InlineData("vulkan14")]
    public void A_renderer_word_the_simulator_reads_as_another_stays_until_changed(string word)
    {
        var installation = WithHome(new InMemoryFileSystem().WithFile(UserIni, $"gfxrenderer {word}\n"));
@@ -873,6 +876,7 @@ public class SettingsStoreTests
    [InlineData(1, "legacy")]
    [InlineData(2, "simple")]
    [InlineData(3, "experimental")]
+    [InlineData(4, "vulkan")]
    public void A_chosen_renderer_is_saved_as_the_simulator_reads_it(int engine, string saved)
    {
        // application.cpp knows full (or default), experimental and simple; every
@@ -888,6 +892,92 @@ public class SettingsStoreTests
        Assert.Contains($"gfxrenderer {saved}\n", SavedLines(installation));
    }

+    [Theory]
+    [InlineData("full", 0)]
+    [InlineData("gl46", 0)]
+    [InlineData("opengl", 0)]
+    [InlineData("vulkan", 4)]
+    [InlineData("VULKAN14", 4)]
+    [InlineData("simpleshader", 1)]
+    public void A_renderer_word_stands_where_the_simulator_reads_it(string word, int engine)
+    {
+        Assert.Equal(engine, SimulatorSettings.RenderEngineOf(word));
+    }
+
+    [Fact]
+    public void The_buffer_is_written_for_old_and_new_simulators()
+    {
+        var installation = WithHome(new InMemoryFileSystem().WithFile(UserIni, "width 1000\nheight 500\n"));
+        installation.SettingsStore.Load();
+        installation.SettingsStore.Settings.BufferScalePercent = 50;
+
+        installation.SettingsStore.Save();
+
+        string saved = SavedLines(installation);
+        Assert.Contains("gfx.buffer.percent 50\n", saved);
+        Assert.Contains("gfx.framebuffer.width 500\n", saved);
+        Assert.Contains("gfx.framebuffer.height 250\n", saved);
+    }
+
+    [Theory]
+    [InlineData("gfx.buffer.percent 0.5\n", 50)]
+    [InlineData("gfx.buffer.percent 75\n", 75)]
+    [InlineData("gfx.buffer.percent 10\n", 25)]
+    [InlineData("gfx.buffer.percent 300\n", 200)]
+    [InlineData("starter.bufferscale 60\n", 60)]
+    [InlineData("starter.bufferscale 60\ngfx.buffer.percent 80\n", 80)]
+    public void The_buffer_is_read_from_the_key_the_new_simulator_goes_by(string ini, int percent)
+    {
+        var installation = WithHome(new InMemoryFileSystem().WithFile(UserIni, ini));
+
+        installation.SettingsStore.Load();
+
+        Assert.Equal(percent, installation.SettingsStore.Settings.BufferScalePercent);
+    }
+
+    [Fact]
+    public void Anti_aliasing_is_saved_below_multisampling_for_the_later_line_to_count()
+    {
+        var installation = WithHome(new InMemoryFileSystem().WithFile(UserIni, "gfx.antialiasing taa\nwidth 800\nmultisampling 2\n"));
+        installation.SettingsStore.Load();
+
+        installation.SettingsStore.Save();
+
+        string saved = SavedLines(installation);
+        Assert.True(saved.IndexOf("multisampling ", StringComparison.Ordinal) < saved.IndexOf("gfx.antialiasing taa", StringComparison.Ordinal), saved);
+    }
+
+    [Fact]
+    public void Anti_aliasing_left_to_multisampling_goes_from_the_file()
+    {
+        var installation = WithHome(new InMemoryFileSystem().WithFile(UserIni, "multisampling 2\ngfx.antialiasing taa\n"));
+        installation.SettingsStore.Load();
+
+        installation.SettingsStore.Settings.Extra["gfx.antialiasing"] = "";
+        installation.SettingsStore.Save();
+
+        Assert.DoesNotContain("\ngfx.antialiasing", SavedLines(installation));
+    }
+
+    [Theory]
+    [InlineData("TAA", "taa")]
+    [InlineData("  dlaa ", "dlaa")]
+    [InlineData("", "")]
+    [InlineData("fxaa", "")]
+    public void A_choice_reads_the_words_it_offers_and_else_the_default(string raw, string word)
+    {
+        Assert.Equal(word, SimulatorKeys.Named("gfx.antialiasing").ParseChoice(raw));
+    }
+
+    [Theory]
+    [InlineData("4 6", "4 6")]
+    [InlineData("4   6", "4 6")]
+    [InlineData("5 5", "3 4")]
+    public void A_choice_of_two_numbers_is_one_word(string raw, string word)
+    {
+        Assert.Equal(word, SimulatorKeys.Named("gfx.postfx.ao.quality").ParseChoice(raw));
+    }
+
    [Fact]
    public void A_field_of_view_down_to_ten_degrees_survives_a_save()
    {
--- a/StarterNG/Application/SettingsStore.cs
+++ b/StarterNG/Application/SettingsStore.cs
@@ -164,6 +164,8 @@ public sealed class SettingsStore
            else
                _config.Set(change.Key, change.After);
        }
+        // Each sets the mode as the simulator reads it, so this one has to come later to count.
+        _config.MoveAfter("gfx.antialiasing", "multisampling");
        _synced = Render(Settings);

        try
--- a/StarterNG/Classes/ConfigFile.cs
+++ b/StarterNG/Classes/ConfigFile.cs
@@ -161,6 +161,21 @@ public sealed class ConfigFile
        Reindex();
    }

+    /// <summary>
+    /// Puts the line of <paramref name="key"/> right below that of <paramref name="anchor"/> when
+    /// it is above it, for keys of which the simulator, reading top down, heeds the later.
+    /// </summary>
+    public void MoveAfter(string key, string anchor)
+    {
+        if (!_index.TryGetValue(key, out int from) || !_index.TryGetValue(anchor, out int to) || from > to)
+            return;
+
+        string line = _lines[from];
+        _lines.RemoveAt(from);
+        _lines.Insert(to, line);
+        Reindex();
+    }
+
    /// <summary>Comments out every line setting the key: the last one alone would bring the one before it back.</summary>
    public void Remove(string key)
    {
--- a/StarterNG/Domain/Settings/GraphicsPreset.cs
+++ b/StarterNG/Domain/Settings/GraphicsPreset.cs
@@ -119,6 +119,107 @@ public sealed record GraphicsTop(
    }
 }

+/// <summary>
+/// What only the simulators with the OpenGL 4.6 and Vulkan 1.4 renderers read, the others pass it
+/// over. High is what they do with nothing set. Left to the player: anti-aliasing by TAA or DLSS,
+/// frame generation, Reflex, the choice of the card, automatic exposure and the fitted cascades.
+/// </summary>
+/// <param name="CabProbeInterval">gfx.cabprobe.interval, in frames: the lower the dearer.</param>
+/// <param name="RayTracing">gfx.raytracing: the Vulkan renderer's alone, OpenGL passes it over.</param>
+public sealed record GraphicsNewRenderer(
+    string LampShadows,
+    string ContactShadows,
+    string Occlusion,
+    string OcclusionQuality,
+    bool OcclusionLighting,
+    string CabProbe,
+    double CabProbeInterval,
+    bool CabProbeReflections,
+    string ScreenReflections,
+    bool RayTracing,
+    string Fog,
+    string FogQuality,
+    string Clouds,
+    bool CloudShadows,
+    bool Grass,
+    double GrassDistance,
+    double GrassFade,
+    double GrassDensity,
+    double Precipitation,
+    bool Bloom)
+{
+    private const string LampShadowsKey = "gfx.lights.shadows";
+    private const string ContactShadowsKey = "gfx.contactshadows";
+    private const string OcclusionKey = "gfx.postfx.ao";
+    private const string OcclusionQualityKey = "gfx.postfx.ao.quality";
+    private const string OcclusionLightingKey = "gfx.postfx.ao.lighting";
+    private const string CabProbeKey = "gfx.cabprobe";
+    private const string CabProbeIntervalKey = "gfx.cabprobe.interval";
+    private const string CabProbeReflectionsKey = "gfx.cabprobe.reflections";
+    private const string ScreenReflectionsKey = "gfx.ssr";
+    private const string RayTracingKey = "gfx.raytracing";
+    private const string FogKey = "gfx.fog";
+    private const string FogQualityKey = "gfx.fog.quality";
+    private const string CloudsKey = "gfx.clouds";
+    private const string CloudShadowsKey = "gfx.clouds.shadows";
+    private const string GrassKey = "gfx.grass";
+    private const string GrassDistanceKey = "gfx.grass.distance";
+    private const string GrassFadeKey = "gfx.grass.fadedistance";
+    private const string GrassDensityKey = "gfx.grass.density";
+    private const string PrecipitationKey = "gfx.precipitation.particles";
+    private const string BloomKey = "gfx.postfx.bloom";
+
+    /// <summary>The eu07.ini keys these values live in, all of them rows of <see cref="SimulatorKeys"/>.</summary>
+    public static readonly IReadOnlyList<string> Keys = new[]
+    {
+        LampShadowsKey, ContactShadowsKey, OcclusionKey, OcclusionQualityKey, OcclusionLightingKey,
+        CabProbeKey, CabProbeIntervalKey, CabProbeReflectionsKey, ScreenReflectionsKey, RayTracingKey,
+        FogKey, FogQualityKey, CloudsKey, CloudShadowsKey,
+        GrassKey, GrassDistanceKey, GrassFadeKey, GrassDensityKey, PrecipitationKey, BloomKey
+    };
+
+    public static GraphicsNewRenderer Of(SimulatorSettings s) =>
+        new(WordOf(s, LampShadowsKey), WordOf(s, ContactShadowsKey), WordOf(s, OcclusionKey), WordOf(s, OcclusionQualityKey),
+            GraphicsPreset.ToggleOf(s, OcclusionLightingKey), WordOf(s, CabProbeKey), GraphicsPreset.NumberOf(s, CabProbeIntervalKey),
+            GraphicsPreset.ToggleOf(s, CabProbeReflectionsKey), WordOf(s, ScreenReflectionsKey), GraphicsPreset.ToggleOf(s, RayTracingKey),
+            WordOf(s, FogKey), WordOf(s, FogQualityKey), WordOf(s, CloudsKey), GraphicsPreset.ToggleOf(s, CloudShadowsKey),
+            GraphicsPreset.ToggleOf(s, GrassKey), GraphicsPreset.NumberOf(s, GrassDistanceKey), GraphicsPreset.NumberOf(s, GrassFadeKey),
+            GraphicsPreset.NumberOf(s, GrassDensityKey), GraphicsPreset.NumberOf(s, PrecipitationKey), GraphicsPreset.ToggleOf(s, BloomKey));
+
+    public void ApplyTo(SimulatorSettings s)
+    {
+        void Number(string key, double value) => s.Extra[key] = value.ToString(CultureInfo.InvariantCulture);
+        void Toggle(string key, bool value) => s.Extra[key] = SimulatorKey.FormatToggle(value);
+
+        s.Extra[LampShadowsKey] = LampShadows;
+        s.Extra[ContactShadowsKey] = ContactShadows;
+        s.Extra[OcclusionKey] = Occlusion;
+        s.Extra[OcclusionQualityKey] = OcclusionQuality;
+        Toggle(OcclusionLightingKey, OcclusionLighting);
+        s.Extra[CabProbeKey] = CabProbe;
+        Number(CabProbeIntervalKey, CabProbeInterval);
+        Toggle(CabProbeReflectionsKey, CabProbeReflections);
+        s.Extra[ScreenReflectionsKey] = ScreenReflections;
+        Toggle(RayTracingKey, RayTracing);
+        s.Extra[FogKey] = Fog;
+        s.Extra[FogQualityKey] = FogQuality;
+        s.Extra[CloudsKey] = Clouds;
+        Toggle(CloudShadowsKey, CloudShadows);
+        Toggle(GrassKey, Grass);
+        Number(GrassDistanceKey, GrassDistance);
+        Number(GrassFadeKey, GrassFade);
+        Number(GrassDensityKey, GrassDensity);
+        Number(PrecipitationKey, Precipitation);
+        Toggle(BloomKey, Bloom);
+    }
+
+    private static string WordOf(SimulatorSettings s, string name)
+    {
+        var key = SimulatorKeys.Named(name);
+        return key.ParseChoice(key.RawIn(s));
+    }
+}
+
 /// <summary>
 /// A level of detail set in one go: what weighs on the graphics card. Every scale climbs in
 /// even steps from <see cref="Minimal"/> to <see cref="Ultra"/>, as far as it has steps for six
@@ -161,6 +262,7 @@ public sealed record GraphicsPreset(
    double ReflectedInstances,
    double ReflectedVehicles,
    int CabShadowsRange,
+    GraphicsNewRenderer NewRenderer,
    GraphicsExtras? Extras = null,
    GraphicsTop? Top = null)
 {
@@ -174,7 +276,7 @@ public sealed record GraphicsPreset(
    public static readonly IReadOnlyList<string> RowKeys = new[]
    {
        DrawRangeKey, DistanceFactorKey, SleeperKey, ReflectedInstancesKey, ReflectedVehiclesKey
-    };
+    }.Concat(GraphicsNewRenderer.Keys).ToList();

    /// <summary>The eu07.ini keys a level sets.</summary>
    public static readonly IReadOnlyList<string> Keys = new[]
@@ -184,7 +286,7 @@ public sealed record GraphicsPreset(
        "gfx.envmap.enabled", "gfx.reflections.fidelity", "gfx.reflections.framerate", "gfx.extraeffects",
        "splinefidelity", DrawRangeKey, DistanceFactorKey, "starter.bufferscale", SleeperKey,
        "gfx.drawrange.factor.max", ReflectedInstancesKey, ReflectedVehiclesKey, "gfx.shadows.cab.range"
-    };
+    }.Concat(GraphicsNewRenderer.Keys).ToList();

    /// <summary>The last resort: no shadows, no reflections, no effects, no smoke, a softer picture.</summary>
    public static readonly GraphicsPreset Minimal = new(
@@ -193,6 +295,10 @@ public sealed record GraphicsPreset(
        EnvMap: false, ReflectionsFidelity: 0, ReflectionsRate: 1 / 300.0, ExtraEffects: false,
        SplineFidelity: 1, DrawRange: 2000, DistanceFactor: 0.6, BufferScale: 70,
        SleeperDistance: 100, DrawRangeFactor: 1, ReflectedInstances: 250, ReflectedVehicles: 50, CabShadowsRange: 0,
+        NewRenderer: new GraphicsNewRenderer(LampShadows: "no", ContactShadows: "no", Occlusion: "no", OcclusionQuality: "3 4",
+            OcclusionLighting: false, CabProbe: "no", CabProbeInterval: 8, CabProbeReflections: false, ScreenReflections: "no",
+            RayTracing: false, Fog: "analytic", FogQuality: "low", Clouds: "no", CloudShadows: false, Grass: false,
+            GrassDistance: 30, GrassFade: 40, GrassDensity: 0.25, Precipitation: 16384, Bloom: false),
        Extras: new GraphicsExtras(MotionBlur: false, ChromaticAberration: false, Smoke: false, PythonUpdateMs: 800));

    public static readonly GraphicsPreset Low = new(
@@ -200,14 +306,22 @@ public sealed record GraphicsPreset(
        DynamicLights: 3, SmokeFidelity: 1, Shadows: true, ShadowMap: 1024, ShadowRange: 125, ShadowRank: 2,
        EnvMap: true, ReflectionsFidelity: 0, ReflectionsRate: 1 / 60.0, ExtraEffects: true,
        SplineFidelity: 1, DrawRange: 2000, DistanceFactor: 0.7, BufferScale: 80,
-        SleeperDistance: 150, DrawRangeFactor: 1.5, ReflectedInstances: 400, ReflectedVehicles: 100, CabShadowsRange: 0);
+        SleeperDistance: 150, DrawRangeFactor: 1.5, ReflectedInstances: 400, ReflectedVehicles: 100, CabShadowsRange: 0,
+        NewRenderer: new GraphicsNewRenderer(LampShadows: "low", ContactShadows: "no", Occlusion: "ssao", OcclusionQuality: "3 4",
+            OcclusionLighting: false, CabProbe: "no", CabProbeInterval: 8, CabProbeReflections: false, ScreenReflections: "low",
+            RayTracing: false, Fog: "volumetric", FogQuality: "low", Clouds: "low", CloudShadows: false, Grass: true,
+            GrassDistance: 40, GrassFade: 50, GrassDensity: 0.5, Precipitation: 32768, Bloom: true));

    public static readonly GraphicsPreset Medium = new(
        "PresetMedium", TextureSize: 2048, CabTextureSize: 2048, Anisotropy: 4, Multisampling: 1,
        DynamicLights: 5, SmokeFidelity: 2, Shadows: true, ShadowMap: 1024, ShadowRange: 175, ShadowRank: 2,
        EnvMap: true, ReflectionsFidelity: 1, ReflectionsRate: 1 / 30.0, ExtraEffects: true,
        SplineFidelity: 2, DrawRange: 2250, DistanceFactor: 0.85, BufferScale: 90,
-        SleeperDistance: 200, DrawRangeFactor: 2, ReflectedInstances: 550, ReflectedVehicles: 150, CabShadowsRange: 20);
+        SleeperDistance: 200, DrawRangeFactor: 2, ReflectedInstances: 550, ReflectedVehicles: 150, CabShadowsRange: 20,
+        NewRenderer: new GraphicsNewRenderer(LampShadows: "low", ContactShadows: "no", Occlusion: "ssao", OcclusionQuality: "3 4",
+            OcclusionLighting: false, CabProbe: "low", CabProbeInterval: 8, CabProbeReflections: true, ScreenReflections: "low",
+            RayTracing: false, Fog: "volumetric", FogQuality: "low", Clouds: "low", CloudShadows: true, Grass: true,
+            GrassDistance: 50, GrassFade: 60, GrassDensity: 0.75, Precipitation: 49152, Bloom: true));

    /// <summary>
    /// Where a player with no settings of their own starts. The simulator's own values (Globals.h),
@@ -219,7 +333,11 @@ public sealed record GraphicsPreset(
        DynamicLights: 7, SmokeFidelity: 2, Shadows: true, ShadowMap: 2048, ShadowRange: 250, ShadowRank: 3,
        EnvMap: true, ReflectionsFidelity: 1, ReflectionsRate: 0.1, ExtraEffects: true,
        SplineFidelity: 2, DrawRange: 2500, DistanceFactor: 1, BufferScale: 100,
-        SleeperDistance: 250, DrawRangeFactor: 3, ReflectedInstances: 750, ReflectedVehicles: 250, CabShadowsRange: 40);
+        SleeperDistance: 250, DrawRangeFactor: 3, ReflectedInstances: 750, ReflectedVehicles: 250, CabShadowsRange: 40,
+        NewRenderer: new GraphicsNewRenderer(LampShadows: "medium", ContactShadows: "no", Occlusion: "gtao", OcclusionQuality: "3 4",
+            OcclusionLighting: true, CabProbe: "medium", CabProbeInterval: 4, CabProbeReflections: true, ScreenReflections: "medium",
+            RayTracing: false, Fog: "volumetric", FogQuality: "medium", Clouds: "medium", CloudShadows: true, Grass: true,
+            GrassDistance: 60, GrassFade: 70, GrassDensity: 1, Precipitation: 65536, Bloom: true));

    /// <summary>For a strong card. A map of 4096 doubles the cascades, so the range here reaches 800 m.</summary>
    public static readonly GraphicsPreset VeryHigh = new(
@@ -227,7 +345,11 @@ public sealed record GraphicsPreset(
        DynamicLights: 7, SmokeFidelity: 3, Shadows: true, ShadowMap: 4096, ShadowRange: 400, ShadowRank: 3,
        EnvMap: true, ReflectionsFidelity: 2, ReflectionsRate: 2, ExtraEffects: true,
        SplineFidelity: 3, DrawRange: 5000, DistanceFactor: 2, BufferScale: 150,
-        SleeperDistance: 2000, DrawRangeFactor: 3, ReflectedInstances: 1500, ReflectedVehicles: 1000, CabShadowsRange: 70);
+        SleeperDistance: 2000, DrawRangeFactor: 3, ReflectedInstances: 1500, ReflectedVehicles: 1000, CabShadowsRange: 70,
+        NewRenderer: new GraphicsNewRenderer(LampShadows: "high", ContactShadows: "medium", Occlusion: "gtao", OcclusionQuality: "4 6",
+            OcclusionLighting: true, CabProbe: "high", CabProbeInterval: 3, CabProbeReflections: true, ScreenReflections: "high",
+            RayTracing: false, Fog: "volumetric", FogQuality: "high", Clouds: "high", CloudShadows: true, Grass: true,
+            GrassDistance: 120, GrassFade: 140, GrassDensity: 1.5, Precipitation: 98304, Bloom: true));

    /// <summary>
    /// Every value at the top of what the screen offers. Not the best picture throughout: a map
@@ -240,6 +362,10 @@ public sealed record GraphicsPreset(
        EnvMap: true, ReflectionsFidelity: 2, ReflectionsRate: 60, ExtraEffects: true,
        SplineFidelity: 4, DrawRange: 10000, DistanceFactor: 3, BufferScale: 200,
        SleeperDistance: 5000, DrawRangeFactor: 3, ReflectedInstances: 3000, ReflectedVehicles: 2000, CabShadowsRange: 100,
+        NewRenderer: new GraphicsNewRenderer(LampShadows: "high", ContactShadows: "high", Occlusion: "gtao", OcclusionQuality: "6 8",
+            OcclusionLighting: true, CabProbe: "high", CabProbeInterval: 2, CabProbeReflections: true, ScreenReflections: "high",
+            RayTracing: true, Fog: "volumetric", FogQuality: "ultra", Clouds: "ultra", CloudShadows: true, Grass: true,
+            GrassDistance: 300, GrassFade: 350, GrassDensity: 2, Precipitation: 131072, Bloom: true),
        Extras: new GraphicsExtras(MotionBlur: true, ChromaticAberration: true, Smoke: true, PythonUpdateMs: 200),
        Top: new GraphicsTop(ShadowAngleLimit: 0.2, TargetFps: 0, ScreenWindowFps: 200, TextureRelease: 0,
                             Screens: true, ScreenMipmaps: true, CompressTextures: false, SkipDecor: false,
@@ -272,6 +398,7 @@ public sealed record GraphicsPreset(
        s.Extra[ReflectedInstancesKey] = ReflectedInstances.ToString(CultureInfo.InvariantCulture);
        s.Extra[ReflectedVehiclesKey] = ReflectedVehicles.ToString(CultureInfo.InvariantCulture);
        s.CabShadowsRange = CabShadowsRange;
+        NewRenderer.ApplyTo(s);
        Extras?.ApplyTo(s);
        Top?.ApplyTo(s);
    }
@@ -292,6 +419,7 @@ public sealed record GraphicsPreset(
        Near(NumberOf(s, ReflectedInstancesKey), ReflectedInstances) &&
        Near(NumberOf(s, ReflectedVehiclesKey), ReflectedVehicles) &&
        s.CabShadowsRange == CabShadowsRange &&
+        GraphicsNewRenderer.Of(s) == NewRenderer &&
        (Extras is null || GraphicsExtras.Of(s) == Extras) &&
        (Top is null || GraphicsTop.Of(s) == Top);

@@ -349,7 +477,9 @@ public sealed record GraphicsGroup(IReadOnlyList<string> Keys)
        GraphicsPreset.ReflectedInstancesKey, GraphicsPreset.ReflectedVehiclesKey
    });

-    public static readonly IReadOnlyList<GraphicsGroup> All = new[] { DrawRange, Textures, Effects, Shadows, Reflections };
+    public static readonly GraphicsGroup NewRenderer = new(GraphicsNewRenderer.Keys);
+
+    public static readonly IReadOnlyList<GraphicsGroup> All = new[] { DrawRange, Textures, Effects, Shadows, Reflections, NewRenderer };
 }

 /// <summary>What applying a level touched.</summary>
--- a/StarterNG/Domain/Settings/SettingReach.cs
+++ b/StarterNG/Domain/Settings/SettingReach.cs
@@ -17,7 +17,8 @@ public enum IdleReason
    /// <summary>The draw range is only stretched by the frame rate regulator, which is off.</summary>
    NeedsFrameRateTarget,
    /// <summary>fullscreenwindowed takes the monitor's own mode instead.</summary>
-    MonitorModeInstead
+    MonitorModeInstead,
+    VulkanOnly
 }

 /// <summary>What about the simulator to be started decides which keys it heeds.</summary>
@@ -71,6 +72,11 @@ public static class SettingReach
        "scalespeculars", "gfx.drawrange.factor.max"
    };

+    private static readonly HashSet<string> VulkanRendererOnly = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "gfx.dlss.preset", "gfx.framegeneration", "gfx.reflex", "gfx.raytracing", "gfx.raytracing.range", "gfx.vulkan.device"
+    };
+
    // application.cpp: fullscreenwindowed takes its size from the monitor and always
    // goes full screen. "width, height" is how the settings screen names that row.
    private static readonly HashSet<string> OverriddenByMonitorMode = new(StringComparer.OrdinalIgnoreCase)
@@ -95,6 +101,8 @@ public static class SettingReach
            return IdleReason.ModernRendererOnly;
        if (OpenGlRenderersOnly.Contains(key) && renderer == RendererKind.Experimental)
            return IdleReason.OpenGlRenderersOnly;
+        if (VulkanRendererOnly.Contains(key) && !IsVulkan(target.Renderer))
+            return IdleReason.VulkanOnly;

        // on_focus_change pauses only a simulator that serves the network.
        if (string.Equals(key, "inactivepause", StringComparison.OrdinalIgnoreCase) && !target.NetworkServer)
@@ -112,11 +120,13 @@ public static class SettingReach
    private static bool DrawRangeRegulated(SimulatorTarget target) =>
        target.FpsAverage != 0 || (target.TargetFps ?? 0) != 0;

-    /// <summary>"full" and "default" are the modern renderer, "experimental" its own; every other word the legacy one.</summary>
+    /// <summary>"full", its other names and the Vulkan renderer are the modern kind, "experimental" its own; every other word the legacy one.</summary>
    public static RendererKind KindOf(string renderer) => renderer.ToLowerInvariant() switch
    {
-        "full" or "default" => RendererKind.Modern,
+        "full" or "default" or "opengl" or "gl46" or "vulkan" or "vulkan14" => RendererKind.Modern,
        "experimental" => RendererKind.Experimental,
        _ => RendererKind.Legacy
    };
+
+    private static bool IsVulkan(string renderer) => renderer.ToLowerInvariant() is "vulkan" or "vulkan14";
 }
--- a/StarterNG/Domain/Settings/SimulatorKeys.cs
+++ b/StarterNG/Domain/Settings/SimulatorKeys.cs
@@ -5,7 +5,7 @@ using System.Linq;

 namespace StarterNG.Domain.Settings;

-public enum SimulatorKeyKind { Toggle, Number, Text }
+public enum SimulatorKeyKind { Toggle, Number, Text, Choice }

 /// <summary>
 /// An eu07.ini key the simulator reads that needs no logic of the starter's own:
@@ -24,13 +24,25 @@ public sealed record SimulatorKey(
    double Step = 1,
    string Unit = "",
    bool ZeroIsOff = false,
-    int Repeat = 1)
+    int Repeat = 1,
+    string[]? Words = null)
 {
    /// <summary>The label's translation key; the explanation's adds "Desc".</summary>
    public string LabelKey => "Ini." + Key;

    public string DescriptionKey => LabelKey + ".Desc";

+    /// <summary>The translation key of a word of a choice; the empty one leaves the key out of the file.</summary>
+    public static string WordKey(string word) =>
+        "IniWord." + (word.Length == 0 ? "same" : word.Replace(' ', '_'));
+
+    /// <summary>The word of <paramref name="raw"/> among those offered, or else the default: the row then shows that and leaves the file alone.</summary>
+    public string ParseChoice(string raw)
+    {
+        string word = string.Join(' ', raw.ToLowerInvariant().Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries));
+        return Words is not null && Words.Contains(word) ? word : Default;
+    }
+
    public static bool ParseToggle(string raw) =>
        FirstToken(raw).ToLowerInvariant() is "yes" or "true" or "1" or "tak";

@@ -69,6 +81,8 @@ public static class SimulatorKeys
    public const string Physics = "physics";
    public const string Advanced = "advanced";

+    private const string NewRenderer = "GfxColNewRenderer";
+
    private static SimulatorKey Toggle(string key, bool value, string category, string section) =>
        new(key, SimulatorKeyKind.Toggle, SimulatorKey.FormatToggle(value), category, section);

@@ -81,6 +95,9 @@ public static class SimulatorKeys
    private static SimulatorKey Text(string key, string category, string section) =>
        new(key, SimulatorKeyKind.Text, string.Empty, category, section);

+    private static SimulatorKey Choice(string key, string value, string category, string section, params string[] words) =>
+        new(key, SimulatorKeyKind.Choice, value, category, section, Words: words);
+
    public static SimulatorKey Named(string key) => All.First(k => k.Key == key);

    public static IReadOnlyList<SimulatorKey> All { get; } = new[]
@@ -114,6 +131,38 @@ public static class SimulatorKeys
        Toggle("newaircouplers", true, Graphics, "IniSectionRanges"),
        Toggle("smoothtraction", true, Graphics, "IniSectionRanges"),

+        // Read by the OpenGL 4.6 and Vulkan 1.4 simulators; the older ones pass them over.
+        Choice("gfx.antialiasing", "", Graphics, NewRenderer, "", "taa", "dlss", "dlaa"),
+        Choice("gfx.dlss.preset", "default", Graphics, NewRenderer, "default", "k", "j", "m", "l"),
+        Choice("gfx.framegeneration", "off", Graphics, NewRenderer, "off", "x2", "x3", "x4"),
+        Choice("gfx.reflex", "off", Graphics, NewRenderer, "off", "on", "boost"),
+        Toggle("gfx.raytracing", false, Graphics, NewRenderer),
+        Number("gfx.raytracing.range", 500, Graphics, NewRenderer, 10, 5000, 10, " m"),
+        Text("gfx.vulkan.device", Graphics, NewRenderer),
+        Toggle("gfx.lights.clustered", true, Graphics, NewRenderer),
+        Choice("gfx.lights.shadows", "medium", Graphics, NewRenderer, "no", "low", "medium", "high"),
+        Choice("gfx.contactshadows", "no", Graphics, NewRenderer, "no", "low", "medium", "high"),
+        Toggle("gfx.shadow.sdsm", false, Graphics, NewRenderer),
+        Choice("gfx.postfx.ao", "gtao", Graphics, NewRenderer, "no", "ssao", "gtao"),
+        Choice("gfx.postfx.ao.quality", "3 4", Graphics, NewRenderer, "3 4", "4 6", "6 8"),
+        Toggle("gfx.postfx.ao.lighting", true, Graphics, NewRenderer),
+        Choice("gfx.ssr", "medium", Graphics, NewRenderer, "no", "low", "medium", "high"),
+        Choice("gfx.cabprobe", "medium", Graphics, NewRenderer, "no", "low", "medium", "high"),
+        Number("gfx.cabprobe.interval", 4, Graphics, NewRenderer, 1, 16, 1),
+        Toggle("gfx.cabprobe.reflections", true, Graphics, NewRenderer),
+        Number("gfx.cabprobe.bounce", 1, Graphics, NewRenderer, 0, 4, 0.25),
+        Choice("gfx.fog", "volumetric", Graphics, NewRenderer, "analytic", "volumetric"),
+        Choice("gfx.fog.quality", "medium", Graphics, NewRenderer, "low", "medium", "high", "ultra"),
+        Choice("gfx.clouds", "medium", Graphics, NewRenderer, "no", "low", "medium", "high", "ultra"),
+        Toggle("gfx.clouds.shadows", true, Graphics, NewRenderer),
+        Toggle("gfx.grass", true, Graphics, NewRenderer),
+        Number("gfx.grass.distance", 60, Graphics, NewRenderer, 5, 300, 5, " m"),
+        Number("gfx.grass.fadedistance", 70, Graphics, NewRenderer, 10, 350, 10, " m"),
+        Number("gfx.grass.density", 1, Graphics, NewRenderer, 0, 2, 0.25, "×"),
+        Number("gfx.precipitation.particles", 65536, Graphics, NewRenderer, 0, 131072, 16384),
+        Toggle("gfx.postfx.bloom", true, Graphics, NewRenderer),
+        Toggle("gfx.postfx.autoexposure", true, Graphics, NewRenderer),
+
        Number("sound.maxsources", 30, Sound, "IniSectionAudio", 8, 256, 8),
        Toggle("sound.asyncload", false, Sound, "IniSectionAudio"),

--- a/StarterNG/Domain/Settings/SimulatorSettings.cs
+++ b/StarterNG/Domain/Settings/SimulatorSettings.cs
@@ -157,16 +157,19 @@ public sealed class SimulatorSettings
    /// <summary>
    /// The gfxrenderer words the simulator tells apart (application.cpp): every
    /// other word - the "simpleshader" and "off" older starters offered among them -
-    /// gets the legacy renderer.
+    /// gets the legacy renderer. A simulator with the OpenGL 4.6 and Vulkan 1.4
+    /// renderers runs everything but "vulkan" as the first, and "vulkan" too when
+    /// it was built without it or the card cannot run it.
    /// </summary>
-    public static readonly string[] RenderEngines = { "full", "legacy", "simple", "experimental" };
+    public static readonly string[] RenderEngines = { "full", "legacy", "simple", "experimental", "vulkan" };

    /// <summary>Where <paramref name="word"/> stands among <see cref="RenderEngines"/>, as the simulator reads it.</summary>
    public static int RenderEngineOf(string word) => word.Trim().ToLowerInvariant() switch
    {
-        "full" or "default" => 0,
+        "full" or "default" or "opengl" or "gl46" => 0,
        "simple" => 2,
        "experimental" => 3,
+        "vulkan" or "vulkan14" => 4,
        _ => 1
    };

--- a/StarterNG/Infrastructure/Settings/SettingsSerializer.cs
+++ b/StarterNG/Infrastructure/Settings/SettingsSerializer.cs
@@ -69,7 +69,7 @@ public sealed class SettingsSerializer
        s.RenderEngine = SimulatorSettings.RenderEngineOf(c.GetString("gfxrenderer", "full"));
        s.Width = c.GetInt("width", 1280);
        s.Height = c.GetInt("height", 720);
-        s.BufferScalePercent = Clamp(c.GetInt("starter.bufferscale", 100), 50, 200);
+        s.BufferScalePercent = ReadBufferScale(c);
        s.MaxTextureSize = c.GetInt("maxtexturesize", 4096);
        s.MaxCabTextureSize = c.GetInt("maxcabtexturesize", 4096);
        s.TextureFiltering = Math.Max(1, c.GetDouble("anisotropicfiltering", 8));
@@ -246,8 +246,10 @@ public sealed class SettingsSerializer
        c.SetInt("starter.bufferscale", s.BufferScalePercent);
        int fbw = (int)Math.Round(s.Width * s.BufferScalePercent / 100.0);
        int fbh = (int)Math.Round(s.Height * s.BufferScalePercent / 100.0);
+        // The size for the simulators before gfx.buffer.percent, which pass that one over and the other way round.
        c.SetInt("gfx.framebuffer.width", fbw);
        c.SetInt("gfx.framebuffer.height", fbh);
+        c.SetInt("gfx.buffer.percent", s.BufferScalePercent);
        c.SetInt("maxtexturesize", s.MaxTextureSize);
        c.SetInt("maxcabtexturesize", s.MaxCabTextureSize);
        c.SetDouble("anisotropicfiltering", s.TextureFiltering);
@@ -334,6 +336,16 @@ public sealed class SettingsSerializer
                c.Set(key.Key, value.Trim());
    }

+    // What the simulator goes by: up to 4 a part of the window, above it percents.
+    private static int ReadBufferScale(ConfigFile c)
+    {
+        if (!c.Has("gfx.buffer.percent"))
+            return Clamp(c.GetInt("starter.bufferscale", 100), 25, 200);
+
+        double value = c.GetDouble("gfx.buffer.percent", 100);
+        return Clamp((int)Math.Round(value > 4 ? value : value * 100), 25, 200);
+    }
+
    private static int Clamp(int v, int lo, int hi) => v < lo ? lo : (v > hi ? hi : v);

    private static int SensitivityStep(double mouseScale) =>
--- a/StarterNG/Views/SettingTexts.cs
+++ b/StarterNG/Views/SettingTexts.cs
@@ -103,6 +103,22 @@ internal static class SettingTexts
        Add("Ini." + GraphicsPreset.ReflectedVehiclesKey, Whole(p.ReflectedVehicles) + " m");
        Add("CabShadowsRange", p.CabShadowsRange + " m");

+        var renderer = p.NewRenderer;
+        string Word(string word) => App.Loc[SimulatorKey.WordKey(word)];
+        lines.Add(App.Loc["GfxColNewRenderer"] + ":");
+        Add("Ini.gfx.lights.shadows", Word(renderer.LampShadows));
+        Add("Ini.gfx.contactshadows", Word(renderer.ContactShadows));
+        Add("Ini.gfx.postfx.ao", Word(renderer.Occlusion));
+        Add("Ini.gfx.postfx.ao.quality", Word(renderer.OcclusionQuality));
+        Add("Ini.gfx.cabprobe", Word(renderer.CabProbe));
+        Add("Ini.gfx.ssr", Word(renderer.ScreenReflections));
+        Add("Ini.gfx.raytracing", YesNo(renderer.RayTracing));
+        Add("Ini.gfx.fog", Word(renderer.Fog));
+        Add("Ini.gfx.fog.quality", Word(renderer.FogQuality));
+        Add("Ini.gfx.clouds", Word(renderer.Clouds));
+        Add("Ini.gfx.grass", renderer.Grass ? Whole(renderer.GrassDistance) + " m" : App.Loc["No"]);
+        Add("Ini.gfx.postfx.bloom", YesNo(renderer.Bloom));
+
        if (p.Extras is { } extras)
        {
            Add("MotionBlur", YesNo(extras.MotionBlur));
--- a/StarterNG/Views/Settings.axaml
+++ b/StarterNG/Views/Settings.axaml
@@ -191,6 +191,7 @@
                                                <ComboBoxItem Content="{Binding [REOld], Source={x:Static starterNg:App.Loc}}" />
                                                <ComboBoxItem Content="{Binding [RESimp], Source={x:Static starterNg:App.Loc}}" />
                                                <ComboBoxItem Content="{Binding [REExperimental], Source={x:Static starterNg:App.Loc}}" />
+                                                <ComboBoxItem Content="{Binding [REVulkan], Source={x:Static starterNg:App.Loc}}" />
                                            </ComboBox>
                                            <TextBlock x:Name="RenderEngineWarning" IsVisible="False" TextWrapping="Wrap"
                                                       Foreground="{StaticResource CarbonAccentBright}"
@@ -228,7 +229,7 @@
                                    <ctl:SettingRow ConfigKey="starter.bufferscale" Label="{Binding [BufforResolution], Source={x:Static starterNg:App.Loc}}"
                                                    Description="{Binding [BufforResolutionDesc], Source={x:Static starterNg:App.Loc}}"
                                                    ValueText="{Binding #bufferScale.Value, StringFormat='{}{0:0}%'}">
-                                        <Slider Name="bufferScale" Minimum="50" Maximum="200" TickFrequency="1"
+                                        <Slider Name="bufferScale" Minimum="25" Maximum="200" TickFrequency="1"
                                                IsSnapToTickEnabled="True" Value="100" />
                                    </ctl:SettingRow>
                                    <ctl:SettingRow ConfigKey="fieldofview" Label="{Binding [FieldOfView], Source={x:Static starterNg:App.Loc}}"
@@ -426,6 +427,41 @@
                                </StackPanel>
                            </ctl:SettingsSection>

+                            <ctl:SettingsSection x:Name="NewRendererSection" Header="{Binding [GfxColNewRenderer], Source={x:Static starterNg:App.Loc}}">
+                                <StackPanel>
+                                    <ctl:KeySlot Key="gfx.antialiasing" />
+                                    <ctl:KeySlot Key="gfx.dlss.preset" />
+                                    <ctl:KeySlot Key="gfx.framegeneration" />
+                                    <ctl:KeySlot Key="gfx.reflex" />
+                                    <ctl:KeySlot Key="gfx.lights.clustered" />
+                                    <ctl:KeySlot Key="gfx.lights.shadows" />
+                                    <ctl:KeySlot Key="gfx.contactshadows" />
+                                    <ctl:KeySlot Key="gfx.shadow.sdsm" />
+                                    <ctl:KeySlot Key="gfx.postfx.ao" />
+                                    <ctl:KeySlot Key="gfx.postfx.ao.quality" />
+                                    <ctl:KeySlot Key="gfx.postfx.ao.lighting" />
+                                    <ctl:KeySlot Key="gfx.ssr" />
+                                    <ctl:KeySlot Key="gfx.raytracing" />
+                                    <ctl:KeySlot Key="gfx.raytracing.range" />
+                                    <ctl:KeySlot Key="gfx.cabprobe" />
+                                    <ctl:KeySlot Key="gfx.cabprobe.interval" />
+                                    <ctl:KeySlot Key="gfx.cabprobe.reflections" />
+                                    <ctl:KeySlot Key="gfx.cabprobe.bounce" />
+                                    <ctl:KeySlot Key="gfx.fog" />
+                                    <ctl:KeySlot Key="gfx.fog.quality" />
+                                    <ctl:KeySlot Key="gfx.clouds" />
+                                    <ctl:KeySlot Key="gfx.clouds.shadows" />
+                                    <ctl:KeySlot Key="gfx.precipitation.particles" />
+                                    <ctl:KeySlot Key="gfx.grass" />
+                                    <ctl:KeySlot Key="gfx.grass.distance" />
+                                    <ctl:KeySlot Key="gfx.grass.fadedistance" />
+                                    <ctl:KeySlot Key="gfx.grass.density" />
+                                    <ctl:KeySlot Key="gfx.postfx.bloom" />
+                                    <ctl:KeySlot Key="gfx.postfx.autoexposure" />
+                                    <ctl:KeySlot Key="gfx.vulkan.device" />
+                                </StackPanel>
+                            </ctl:SettingsSection>
+
                            <ctl:SettingsSection Header="{Binding [GfxColScripts], Source={x:Static starterNg:App.Loc}}">
                                <StackPanel>
                                    <ctl:SettingRow ConfigKey="python.enabled" Description="{Binding [RenderScreensDesc], Source={x:Static starterNg:App.Loc}}">
--- a/StarterNG/Views/Settings.axaml.cs
+++ b/StarterNG/Views/Settings.axaml.cs
@@ -516,7 +516,7 @@ public partial class Settings : UserControl, ISettingsCapture
                 {
                     (DrawRangeSection, GraphicsGroup.DrawRange), (TexturesSection, GraphicsGroup.Textures),
                     (EffectsSection, GraphicsGroup.Effects), (ShadowsSection, GraphicsGroup.Shadows),
-                     (ReflectionsSection, GraphicsGroup.Reflections)
+                     (ReflectionsSection, GraphicsGroup.Reflections), (NewRendererSection, GraphicsGroup.NewRenderer)
                 })
        {
            var levels = new ComboBox();
@@ -1098,6 +1098,7 @@ public partial class Settings : UserControl, ISettingsCapture
        IdleReason.NeedsNetworkServer => App.Loc["IdleNeedsNetworkServer"],
        IdleReason.NeedsFrameRateTarget => App.Loc["IdleNeedsFrameRateTarget"],
        IdleReason.MonitorModeInstead => App.Loc["IdleMonitorMode"],
+        IdleReason.VulkanOnly => App.Loc["IdleVulkanOnly"],
        _ => null
    };

--- a/StarterNG/Views/SimulatorKeyRows.cs
+++ b/StarterNG/Views/SimulatorKeyRows.cs
@@ -77,6 +77,7 @@ internal sealed class SimulatorKeyRows
                TickFrequency = key.Step,
                IsSnapToTickEnabled = true
            },
+            SimulatorKeyKind.Choice => ChoiceBox(key),
            _ => new TextBox { MinWidth = 200 }
        };

@@ -102,11 +103,23 @@ internal sealed class SimulatorKeyRows
            case TextBox text:
                text.TextChanged += (_, _) => OnEdited(row);
                break;
+            case ComboBox box:
+                box.SelectionChanged += (_, _) => OnEdited(row);
+                break;
        }

        return setting;
    }

+    private static ComboBox ChoiceBox(SimulatorKey key)
+    {
+        var box = new ComboBox();
+        box.Classes.Add("Localized");
+        foreach (string word in key.Words ?? Array.Empty<string>())
+            box.Items.Add(new ComboBoxItem { Tag = word });
+        return box;
+    }
+
    /// <summary>
    /// Only a value other than the one shown counts: a text box reports the text it
    /// was given after the fact, and a slider reports its own clamping.
@@ -159,6 +172,11 @@ internal sealed class SimulatorKeyRows
                    row.Setting.Label = label;
                    text.PlaceholderText = App.Loc["IniDefault"];
                    break;
+                case ComboBox choice:
+                    row.Setting.Label = label;
+                    foreach (var item in choice.Items.OfType<ComboBoxItem>())
+                        item.Content = App.Loc[SimulatorKey.WordKey(item.Tag as string ?? string.Empty)];
+                    break;
                default:
                    row.Setting.Label = label;
                    UpdateValueText(row);
@@ -224,6 +242,10 @@ internal sealed class SimulatorKeyRows
            case TextBox text:
                text.Text = raw.Trim();
                break;
+            case ComboBox choice:
+                string word = row.Key.ParseChoice(raw);
+                choice.SelectedItem = choice.Items.OfType<ComboBoxItem>().FirstOrDefault(item => item.Tag as string == word);
+                break;
        }
    }

@@ -232,6 +254,7 @@ internal sealed class SimulatorKeyRows
        CheckBox box => SimulatorKey.FormatToggle(box.IsChecked == true),
        Slider slider => row.Key.FormatNumber(slider.Value),
        TextBox text => (text.Text ?? string.Empty).Trim(),
+        ComboBox choice => (choice.SelectedItem as ComboBoxItem)?.Tag as string ?? row.Key.Default,
        _ => string.Empty
    };

--- a/StarterNG/startercfg/lang/cz.xml
+++ b/StarterNG/startercfg/lang/cz.xml
@@ -407,7 +407,7 @@
    <String key="Graphic">Grafika</String>
    <String key="RenderEngine">Vykreslovací engine</String>
    <String key="REFull">Plný</String>
-    <String key="RenderEngineDesc">Plný: OpenGL 3.3 se stíny a odrazy. Starý a Zjednodušený: pro slabé karty. Experimentální: Vulkan, Direct3D 12, ve vývoji.</String>
+    <String key="RenderEngineDesc">Plný: OpenGL se stíny a odrazy, v novém simulátoru OpenGL 4.6. Starý, Zjednodušený, Experimentální: starší verze simulátoru, nová spustí Plný. Vulkan 1.4: když ho exe nemá nebo ho karta nezvládne, nová verze spustí OpenGL a starší Starý.</String>
    <String key="REOld">Starý</String>
    <String key="RESimp">Zjednodušený</String>
    <String key="REExperimental">Experimentální</String>
@@ -865,4 +865,64 @@
    <String key="WarehouseSaved">Ve skladu: {0}</String>
    <String key="WarehouseNothingToAdd">Vyberte soupravu s vozidly</String>
    <String key="GfxGroupLevelTip">Úroveň jen pro tuto část grafiky</String>
+    <String key="REVulkan">Vulkan 1.4</String>
+    <String key="IdleVulkanOnly">Funguje jen s Vulkanem.</String>
+    <String key="GfxColNewRenderer">Nový renderer (OpenGL 4.6, Vulkan)</String>
+    <String key="Ini.gfx.antialiasing">Vyhlazování TAA / DLSS</String>
+    <String key="Ini.gfx.dlss.preset">Předvolba DLSS</String>
+    <String key="Ini.gfx.framegeneration">Generování snímků</String>
+    <String key="Ini.gfx.reflex">NVIDIA Reflex</String>
+    <String key="Ini.gfx.raytracing">Odrazy ray tracing</String>
+    <String key="Ini.gfx.raytracing.range">Dosah ray tracingu</String>
+    <String key="Ini.gfx.vulkan.device">Grafická karta (Vulkan)</String>
+    <String key="Ini.gfx.ssr">Odrazy v prostoru obrazovky (SSR)</String>
+    <String key="Ini.gfx.postfx.ao">Okolní zastínění</String>
+    <String key="Ini.gfx.postfx.ao.quality">Kvalita zastínění</String>
+    <String key="Ini.gfx.postfx.ao.lighting">Zastínění v okolním světle</String>
+    <String key="Ini.gfx.lights.clustered">Klastrové osvětlení</String>
+    <String key="Ini.gfx.lights.shadows">Stíny lamp a reflektorů</String>
+    <String key="Ini.gfx.contactshadows">Kontaktní stíny</String>
+    <String key="Ini.gfx.shadow.sdsm">Kaskády stínů podle scény (SDSM)</String>
+    <String key="Ini.gfx.cabprobe">Sonda kabiny</String>
+    <String key="Ini.gfx.cabprobe.interval">Obnovení sondy každých N snímků</String>
+    <String key="Ini.gfx.cabprobe.reflections">Kabina odráží sebe</String>
+    <String key="Ini.gfx.cabprobe.bounce">Odražené světlo lampy v kabině</String>
+    <String key="Ini.gfx.fog">Mlha</String>
+    <String key="Ini.gfx.fog.quality">Kvalita mlhy</String>
+    <String key="Ini.gfx.clouds">Objemová oblaka</String>
+    <String key="Ini.gfx.clouds.shadows">Stíny oblaků na zemi</String>
+    <String key="Ini.gfx.grass">Tráva</String>
+    <String key="Ini.gfx.grass.distance">Dosah trávy</String>
+    <String key="Ini.gfx.grass.fadedistance">Tráva mizí do</String>
+    <String key="Ini.gfx.grass.density">Hustota trávy</String>
+    <String key="Ini.gfx.precipitation.particles">Srážky (částice)</String>
+    <String key="Ini.gfx.postfx.bloom">Záře světlých míst (bloom)</String>
+    <String key="Ini.gfx.postfx.autoexposure">Automatická expozice</String>
+    <String key="IniWord.same">Jako MSAA výše</String>
+    <String key="IniWord.no">Vypnuto</String>
+    <String key="IniWord.off">Vypnuto</String>
+    <String key="IniWord.low">Nízká</String>
+    <String key="IniWord.medium">Střední</String>
+    <String key="IniWord.high">Vysoká</String>
+    <String key="IniWord.ultra">Ultra</String>
+    <String key="IniWord.on">Zapnuto</String>
+    <String key="IniWord.boost">Zapnuto + boost</String>
+    <String key="IniWord.ssao">SSAO</String>
+    <String key="IniWord.gtao">GTAO</String>
+    <String key="IniWord.volumetric">Objemová</String>
+    <String key="IniWord.analytic">Analytická</String>
+    <String key="IniWord.default">Automaticky</String>
+    <String key="IniWord.k">K: nejlepší kvalita</String>
+    <String key="IniWord.j">J: méně rozmazání</String>
+    <String key="IniWord.m">M: pro režim Výkon</String>
+    <String key="IniWord.l">L: pro Ultra výkon</String>
+    <String key="IniWord.x2">x2</String>
+    <String key="IniWord.x3">x3</String>
+    <String key="IniWord.x4">x4</String>
+    <String key="IniWord.taa">TAA</String>
+    <String key="IniWord.dlss">DLSS (škálování)</String>
+    <String key="IniWord.dlaa">DLAA (nativní rozlišení)</String>
+    <String key="IniWord.3_4">Výchozí (3×4)</String>
+    <String key="IniWord.4_6">Vysoká (4×6)</String>
+    <String key="IniWord.6_8">Ultra (6×8)</String>
 </Language>
--- a/StarterNG/startercfg/lang/en.xml
+++ b/StarterNG/startercfg/lang/en.xml
@@ -413,7 +413,7 @@

    <String key="Graphic">Graphics</String>
    <String key="RenderEngine">Render engine</String>
-    <String key="RenderEngineDesc">Full: OpenGL 3.3 with shadows and reflections. Old and Simplified: for weak cards. Experimental: Vulkan, Direct3D 12, in development.</String>
+    <String key="RenderEngineDesc">Full: OpenGL with shadows and reflections, OpenGL 4.6 in the new simulator. Old, Simplified, Experimental: older simulator versions, the new one starts Full. Vulkan 1.4: if the exe lacks it or the card cannot run it, the new version starts OpenGL and an older one Old.</String>
    <String key="REFull">Full</String>
    <String key="REOld">Old</String>
    <String key="RESimp">Simplified</String>
@@ -1097,4 +1097,83 @@
    <String key="WarehouseSaved">In the warehouse: {0}</String>
    <String key="WarehouseNothingToAdd">Pick a consist with vehicles</String>
    <String key="GfxGroupLevelTip">Level for this part of the graphics only</String>
+    <String key="REVulkan">Vulkan 1.4</String>
+    <String key="IdleVulkanOnly">Works with Vulkan only.</String>
+    <String key="GfxColNewRenderer">New renderer (OpenGL 4.6, Vulkan)</String>
+    <String key="Ini.gfx.antialiasing">TAA / DLSS anti-aliasing</String>
+    <String key="Ini.gfx.antialiasing.Desc">Replaces MSAA. TAA smooths the whole image at the cost of slight blur. DLSS and DLAA need Vulkan and an NVIDIA RTX card.</String>
+    <String key="Ini.gfx.dlss.preset">DLSS preset</String>
+    <String key="Ini.gfx.dlss.preset.Desc">The model DLSS rebuilds the image with. The DLSS mode follows the buffer scale: about 67% Quality, 50% Performance, 33% Ultra Performance.</String>
+    <String key="Ini.gfx.framegeneration">Frame generation</String>
+    <String key="Ini.gfx.framegeneration.Desc">Extra frames between the drawn ones. With DLSS or DLAA only. x3 and x4 need an RTX 50 card.</String>
+    <String key="Ini.gfx.reflex">NVIDIA Reflex</String>
+    <String key="Ini.gfx.reflex.Desc">Less delay between the controls and the image.</String>
+    <String key="Ini.gfx.raytracing">Ray traced reflections</String>
+    <String key="Ini.gfx.raytracing.Desc">Fills in reflections where SSR finds nothing. The card needs ray query.</String>
+    <String key="Ini.gfx.raytracing.range">Ray tracing range</String>
+    <String key="Ini.gfx.vulkan.device">Graphics card (Vulkan)</String>
+    <String key="Ini.gfx.vulkan.device.Desc">A card's number from the list in the log, or part of its name, like RTX. Empty: chosen automatically.</String>
+    <String key="Ini.gfx.ssr">Screen space reflections (SSR)</String>
+    <String key="Ini.gfx.ssr.Desc">Reflections of what is on screen, on wet and smooth surfaces.</String>
+    <String key="Ini.gfx.postfx.ao">Ambient occlusion</String>
+    <String key="Ini.gfx.postfx.ao.Desc">Darkens corners and places where surfaces meet. GTAO is more accurate than SSAO.</String>
+    <String key="Ini.gfx.postfx.ao.quality">Occlusion quality</String>
+    <String key="Ini.gfx.postfx.ao.lighting">Occlusion in ambient light</String>
+    <String key="Ini.gfx.postfx.ao.lighting.Desc">GTAO only. Darkens ambient light and reflections, sun and lamps stay bright. Off: multiplies the finished image, cheaper.</String>
+    <String key="Ini.gfx.lights.clustered">Clustered lighting</String>
+    <String key="Ini.gfx.lights.clustered.Desc">Vehicle lights and street lamps with no limit on their number. Needed for scenery lamps and the cab lamp.</String>
+    <String key="Ini.gfx.lights.shadows">Lamp and headlight shadows</String>
+    <String key="Ini.gfx.lights.shadows.Desc">Shadows cast by the cab lamp, street lamps and vehicle headlights.</String>
+    <String key="Ini.gfx.contactshadows">Contact shadows</String>
+    <String key="Ini.gfx.contactshadows.Desc">Small shadows where objects touch, which the shadow map misses.</String>
+    <String key="Ini.gfx.shadow.sdsm">Shadow cascades fitted to the scene (SDSM)</String>
+    <String key="Ini.gfx.shadow.sdsm.Desc">Spreads the sun shadow resolution over what is actually in view.</String>
+    <String key="Ini.gfx.cabprobe">Cab probe</String>
+    <String key="Ini.gfx.cabprobe.Desc">Light bounced off the cab walls and reflections of the interior in the windows.</String>
+    <String key="Ini.gfx.cabprobe.interval">Refresh the probe every N frames</String>
+    <String key="Ini.gfx.cabprobe.reflections">Cab reflects itself</String>
+    <String key="Ini.gfx.cabprobe.reflections.Desc">The windows show the cab interior instead of the sky where SSR finds nothing.</String>
+    <String key="Ini.gfx.cabprobe.bounce">Cab lamp light bounce</String>
+    <String key="Ini.gfx.cabprobe.bounce.Desc">How much of the lamp's light reflected off the walls lights the cab again. Works with the cab probe.</String>
+    <String key="Ini.gfx.fog">Fog</String>
+    <String key="Ini.gfx.fog.Desc">Volumetric: with sun rays, cloud shadows and lamp light. Analytic: simpler and cheaper.</String>
+    <String key="Ini.gfx.fog.quality">Fog quality</String>
+    <String key="Ini.gfx.clouds">Volumetric clouds</String>
+    <String key="Ini.gfx.clouds.shadows">Cloud shadows on the ground</String>
+    <String key="Ini.gfx.grass">Grass</String>
+    <String key="Ini.gfx.grass.distance">Grass range</String>
+    <String key="Ini.gfx.grass.fadedistance">Grass fades out at</String>
+    <String key="Ini.gfx.grass.density">Grass density</String>
+    <String key="Ini.gfx.precipitation.particles">Precipitation (particles)</String>
+    <String key="Ini.gfx.precipitation.particles.Desc">Number of raindrops and snowflakes in the heaviest precipitation.</String>
+    <String key="Ini.gfx.postfx.bloom">Glow of bright areas (bloom)</String>
+    <String key="Ini.gfx.postfx.autoexposure">Automatic exposure</String>
+    <String key="Ini.gfx.postfx.autoexposure.Desc">Image brightness adapts to the scene, for instance entering a tunnel.</String>
+    <String key="IniWord.same">As MSAA above</String>
+    <String key="IniWord.no">Off</String>
+    <String key="IniWord.off">Off</String>
+    <String key="IniWord.low">Low</String>
+    <String key="IniWord.medium">Medium</String>
+    <String key="IniWord.high">High</String>
+    <String key="IniWord.ultra">Ultra</String>
+    <String key="IniWord.on">On</String>
+    <String key="IniWord.boost">On + boost</String>
+    <String key="IniWord.ssao">SSAO</String>
+    <String key="IniWord.gtao">GTAO</String>
+    <String key="IniWord.volumetric">Volumetric</String>
+    <String key="IniWord.analytic">Analytic</String>
+    <String key="IniWord.default">Automatic</String>
+    <String key="IniWord.k">K: best quality</String>
+    <String key="IniWord.j">J: less smearing</String>
+    <String key="IniWord.m">M: for Performance mode</String>
+    <String key="IniWord.l">L: for Ultra Performance</String>
+    <String key="IniWord.x2">x2</String>
+    <String key="IniWord.x3">x3</String>
+    <String key="IniWord.x4">x4</String>
+    <String key="IniWord.taa">TAA</String>
+    <String key="IniWord.dlss">DLSS (upscaling)</String>
+    <String key="IniWord.dlaa">DLAA (native resolution)</String>
+    <String key="IniWord.3_4">Default (3×4)</String>
+    <String key="IniWord.4_6">High (4×6)</String>
+    <String key="IniWord.6_8">Ultra (6×8)</String>
 </Language>
--- a/StarterNG/startercfg/lang/hu.xml
+++ b/StarterNG/startercfg/lang/hu.xml
@@ -407,7 +407,7 @@
    <String key="Graphic">Grafika</String>
    <String key="RenderEngine">Megjelenítő motor</String>
    <String key="REFull">Teljes</String>
-    <String key="RenderEngineDesc">Teljes: OpenGL 3.3 árnyékokkal és tükröződéssel. Régi és Egyszerűsített: gyenge kártyákhoz. Kísérleti: Vulkan, Direct3D 12, fejlesztés alatt.</String>
+    <String key="RenderEngineDesc">Teljes: OpenGL árnyékokkal és tükröződéssel, az új szimulátorban OpenGL 4.6. Régi, Egyszerűsített, Kísérleti: a szimulátor régebbi verziói, az új a Teljeset indítja. Vulkan 1.4: ha az exe nem tartalmazza vagy a kártya nem bírja, az új verzió OpenGL-t, a régebbi a Régit indítja.</String>
    <String key="REOld">Régi</String>
    <String key="RESimp">Egyszerűsített</String>
    <String key="REExperimental">Kísérleti</String>
@@ -865,4 +865,64 @@
    <String key="WarehouseSaved">A raktárban: {0}</String>
    <String key="WarehouseNothingToAdd">Válassz járműveket tartalmazó szerelvényt</String>
    <String key="GfxGroupLevelTip">Csak a grafika ezen részének szintje</String>
+    <String key="REVulkan">Vulkan 1.4</String>
+    <String key="IdleVulkanOnly">Csak Vulkannal működik.</String>
+    <String key="GfxColNewRenderer">Új renderelő (OpenGL 4.6, Vulkan)</String>
+    <String key="Ini.gfx.antialiasing">TAA / DLSS élsimítás</String>
+    <String key="Ini.gfx.dlss.preset">DLSS előbeállítás</String>
+    <String key="Ini.gfx.framegeneration">Képkocka-generálás</String>
+    <String key="Ini.gfx.reflex">NVIDIA Reflex</String>
+    <String key="Ini.gfx.raytracing">Sugárkövetéses tükröződés</String>
+    <String key="Ini.gfx.raytracing.range">Sugárkövetés hatótávja</String>
+    <String key="Ini.gfx.vulkan.device">Videokártya (Vulkan)</String>
+    <String key="Ini.gfx.ssr">Képernyőtéri tükröződés (SSR)</String>
+    <String key="Ini.gfx.postfx.ao">Környezeti kitakarás</String>
+    <String key="Ini.gfx.postfx.ao.quality">Kitakarás minősége</String>
+    <String key="Ini.gfx.postfx.ao.lighting">Kitakarás a környezeti fényben</String>
+    <String key="Ini.gfx.lights.clustered">Klaszteres megvilágítás</String>
+    <String key="Ini.gfx.lights.shadows">Lámpák és fényszórók árnyéka</String>
+    <String key="Ini.gfx.contactshadows">Kontaktárnyékok</String>
+    <String key="Ini.gfx.shadow.sdsm">Jelenethez igazított árnyékkaszkádok (SDSM)</String>
+    <String key="Ini.gfx.cabprobe">Fülkeszonda</String>
+    <String key="Ini.gfx.cabprobe.interval">Szonda frissítése N képkockánként</String>
+    <String key="Ini.gfx.cabprobe.reflections">A fülke önmagát tükrözi</String>
+    <String key="Ini.gfx.cabprobe.bounce">A fülkelámpa visszavert fénye</String>
+    <String key="Ini.gfx.fog">Köd</String>
+    <String key="Ini.gfx.fog.quality">Köd minősége</String>
+    <String key="Ini.gfx.clouds">Térfogati felhők</String>
+    <String key="Ini.gfx.clouds.shadows">Felhők árnyéka a talajon</String>
+    <String key="Ini.gfx.grass">Fű</String>
+    <String key="Ini.gfx.grass.distance">Fű hatótávja</String>
+    <String key="Ini.gfx.grass.fadedistance">A fű eltűnik eddig</String>
+    <String key="Ini.gfx.grass.density">Fű sűrűsége</String>
+    <String key="Ini.gfx.precipitation.particles">Csapadék (részecskék)</String>
+    <String key="Ini.gfx.postfx.bloom">Világos részek ragyogása (bloom)</String>
+    <String key="Ini.gfx.postfx.autoexposure">Automatikus expozíció</String>
+    <String key="IniWord.same">Mint a fenti MSAA</String>
+    <String key="IniWord.no">Ki</String>
+    <String key="IniWord.off">Ki</String>
+    <String key="IniWord.low">Alacsony</String>
+    <String key="IniWord.medium">Közepes</String>
+    <String key="IniWord.high">Magas</String>
+    <String key="IniWord.ultra">Ultra</String>
+    <String key="IniWord.on">Be</String>
+    <String key="IniWord.boost">Be + boost</String>
+    <String key="IniWord.ssao">SSAO</String>
+    <String key="IniWord.gtao">GTAO</String>
+    <String key="IniWord.volumetric">Térfogati</String>
+    <String key="IniWord.analytic">Analitikus</String>
+    <String key="IniWord.default">Automatikus</String>
+    <String key="IniWord.k">K: legjobb minőség</String>
+    <String key="IniWord.j">J: kevesebb elmosódás</String>
+    <String key="IniWord.m">M: Teljesítmény módhoz</String>
+    <String key="IniWord.l">L: Ultra teljesítményhez</String>
+    <String key="IniWord.x2">x2</String>
+    <String key="IniWord.x3">x3</String>
+    <String key="IniWord.x4">x4</String>
+    <String key="IniWord.taa">TAA</String>
+    <String key="IniWord.dlss">DLSS (felskálázás)</String>
+    <String key="IniWord.dlaa">DLAA (natív felbontás)</String>
+    <String key="IniWord.3_4">Alapértelmezett (3×4)</String>
+    <String key="IniWord.4_6">Magas (4×6)</String>
+    <String key="IniWord.6_8">Ultra (6×8)</String>
 </Language>
--- a/StarterNG/startercfg/lang/pl.xml
+++ b/StarterNG/startercfg/lang/pl.xml
@@ -413,7 +413,7 @@

    <String key="Graphic">Grafika</String>
    <String key="RenderEngine">Silnik renderowania</String>
-    <String key="RenderEngineDesc">Pełny: OpenGL 3.3 z cieniami i odbiciami. Stary i Uproszczony: dla słabych kart. Eksperymentalny: Vulkan, Direct3D 12, w rozwoju.</String>
+    <String key="RenderEngineDesc">Pełny: OpenGL z cieniami i odbiciami, w nowym symulatorze OpenGL 4.6. Stary, Uproszczony, Eksperymentalny: starsze wersje symulatora, nowa włączy Pełny. Vulkan 1.4: gdy exe go nie ma albo karta nie da rady, nowa wersja włączy OpenGL, a starsza Stary.</String>
    <String key="REFull">Pełny</String>
    <String key="REOld">Stary</String>
    <String key="RESimp">Uproszczony</String>
@@ -919,4 +919,83 @@
    <String key="WarehouseSaved">W magazynie: {0}</String>
    <String key="WarehouseNothingToAdd">Wybierz skład z pojazdami</String>
    <String key="GfxGroupLevelTip">Poziom tylko tej części grafiki</String>
+    <String key="REVulkan">Vulkan 1.4</String>
+    <String key="IdleVulkanOnly">Działa tylko z Vulkanem.</String>
+    <String key="GfxColNewRenderer">Nowy renderer (OpenGL 4.6, Vulkan)</String>
+    <String key="Ini.gfx.antialiasing">Wygładzanie TAA / DLSS</String>
+    <String key="Ini.gfx.antialiasing.Desc">Zastępuje MSAA. TAA wygładza cały obraz kosztem lekkiego rozmycia. DLSS i DLAA tylko z Vulkanem na kartach NVIDIA RTX.</String>
+    <String key="Ini.gfx.dlss.preset">Preset DLSS</String>
+    <String key="Ini.gfx.dlss.preset.Desc">Model, którym DLSS odtwarza obraz. Tryb DLSS wynika ze skali bufora: ok. 67% Jakość, 50% Wydajność, 33% Ultra wydajność.</String>
+    <String key="Ini.gfx.framegeneration">Generowanie klatek</String>
+    <String key="Ini.gfx.framegeneration.Desc">Dodatkowe klatki między rysowanymi. Tylko z DLSS lub DLAA. x3 i x4 tylko na kartach RTX 50.</String>
+    <String key="Ini.gfx.reflex">NVIDIA Reflex</String>
+    <String key="Ini.gfx.reflex.Desc">Mniejsze opóźnienie między sterowaniem a obrazem.</String>
+    <String key="Ini.gfx.raytracing">Odbicia ray tracing</String>
+    <String key="Ini.gfx.raytracing.Desc">Uzupełnia odbicia tam, gdzie SSR nic nie znajduje. Karta musi mieć ray query.</String>
+    <String key="Ini.gfx.raytracing.range">Zasięg ray tracingu</String>
+    <String key="Ini.gfx.vulkan.device">Karta graficzna (Vulkan)</String>
+    <String key="Ini.gfx.vulkan.device.Desc">Numer karty z listy w logu albo fragment nazwy, np. RTX. Puste: wybór automatyczny.</String>
+    <String key="Ini.gfx.ssr">Odbicia w przestrzeni ekranu (SSR)</String>
+    <String key="Ini.gfx.ssr.Desc">Odbicia tego, co widać na ekranie, na mokrych i gładkich powierzchniach.</String>
+    <String key="Ini.gfx.postfx.ao">Okluzja otoczenia</String>
+    <String key="Ini.gfx.postfx.ao.Desc">Przyciemnia zakamarki i styki powierzchni. GTAO jest dokładniejsze od SSAO.</String>
+    <String key="Ini.gfx.postfx.ao.quality">Jakość okluzji</String>
+    <String key="Ini.gfx.postfx.ao.lighting">Okluzja w świetle otoczenia</String>
+    <String key="Ini.gfx.postfx.ao.lighting.Desc">Tylko z GTAO. Przyciemnia światło otoczenia i odbicia, a słońce i lampy zostają jasne. Wyłączone: mnoży gotowy obraz, taniej.</String>
+    <String key="Ini.gfx.lights.clustered">Oświetlenie klastrowe</String>
+    <String key="Ini.gfx.lights.clustered.Desc">Światła pojazdów i latarnie bez limitu liczby. Potrzebne dla lamp scenerii i lampy w kabinie.</String>
+    <String key="Ini.gfx.lights.shadows">Cienie lamp i reflektorów</String>
+    <String key="Ini.gfx.lights.shadows.Desc">Cienie rzucane przez lampę kabiny, latarnie i reflektory pojazdów.</String>
+    <String key="Ini.gfx.contactshadows">Cienie kontaktowe</String>
+    <String key="Ini.gfx.contactshadows.Desc">Drobne cienie w miejscach styku obiektów, których mapa cieni nie łapie.</String>
+    <String key="Ini.gfx.shadow.sdsm">Kaskady cieni dopasowane do sceny (SDSM)</String>
+    <String key="Ini.gfx.shadow.sdsm.Desc">Rozkłada rozdzielczość cieni słońca na to, co faktycznie widać.</String>
+    <String key="Ini.gfx.cabprobe">Próbka kabiny</String>
+    <String key="Ini.gfx.cabprobe.Desc">Światło odbite od ścian kabiny i odbicia wnętrza w szybach.</String>
+    <String key="Ini.gfx.cabprobe.interval">Odświeżanie próbki co N klatek</String>
+    <String key="Ini.gfx.cabprobe.reflections">Kabina odbija siebie</String>
+    <String key="Ini.gfx.cabprobe.reflections.Desc">W szybach widać wnętrze kabiny zamiast nieba tam, gdzie SSR nic nie znajduje.</String>
+    <String key="Ini.gfx.cabprobe.bounce">Odbite światło lampy w kabinie</String>
+    <String key="Ini.gfx.cabprobe.bounce.Desc">Ile światła lampy odbitego od ścian oświetla kabinę ponownie. Działa z próbką kabiny.</String>
+    <String key="Ini.gfx.fog">Mgła</String>
+    <String key="Ini.gfx.fog.Desc">Wolumetryczna: z promieniami słońca, cieniami chmur i światłem lamp. Analityczna: prostsza i tańsza.</String>
+    <String key="Ini.gfx.fog.quality">Jakość mgły</String>
+    <String key="Ini.gfx.clouds">Chmury wolumetryczne</String>
+    <String key="Ini.gfx.clouds.shadows">Cienie chmur na ziemi</String>
+    <String key="Ini.gfx.grass">Trawa</String>
+    <String key="Ini.gfx.grass.distance">Zasięg trawy</String>
+    <String key="Ini.gfx.grass.fadedistance">Trawa zanika do</String>
+    <String key="Ini.gfx.grass.density">Gęstość trawy</String>
+    <String key="Ini.gfx.precipitation.particles">Opady (cząsteczki)</String>
+    <String key="Ini.gfx.precipitation.particles.Desc">Liczba kropli deszczu i płatków śniegu przy największych opadach.</String>
+    <String key="Ini.gfx.postfx.bloom">Poświata jasnych miejsc (bloom)</String>
+    <String key="Ini.gfx.postfx.autoexposure">Automatyczna ekspozycja</String>
+    <String key="Ini.gfx.postfx.autoexposure.Desc">Jasność obrazu dopasowuje się do sceny, np. przy wjeździe do tunelu.</String>
+    <String key="IniWord.same">Jak MSAA wyżej</String>
+    <String key="IniWord.no">Wyłączone</String>
+    <String key="IniWord.off">Wyłączone</String>
+    <String key="IniWord.low">Niskie</String>
+    <String key="IniWord.medium">Średnie</String>
+    <String key="IniWord.high">Wysokie</String>
+    <String key="IniWord.ultra">Ultra</String>
+    <String key="IniWord.on">Włączony</String>
+    <String key="IniWord.boost">Włączony + boost</String>
+    <String key="IniWord.ssao">SSAO</String>
+    <String key="IniWord.gtao">GTAO</String>
+    <String key="IniWord.volumetric">Wolumetryczna</String>
+    <String key="IniWord.analytic">Analityczna</String>
+    <String key="IniWord.default">Automatyczny</String>
+    <String key="IniWord.k">K: najlepsza jakość</String>
+    <String key="IniWord.j">J: mniej smużenia</String>
+    <String key="IniWord.m">M: pod tryb Wydajność</String>
+    <String key="IniWord.l">L: pod Ultra wydajność</String>
+    <String key="IniWord.x2">x2</String>
+    <String key="IniWord.x3">x3</String>
+    <String key="IniWord.x4">x4</String>
+    <String key="IniWord.taa">TAA</String>
+    <String key="IniWord.dlss">DLSS (skalowanie)</String>
+    <String key="IniWord.dlaa">DLAA (natywna rozdzielczość)</String>
+    <String key="IniWord.3_4">Domyślna (3×4)</String>
+    <String key="IniWord.4_6">Wysoka (4×6)</String>
+    <String key="IniWord.6_8">Ultra (6×8)</String>
 </Language>
--- a/StarterNG/startercfg/lang/ru.xml
+++ b/StarterNG/startercfg/lang/ru.xml
@@ -407,7 +407,7 @@
    <String key="Graphic">Графика</String>
    <String key="RenderEngine">Движок отрисовки</String>
    <String key="REFull">Полный</String>
-    <String key="RenderEngineDesc">Полный: OpenGL 3.3 с тенями и отражениями. Старый и Упрощённый: для слабых карт. Экспериментальный: Vulkan, Direct3D 12, в разработке.</String>
+    <String key="RenderEngineDesc">Полный: OpenGL с тенями и отражениями, в новом симуляторе OpenGL 4.6. Старый, Упрощённый, Экспериментальный: старые версии симулятора, новая запустит Полный. Vulkan 1.4: если его нет в exe или карта не справится, новая версия запустит OpenGL, а старая Старый.</String>
    <String key="REOld">Старый</String>
    <String key="RESimp">Упрощённый</String>
    <String key="REExperimental">Экспериментальный</String>
@@ -865,4 +865,64 @@
    <String key="WarehouseSaved">На складе: {0}</String>
    <String key="WarehouseNothingToAdd">Выберите состав с транспортом</String>
    <String key="GfxGroupLevelTip">Уровень только для этой части графики</String>
+    <String key="REVulkan">Vulkan 1.4</String>
+    <String key="IdleVulkanOnly">Работает только с Vulkan.</String>
+    <String key="GfxColNewRenderer">Новый рендерер (OpenGL 4.6, Vulkan)</String>
+    <String key="Ini.gfx.antialiasing">Сглаживание TAA / DLSS</String>
+    <String key="Ini.gfx.dlss.preset">Пресет DLSS</String>
+    <String key="Ini.gfx.framegeneration">Генерация кадров</String>
+    <String key="Ini.gfx.reflex">NVIDIA Reflex</String>
+    <String key="Ini.gfx.raytracing">Отражения с трассировкой лучей</String>
+    <String key="Ini.gfx.raytracing.range">Дальность трассировки лучей</String>
+    <String key="Ini.gfx.vulkan.device">Видеокарта (Vulkan)</String>
+    <String key="Ini.gfx.ssr">Отражения в экранном пространстве (SSR)</String>
+    <String key="Ini.gfx.postfx.ao">Фоновое затенение</String>
+    <String key="Ini.gfx.postfx.ao.quality">Качество затенения</String>
+    <String key="Ini.gfx.postfx.ao.lighting">Затенение в фоновом свете</String>
+    <String key="Ini.gfx.lights.clustered">Кластерное освещение</String>
+    <String key="Ini.gfx.lights.shadows">Тени ламп и прожекторов</String>
+    <String key="Ini.gfx.contactshadows">Контактные тени</String>
+    <String key="Ini.gfx.shadow.sdsm">Каскады теней по сцене (SDSM)</String>
+    <String key="Ini.gfx.cabprobe">Зонд кабины</String>
+    <String key="Ini.gfx.cabprobe.interval">Обновление зонда каждые N кадров</String>
+    <String key="Ini.gfx.cabprobe.reflections">Кабина отражает себя</String>
+    <String key="Ini.gfx.cabprobe.bounce">Отражённый свет лампы в кабине</String>
+    <String key="Ini.gfx.fog">Туман</String>
+    <String key="Ini.gfx.fog.quality">Качество тумана</String>
+    <String key="Ini.gfx.clouds">Объёмные облака</String>
+    <String key="Ini.gfx.clouds.shadows">Тени облаков на земле</String>
+    <String key="Ini.gfx.grass">Трава</String>
+    <String key="Ini.gfx.grass.distance">Дальность травы</String>
+    <String key="Ini.gfx.grass.fadedistance">Трава исчезает на</String>
+    <String key="Ini.gfx.grass.density">Густота травы</String>
+    <String key="Ini.gfx.precipitation.particles">Осадки (частицы)</String>
+    <String key="Ini.gfx.postfx.bloom">Свечение ярких мест (bloom)</String>
+    <String key="Ini.gfx.postfx.autoexposure">Автоматическая экспозиция</String>
+    <String key="IniWord.same">Как MSAA выше</String>
+    <String key="IniWord.no">Выкл.</String>
+    <String key="IniWord.off">Выкл.</String>
+    <String key="IniWord.low">Низкое</String>
+    <String key="IniWord.medium">Среднее</String>
+    <String key="IniWord.high">Высокое</String>
+    <String key="IniWord.ultra">Ультра</String>
+    <String key="IniWord.on">Вкл.</String>
+    <String key="IniWord.boost">Вкл. + boost</String>
+    <String key="IniWord.ssao">SSAO</String>
+    <String key="IniWord.gtao">GTAO</String>
+    <String key="IniWord.volumetric">Объёмный</String>
+    <String key="IniWord.analytic">Аналитический</String>
+    <String key="IniWord.default">Автоматически</String>
+    <String key="IniWord.k">K: лучшее качество</String>
+    <String key="IniWord.j">J: меньше размытия</String>
+    <String key="IniWord.m">M: для режима Производительность</String>
+    <String key="IniWord.l">L: для Ультра производительность</String>
+    <String key="IniWord.x2">x2</String>
+    <String key="IniWord.x3">x3</String>
+    <String key="IniWord.x4">x4</String>
+    <String key="IniWord.taa">TAA</String>
+    <String key="IniWord.dlss">DLSS (масштабирование)</String>
+    <String key="IniWord.dlaa">DLAA (родное разрешение)</String>
+    <String key="IniWord.3_4">По умолчанию (3×4)</String>
+    <String key="IniWord.4_6">Высокое (4×6)</String>
+    <String key="IniWord.6_8">Ультра (6×8)</String>
 </Language>