Program.cs

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security.Principal;
using System.Threading;
using System.ServiceProcess;
using Microsoft.Win32;

namespace ExtraLowLatencyMod
{
    /// <summary>
    /// Профессиональный оптимизатор системных задержек и задержек ввода Windows NT (Unified Low-Latency Tool)
    /// Сборка в один автономный исполняемый (.exe) файл.
    /// </summary>
    public static class Program
    {
        // Импорт функции изменения разрешения аппаратного системного таймера
        [DllImport("ntdll.dll", SetLastError = true)]
        private static extern int NtSetTimerResolution(uint DesiredResolution, bool SetResolution, out uint CurrentResolution);

        // Импорт функций консоли для визуального тюнинга
        [DllImport("kernel32.dll", ExactSpelling = true)]
        private static extern IntPtr GetConsoleWindow();
        [DllImport("user32.dll")]
        private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);

        private const int SW_HIDE = 0;
        private const int SW_SHOW = 5;

        [STAThread]
        public static void Main(string[] args)
        {
            // Проверка аргументов командной строки для службы или установщика
            if (args.Length > 0)
            {
                string arg = args[0].ToLower();
                if (arg == "--service" || arg == "/service")
                {
                    // Запуск в режиме Windows Service
                    ServiceBase.Run(new LatencyBackgroundService());
                    return;
                }
                if (arg == "--install" || arg == "/install")
                {
                    InstallService();
                    return;
                }
                if (arg == "--uninstall" || arg == "/uninstall")
                {
                    UninstallService();
                    return;
                }
            }

            // Запуск GUI-подобной интерактивной консоли управления
            RunInteractiveConsole();
        }

        private static void RunInteractiveConsole()
        {
            Console.Title = "ExtraLowLatencyMod - Windows Hardware Latency Suite";

            // Проверка присутствия прав Администратора
            if (!IsAdministrator())
            {
                Console.Clear();
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("[КРИТИЧЕСКИЙ СБОЙ] Для применения твиков ядра нужны права Администратора!");
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("[РЕШЕНИЕ] Нажмите правой кнопкой мыши по С# EXE и выберите 'Запуск от имени Администратора'.");
                Console.ResetColor();
                Console.WriteLine("\nНажмите любую клавишу для безопасного выхода...");
                Console.ReadKey();
                return;
            }

            while (true)
            {
                Console.Clear();
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine(@"
███████╗██╗  ██╗████████╗██████╗  █████╗ ██╗      ██████╗ ██╗    ██╗
██╔════╝╚██╗██╔╝╚══██╔══╝██╔══██╗██╔══██╗██║     ██╔═══██╗██║    ██║
█████╗   ╚███╔╝    ██║   ██████╔╝███████║██║     ██║   ██║██║ █╗ ██║
██╔════╝ ██╔██╗    ██║   ██╔══██╗██╔══██║██║     ██║   ██║██║███╗██║
███████╗██╔╝ ██╗   ██║   ██║  ██║██║  ██║███████╗╚██████╔╝╚███╔███╔╝
╚══════╝╚═╝  ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝ ╚═════╝  ╚══╝╚══╝ 
");
                Console.ForegroundColor = ConsoleColor.White;
                Console.WriteLine("=====================================================================");
                Console.WriteLine("        СИСТЕМНЫЙ ОПТИМИЗАТОР ЗАДЕРЖЕК ВВОДА И ТАЙМЕРОВ ЯДРА         ");
                Console.WriteLine("=====================================================================");
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine("[✓] Приложение запущено с административными полномочиями OS.");
                Console.ResetColor();

                Console.WriteLine("\nВЫБЕРИТЕ ДЕЙСТВИЕ ДЛЯ ОПТИМИЗАЦИИ:");
                Console.ForegroundColor = ConsoleColor.Cyan;
                Console.WriteLine("1. Применить комплексные низкозадерживаемые твики (Registry, BCDedit, MMCSS)");
                Console.WriteLine("2. Включить аппаратный Message Signaled Interrupts (MSI) режим для всех PCI-устройств");
                Console.WriteLine("3. Запустить тайминговый драйвер в текущем окне (фиксация 0.5 мс / 2000 Гц)");
                Console.WriteLine("4. Установить тайминговый драйвер как автозапускаемую Windows-службу");
                Console.WriteLine("5. Полностью удалить фоновую службу из Windows");
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("6. Подробный статус-отчет по текущему таймеру ядра");
                Console.WriteLine("0. Выход");
                Console.ResetColor();
                Console.Write("\nВведите номер пункта > ");

                string choice = Console.ReadLine();
                switch (choice)
                {
                    case "1":
                        ApplyGlobalTimerTweaks();
                        OptimizeScheduler();
                        ShowReturnPrompt();
                        break;
                    case "2":
                        EnableMSIMode();
                        ShowReturnPrompt();
                        break;
                    case "3":
                        Console.Clear();
                        Console.ForegroundColor = ConsoleColor.Yellow;
                        Console.WriteLine("=====================================================================");
                        Console.WriteLine("          АКТИВАЦИЯ ЯДЕРНОГО ДРАЙВЕРА ВВОДА (0.50 мс - 2000Hz)        ");
                        Console.WriteLine("=====================================================================");
                        Console.ResetColor();
                        HoldMaximumResponsiveness();
                        return;
                    case "4":
                        InstallService();
                        ShowReturnPrompt();
                        break;
                    case "5":
                        UninstallService();
                        ShowReturnPrompt();
                        break;
                    case "6":
                        ShowTimerDiagnostics();
                        ShowReturnPrompt();
                        break;
                    case "0":
                        return;
                    default:
                        Console.ForegroundColor = ConsoleColor.DarkYellow;
                        Console.WriteLine("Неизвестный параметр. Попробуйте еще раз.");
                        Console.ResetColor();
                        Thread.Sleep(1500);
                        break;
                }
            }
        }

        private static void ShowReturnPrompt()
        {
            Console.ForegroundColor = ConsoleColor.DarkGray;
            Console.WriteLine("\nНажмите любую клавишу, чтобы вернуться в меню...");
            Console.ResetColor();
            Console.ReadKey(true);
        }

        public static void ApplyGlobalTimerTweaks()
        {
            try
            {
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("\n[*] Оптимизация тактовых параметров CPU ядра (BCDEdit)...");
                Console.ResetColor();

                // Запрет процессору пропускать такты аппаратного таймера
                ExecuteCommand("bcdedit", "/set disabledynamictick yes");

                // Перевод ядра на аппаратные TSC-такты чистого кремния вместо HPET
                ExecuteCommand("bcdedit", "/set useplatformclock no");
                ExecuteCommand("bcdedit", "/set tscsyncpolicy Enhanced");

                Console.WriteLine(" [+] Параметры DynamicTick и HPET в базе данных конфигурации загрузки настроены.");

                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("[*] Снятие ограничений Windows 11 на запросы разрешения таймера...");
                Console.ResetColor();
                string kernelPath = @"SYSTEM\CurrentControlSet\Control\Session Manager\kernel";
                using (RegistryKey key = Registry.LocalMachine.OpenSubKey(kernelPath, true))
                {
                    if (key != null)
                    {
                        key.SetValue("GlobalTimerResolutionRequests", 1, RegistryValueKind.DWord);
                        Console.WriteLine(" [+] Параметр GlobalTimerResolutionRequests установлен в 1 (глобально).");
                    }
                }
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"[!] Ошибка записи реестра таймера: {ex.Message}");
                Console.ResetColor();
            }
        }

        public static void OptimizeScheduler()
        {
            try
            {
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("\n[*] Разблокировка планировщика MMCSS мультимедиа распределения ресурсов...");
                Console.ResetColor();

                string profilePath = @"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Multimedia\SystemProfile";
                using (RegistryKey key = Registry.LocalMachine.OpenSubKey(profilePath, true))
                {
                    if (key != null)
                    {
                        // 0% резерва фоновым процессам - вся мощность активным окнам
                        key.SetValue("SystemResponsiveness", 0, RegistryValueKind.DWord);
                        // Отключение сетевого троттлинга карт (исключает пакетирование пинга)
                        key.SetValue("NetworkThrottlingIndex", unchecked((int)0xFFFFFFFF), RegistryValueKind.DWord);
                        Console.WriteLine(" [+] Ограничения системного приоритета CPU и Сети сняты.");
                    }
                }

                // Перевод дескрипторов задач игр на High
                string gamesTaskPath = @"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Multimedia\SystemProfile\Tasks\Games";
                using (RegistryKey key = Registry.LocalMachine.OpenSubKey(gamesTaskPath, true))
                {
                    if (key != null)
                    {
                        key.SetValue("GPU Priority", 8, RegistryValueKind.DWord);
                        key.SetValue("Priority", 6, RegistryValueKind.DWord);
                        key.SetValue("Scheduling Category", "High", RegistryValueKind.String);
                        key.SetValue("SFIO Priority", "High", RegistryValueKind.String);
                        Console.WriteLine(" [+] Категория 'Games' MMCSS переведена на высшие приоритеты.");
                    }
                }
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"[!] Ошибка твика MMCSS: {ex.Message}");
                Console.ResetColor();
            }
        }

        public static void EnableMSIMode()
        {
            try
            {
                Console.ForegroundColor = ConsoleColor.Yellow;
                Console.WriteLine("\n[*] Сканирование системной топологии физической шины PCI...");
                Console.ResetColor();

                string enumPath = @"SYSTEM\CurrentControlSet\Enum\PCI";
                using (RegistryKey baseKey = Registry.LocalMachine.OpenSubKey(enumPath, true))
                {
                    if (baseKey == null)
                    {
                        Console.WriteLine(" [!] Устройства PCI шины не обнаружены в текущем улье реестра.");
                        return;
                    }

                    int matches = 0;
                    foreach (string deviceId in baseKey.GetSubKeyNames())
                    {
                        using (RegistryKey devInstance = baseKey.OpenSubKey(deviceId, true))
                        {
                            if (devInstance == null) continue;
                            foreach (string subId in devInstance.GetSubKeyNames())
                            {
                                string devicePath = subId + @"\Device Parameters";
                                using (RegistryKey configKey = devInstance.OpenSubKey(devicePath, true))
                                {
                                    if (configKey == null) continue;

                                    using (RegistryKey msiKey = configKey.CreateSubKey(@"Interrupt Management\MessageSignaledInterruptProperties"))
                                    {
                                        if (msiKey != null)
                                        {
                                            // Активируем MSI
                                            msiKey.SetValue("MSISupported", 1, RegistryValueKind.DWord);
                                            // Запросы обрабатываются в один выделенный и быстрый вектор прерывания ядра
                                            msiKey.SetValue("MessageNumberLimit", 1, RegistryValueKind.DWord);
                                            matches++;
                                        }
                                    }
                                }
                            }
                        }
                    }
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.WriteLine($"[✓] Аппаратные прерывания MSI и приоритеты успешно включены для {matches} PCI-чипов!");
                    Console.ResetColor();
                }
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"[!] Ошибка MSI оптимизации: {ex.Message}");
                Console.ResetColor();
            }
        }

        public static void HoldMaximumResponsiveness()
        {
            uint desired = 5000; // 0.5 мс
            uint current;

            int result = NtSetTimerResolution(desired, true, out current);
            
            if (result == 0)
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine($"[АКТИВНО] Удержание осуществлено! Текущее разрешение Windows: {current / 10000.0:F4} мс.");
                Console.WriteLine("[СТАТУС] Микро-джиттер равен нулю. Частота тиков ядра зафиксирована на 2000 Гц.");
                Console.ResetColor();
                Console.WriteLine("\nДля сброса таймера в дефолт и выхода зажмите сочетание [Ctrl + C].");
                
                // Закрепление потока без создания нагрузки на CPU циклы
                Thread.Sleep(Timeout.Infinite);
            }
            else
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"[!] Ошибка вызова ntdll. NtSetTimerResolution вернул код сбоя: {result}");
                Console.ResetColor();
            }
        }

        private static void ShowTimerDiagnostics()
        {
            uint current;
            // Считываем текущее разрешение отправкой ложного SetResolution=false
            int result = NtSetTimerResolution(5000, false, out current);
            
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("\n================ ДИАГНОСТИКА ТАЙМЕРОВ ЯДРА ================");
            Console.ResetColor();
            Console.WriteLine($"Код опроса ntdll.dll: {result}");
            Console.WriteLine($"Текущий шаг прерывания Windows: {current / 10000.0:F4} мс");
            Console.WriteLine($"Приблизительная плотность кадров ввода: {(1000.0 / (current / 10000.0)):F1} Гц");
            
            if (current <= 5500)
            {
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine("Вердикт: Идеально. Включен Low-Latency режим (0.50 мс - 0.55 мс).");
            }
            else
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine("Вердикт: Требуется включение. Система работает на рваном таймере планировщика (~15.6 мс).");
            }
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("===========================================================");
            Console.ResetColor();
        }

        private static void InstallService()
        {
            try
            {
                string exePath = Process.GetCurrentProcess().MainModule.FileName;
                Console.WriteLine($"[*] Установка службы ExtraLowLatencyMod...");
                
                // Используем стандартную sc.exe утилиту Windows для регистрации службы
                ExecuteCommand("sc", $"create ExtraLowLatencyModService binPath= \"\\\"{exePath}\\\" --service\" start= auto displayname= \"ExtraLowLatencyMod Kernel Keeper\"");
                ExecuteCommand("sc", "description ExtraLowLatencyModService \"Удерживает разрешение глобального таймера Windows на 0.5 мс (2000 Гц) для полной ликвидации Input Lag.\"");
                ExecuteCommand("sc", "start ExtraLowLatencyModService");
                
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine("[✓] Фоновая служба успешно создана, добавлена в автозапуск Windows и запущена!");
                Console.ResetColor();
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"[!] Сбой инсталляции службы: {ex.Message}");
                Console.ResetColor();
            }
        }

        private static void UninstallService()
        {
            try
            {
                Console.WriteLine("[*] Остановка и удаление Windows Service...");
                ExecuteCommand("sc", "stop ExtraLowLatencyModService");
                ExecuteCommand("sc", "delete ExtraLowLatencyModService");
                
                Console.ForegroundColor = ConsoleColor.Green;
                Console.WriteLine("[✓] Служба ExtraLowLatencyModService успешно полностью удалена из системных ресурсов.");
                Console.ResetColor();
            }
            catch (Exception ex)
            {
                Console.ForegroundColor = ConsoleColor.Red;
                Console.WriteLine($"[!] Сбой удаления службы: {ex.Message}");
                Console.ResetColor();
            }
        }

        private static void ExecuteCommand(string fileName, string arguments)
        {
            try
            {
                ProcessStartInfo psi = new ProcessStartInfo
                {
                    FileName = fileName,
                    Arguments = arguments,
                    RedirectStandardOutput = true,
                    UseShellExecute = false,
                    CreateNoWindow = true
                };
                using (Process p = Process.Start(psi))
                {
                    p.WaitForExit();
                }
            }
            catch { }
        }

        private static bool IsAdministrator()
        {
            using (WindowsIdentity identity = WindowsIdentity.GetCurrent())
            {
                WindowsPrincipal principal = new WindowsPrincipal(identity);
                return principal.IsInRole(WindowsBuiltInRole.Administrator);
            }
        }
    }

    /// <summary>
    /// Манифест класса службы для бесконфликтной интеграции Windows Service в один .exe
    /// </summary>
    public class LatencyBackgroundService : ServiceBase
    {
        private Thread _timerThread;
        private bool _isRunning;

        [DllImport("ntdll.dll", SetLastError = true)]
        private static extern int NtSetTimerResolution(uint DesiredResolution, bool SetResolution, out uint CurrentResolution);

        public LatencyBackgroundService()
        {
            this.ServiceName = "ExtraLowLatencyModService";
            this.CanStop = true;
            this.AutoLog = true;
        }

        protected override void OnStart(string[] args)
        {
            _isRunning = true;
            _timerThread = new Thread(HoldLoop)
            {
                IsBackground = true,
                Priority = ThreadPriority.Lowest
            };
            _timerThread.Start();
        }

        private void HoldLoop()
        {
            uint desired = 5000; // 0.5 мс
            uint current;
            while (_isRunning)
            {
                // Посылаем запрос в ntdll
                NtSetTimerResolution(desired, true, out current);
                // Засыпаем на 30 секунд. Вызов удерживается, пока активна служба
                Thread.Sleep(30000);
            }
        }

        protected override void OnStop()
        {
            _isRunning = false;
            uint current;
            // Сбрасываем таймер в дефолт перед выгрузкой службы
            NtSetTimerResolution(5000, false, out current);
        }
    }
}