diff --git a/StarterNG.Tests/ConfigFileTests.cs b/StarterNG.Tests/ConfigFileTests.cs
index 1eb356b..6618e99 100644
--- 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()
     {
diff --git a/StarterNG.Tests/GraphicsPresetTests.cs b/StarterNG.Tests/GraphicsPresetTests.cs
index 6a7b4c4..4331268 100644
--- 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);
diff --git a/StarterNG.Tests/SettingReachTests.cs b/StarterNG.Tests/SettingReachTests.cs
index 77e6e4f..68d633e 100644
--- 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)]
diff --git a/StarterNG.Tests/SettingsStoreTests.cs b/StarterNG.Tests/SettingsStoreTests.cs
index 6d8c21f..2198dcb 100644
--- 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()
     {
diff --git a/StarterNG/Application/SettingsStore.cs b/StarterNG/Application/SettingsStore.cs
index ca92875..6bcdbed 100644
--- 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
diff --git a/StarterNG/Classes/ConfigFile.cs b/StarterNG/Classes/ConfigFile.cs
index 63be091..0769175 100644
--- 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)
     {
diff --git a/StarterNG/Domain/Settings/GraphicsPreset.cs b/StarterNG/Domain/Settings/GraphicsPreset.cs
index 78abedd..a1ae91c 100644
--- 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>
diff --git a/StarterNG/Domain/Settings/SettingReach.cs b/StarterNG/Domain/Settings/SettingReach.cs
index b00af23..3bc5fc5 100644
--- 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";
 }
diff --git a/StarterNG/Domain/Settings/SimulatorKeys.cs b/StarterNG/Domain/Settings/SimulatorKeys.cs
index c391fe2..3193002 100644
--- 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"),
 
diff --git a/StarterNG/Domain/Settings/SimulatorSettings.cs b/StarterNG/Domain/Settings/SimulatorSettings.cs
index 5c22ad9..64183fc 100644
--- 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
     };
 
diff --git a/StarterNG/Infrastructure/Settings/SettingsSerializer.cs b/StarterNG/Infrastructure/Settings/SettingsSerializer.cs
index 4f54d74..3b0fc96 100644
--- 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) =>
diff --git a/StarterNG/Views/SettingTexts.cs b/StarterNG/Views/SettingTexts.cs
index 63edfc4..018a325 100644
--- 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));
diff --git a/StarterNG/Views/Settings.axaml b/StarterNG/Views/Settings.axaml
index 025bdc6..ef415fe 100644
--- 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}}">
diff --git a/StarterNG/Views/Settings.axaml.cs b/StarterNG/Views/Settings.axaml.cs
index 2523910..d4b0c70 100644
--- 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
     };
 
diff --git a/StarterNG/Views/SimulatorKeyRows.cs b/StarterNG/Views/SimulatorKeyRows.cs
index a59fea5..a6309b0 100644
--- 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
     };
 
diff --git a/StarterNG/startercfg/lang/cz.xml b/StarterNG/startercfg/lang/cz.xml
index 92f7e7a..4ffb30e 100644
--- 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>
diff --git a/StarterNG/startercfg/lang/en.xml b/StarterNG/startercfg/lang/en.xml
index b02cf92..b43be8e 100644
--- 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>
diff --git a/StarterNG/startercfg/lang/hu.xml b/StarterNG/startercfg/lang/hu.xml
index ae30b44..8fedefa 100644
--- 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>
diff --git a/StarterNG/startercfg/lang/pl.xml b/StarterNG/startercfg/lang/pl.xml
index 8570281..2e0d031 100644
--- 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>
diff --git a/StarterNG/startercfg/lang/ru.xml b/StarterNG/startercfg/lang/ru.xml
index d27fc69..208cb43 100644
--- 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>