Deribbonizer for Classic File Explorer

hdmi · Jun 5, 2025

As the title says, this tool (written by me) removes the ribbon from each newly opened File Explorer window if you are using ExplorerPatcher settings > File Explorer > Control Interface > Windows 10 Ribbon (or this tweak—Option Three).

Please be aware that I haven't yet tested the program for very long yet. So, use it at your own risk.

To compile the program, copy-paste the code below to a new batch (.bat) file, then run the batch file. It uses the built-in C# 5 compiler of .NET Framework 4.8.1, which is available in Windows 11 by default. After you run the batch file, you should be able to find the file Deribbonizer.exe in the same folder.

I designed Deribbonizer such a way that it runs as a console application silently in the background. To quit the application, you can simply run it again on the command line with a /quit parameter switch (or simply create a new desktop shortcut, and put the command in its target field).

Deribbonizer.exe /quit

Also note, if certain types of errors occur, the program logs them to a log file in the same folder.

How it works

Deribbonizer uses Windows built-in UI Automation capabilities to listen for specific Automation events that Windows fires when a window opens. This approach is vastly more efficient compared to constant polling of System.Activator.CreateInstance(Type.GetTypeFromProgID("Shell.Application")).Windows collection object, with some minor caveat.

To prevent the application's memory usage from growing forever, I made an attempt at implementing Garbage Collection in a more optimized manner. It helps to slow down the memory growth for sure, but doesnt completely fix the problem. So, I had to come up with an additional strategy. That is, to make the application automatically restart itself after it sees that its memory usage got a little bit too big.

I know that someone who has better knowledge about how to write a mod for Windhawk should be able to make my program obsolete, BUT... my approach doesn't require to hook into explorer.exe, and, you don't need to install anything for it to work. Another reason why I decided to use UI Automation for this purpose was to open the road for future ideas on customizing the classic File Explorer (and various other things...) to add advanced functionalities to it without the need to learn how to write my own mod for Windhawk.

Here is the code:

Batch:

// 2>NUL&@ECHO OFF&CLS&GOTO batch
/*
:batch
FOR /F "tokens=* USEBACKQ" %%F IN (`REG QUERY "HKLM\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full" /v InstallPath`) DO SET "InstallPath=%%F"
SET InstallPath=%InstallPath:*REG_SZ =%
FOR /F "tokens=* Eol= " %%F IN ("%InstallPath%") DO SET "InstallPath=%%F"
IF EXIST "%InstallPath%csc.exe" ("%InstallPath%csc.exe" /out:"%~dp0\Deribbonizer.exe" /target:winexe "%~dpnx0" /lib:%InstallPath%WPF /r:UIAutomationTypes.dll,UIAutomationClient.dll) ELSE (ECHO ERROR - Missing csc.exe)
PAUSE&EXIT
*/

using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Automation;
using System.Windows.Forms;

class Program
{
    private const int HWND_MESSAGE = -3; // Message-Only Window
    private const uint WM_CLOSE = 0x0010; // Close message
    private const string WINDOW_CLASS_NAME = "MessageOnlyWindowClass";
    private const string ERROR_LOG_FILE = "error_log.txt";

    private static bool isQuitMsg;
    private static IntPtr hWndFind;
    private static IntPtr hWndMsg;
    private static Process process;

    [DllImport("user32.dll")]
    private static extern bool PostMessage(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

    [DllImport("user32.dll")]
    private static extern IntPtr DefWindowProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern ushort RegisterClassEx(ref WNDCLASSEX lpwcx);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr CreateWindowEx(
        int dwExStyle, string lpClassName, string lpWindowName,
        int dwStyle, int x, int y, int nWidth, int nHeight,
        IntPtr hWndParent, IntPtr hMenu, IntPtr hInstance, IntPtr lpParam);

    [DllImport("user32.dll")]
    private static extern bool DestroyWindow(IntPtr hWnd);

    private static IntPtr WindowProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
    {
        if (msg == WM_CLOSE)
        {
            isQuitMsg = true; // static
            try
            {
                if (process == null || process.HasExited)
                {
                    Environment.Exit(0);
                }
                if (hWndMsg != IntPtr.Zero)
                {
                    DestroyWindow(hWndMsg);
                    hWndMsg = IntPtr.Zero;
                }
                Automation.RemoveAllEventHandlers();
                GarbageCollect();
                process.Dispose();
                process = null;
                Environment.Exit(0);
            }
            catch (Exception ex)
            {
                LogError(ex);
            }
            Environment.Exit(0);
        }
        return DefWindowProc(hWnd, msg, wParam, lParam);
    }

    // ******************************** Main ********************************
    static void Main(string[] args)
    {
        process = Process.GetCurrentProcess(); // static
        bool isQuitCommand = args.Length == 1 && args[0].Equals("/quit", StringComparison.OrdinalIgnoreCase);
        if (!isQuitCommand && args.Length != 0)
        {
            process.Dispose();
            Environment.Exit(0);
        }
        hWndFind = FindWindow(WINDOW_CLASS_NAME, "MessageWindow"); // static
        if (isQuitCommand)
        {
            Abort();
        }
        RegisterAndCreateWindow();
        AddAutomationEventHandler();
        if (hWndFind != IntPtr.Zero)
        {
            if (!PostMessage(hWndFind, WM_CLOSE, IntPtr.Zero, IntPtr.Zero))
            {
                LogError(new Exception("PostMessage failed in Main()"));
            }
            hWndFind = IntPtr.Zero;
        }
        System.Windows.Forms.Timer gcTimer = new System.Windows.Forms.Timer();
        gcTimer.Interval = 30000; // 30 seconds
        gcTimer.Tick += (sender, e) =>
        {
            try
            {
                if (isQuitMsg || process == null || process.HasExited)
                {
                    return;
                }
                Cleanup();
            }
            catch (Exception ex)
            {
                LogError(ex);
            }
        };
        gcTimer.Start();
        Application.Run();
    }
    // **********************************************************************

    private static void RegisterAndCreateWindow()
    {
        WindowProcDelegate windowProc = WindowProc;
        IntPtr functionPointer = Marshal.GetFunctionPointerForDelegate(windowProc);
        WNDCLASSEX wndClass = new WNDCLASSEX
        {
            cbSize = (uint)Marshal.SizeOf(typeof(WNDCLASSEX)),
            style = 0,
            lpfnWndProc = functionPointer,
            cbClsExtra = 0,
            cbWndExtra = 0,
            hInstance = IntPtr.Zero,
            hIcon = IntPtr.Zero,
            hCursor = IntPtr.Zero,
            hbrBackground = IntPtr.Zero,
            lpszMenuName = null,
            lpszClassName = WINDOW_CLASS_NAME,
            hIconSm = IntPtr.Zero
        };
        if (RegisterClassEx(ref wndClass) == 0)
        {
            Abort();
        }
        hWndMsg = CreateWindowEx(0, WINDOW_CLASS_NAME, "MessageWindow", 0, 0, 0, 0, 0, (IntPtr)HWND_MESSAGE,
                                 IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); // static
        if (hWndMsg != IntPtr.Zero)
        {
            return;
        }
        Abort();
    }

    private static void AddAutomationEventHandler()
    {
        Automation.AddAutomationEventHandler(
            WindowPattern.WindowOpenedEvent,
            AutomationElement.RootElement,
            TreeScope.Children,
            (sender, e) =>
            {
                var element = sender as AutomationElement;
                if (element.Current.ClassName == "CabinetWClass")
                {
                    PropertyCondition condition = new PropertyCondition(AutomationElement.ClassNameProperty, "UIRibbonCommandBarDock");
                    AutomationElement child = element.FindFirst(TreeScope.Children, condition);
                    if (child != null)
                    {
                        condition = new PropertyCondition(AutomationElement.ClassNameProperty, "UIRibbonCommandBar");
                        child = child.FindFirst(TreeScope.Children, condition);
                        if (child != null)
                        {
                            IntPtr hWndBar = (IntPtr)child.Current.NativeWindowHandle;
                            child = null;
                            if (hWndBar == IntPtr.Zero)
                            {
                                LogError(new Exception("hWndBar is IntPtr.Zero — UI element not found."));
                            }
                            else
                            {
                                if (!PostMessage(hWndBar, WM_CLOSE, IntPtr.Zero, IntPtr.Zero))
                                {
                                    LogError(new Exception("PostMessage failed in AddAutomationEventHandler()"));
                                }
                            }
                        }
                    }
                    condition = null;
                }
                element = null;
                try
                {
                    if (isQuitMsg || process == null || process.HasExited)
                    {
                        return;
                    }
                    Cleanup();
                }
                catch (Exception ex)
                {
                    LogError(ex);
                }
            }
        );
    }

    private static void Cleanup()
    {
        process.Refresh();
        if (process.WorkingSet64 > 39 << 20)
        {
            isQuitMsg = true; // static
            Process processNew = new Process();
            processNew.StartInfo.UseShellExecute = false;
            processNew.StartInfo.FileName = process.ProcessName + ".exe";
            processNew.Start();
            processNew.Dispose();
            processNew = null;
        }
        GarbageCollect();
    }

    private static void GarbageCollect()
    {
        if (GC.TryStartNoGCRegion(50 << 20))
        {
            GC.EndNoGCRegion();
        }
        GC.Collect(GC.MaxGeneration, GCCollectionMode.Optimized);
        GC.WaitForPendingFinalizers();
    }

    private static void Abort()
    {
        if (hWndFind != IntPtr.Zero)
        {
            if (!PostMessage(hWndFind, WM_CLOSE, IntPtr.Zero, IntPtr.Zero))
            {
                LogError(new Exception("PostMessage failed in Abort()"));
            }
        }
        process.Dispose();
        Environment.Exit(0);
    }

    private static void LogError(Exception ex)
    {
        File.AppendAllText(ERROR_LOG_FILE, String.Format("{0} :\n{1}\n", DateTime.Now, ex.Message));
    }
}

[StructLayout(LayoutKind.Sequential)]
struct WNDCLASSEX
{
    public uint cbSize;
    public uint style;
    public IntPtr lpfnWndProc;
    public int cbClsExtra;
    public int cbWndExtra;
    public IntPtr hInstance;
    public IntPtr hIcon;
    public IntPtr hCursor;
    public IntPtr hbrBackground;
    public string lpszMenuName;
    public string lpszClassName;
    public IntPtr hIconSm;
}

delegate IntPtr WindowProcDelegate(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);

hdmi · Saturday at 8:05 AM

Deribbonizer v2 is out.

Batch:

// 2>NUL&@ECHO OFF&CLS&GOTO batch
/*
:batch
FOR /F "tokens=* USEBACKQ" %%F IN (`REG QUERY "HKLM\SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full" /v InstallPath`) DO SET "InstallPath=%%F"
SET InstallPath=%InstallPath:*REG_SZ =%
FOR /F "tokens=* Eol= " %%F IN ("%InstallPath%") DO SET "InstallPath=%%F"
IF EXIST "%InstallPath%csc.exe" ("%InstallPath%csc.exe" /out:"%~dp0\Deribbonizer.exe" /target:winexe "%~dpnx0") ELSE (ECHO ERROR - Missing csc.exe)
PAUSE&EXIT
*/

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Text;
using System.Windows.Forms;

class Program
{
    private const int HWND_MESSAGE = -3; // Message-Only Window
    private const uint WM_CLOSE = 0x0010; // Close message
    private const uint PM_REMOVE = 0x0001; // Messages are removed from the queue after processing by PeekMessage
    private const int WAIT_OBJECT_0 = 0x00000000; // An object became signaled (an event, message, or process has triggered)
    private const int QS_ALLINPUT = 0x04FF; // ANY input message in the queue
    private const int MWMO_INPUTAVAILABLE = 0x0004; // Ensures messages are processed
    private const uint INFINITE = 0xFFFFFFFF; // No timeout
    private const int MAX_CLASS_NAME = 256;
    private const string WINDOW_CLASS_NAME = "MessageOnlyWindowClass";

    private static bool isRestartPending;
    private static Process process;
    private static HashSet<uint> processed = new HashSet<uint>();

    [DllImport("user32.dll")]
    private static extern bool PeekMessage(out MSG lpMsg, IntPtr hWnd, uint wMsgFilterMin, uint wMsgFilterMax, uint wRemoveMsg);

    [DllImport("user32.dll")]
    private static extern bool TranslateMessage(ref MSG lpMsg);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr DispatchMessage(ref MSG lpMsg);

    [DllImport("user32.dll")]
    private static extern uint MsgWaitForMultipleObjectsEx(uint nCount, IntPtr[] pHandles, uint dwMilliseconds, uint dwWakeMask, uint dwFlags);

    [DllImport("user32.dll")]
    private static extern bool PostMessage(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);

    [DllImport("user32.dll")]
    private static extern bool IsWindow(IntPtr hWnd);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr FindWindow(string lpClassName, string lpWindowName);

    [DllImport("user32.dll")]
    private static extern bool EnumChildWindows(IntPtr hWndParent, EnumChildProc lpEnumFunc, IntPtr lParam);

    [DllImport("user32.dll")]
    private static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);

    [DllImport("user32.dll")]
    private static extern IntPtr DefWindowProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern ushort RegisterClassEx(ref WNDCLASSEX lpwcx);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern IntPtr CreateWindowEx(int dwExStyle, string lpClassName, string lpWindowName, int dwStyle, int x, int y,
                                                int nWidth, int nHeight, IntPtr hWndParent, IntPtr hMenu, IntPtr hInstance, IntPtr lpParam);

    [DllImport("user32.dll")]
    private static extern bool DestroyWindow(IntPtr hWnd);

    [DllImport("user32.dll", SetLastError = true)]
    private static extern int GetClassName(IntPtr hWnd, StringBuilder lpClassName, int nMaxCount);

    private static bool EnumChildCallback(IntPtr hWnd, IntPtr lParam)
    {
        StringBuilder className = new StringBuilder(MAX_CLASS_NAME);
        GetClassName(hWnd, className, MAX_CLASS_NAME);
        if (className.ToString() == "UIRibbonCommandBar")
        {
            if (IsWindow(hWnd))
            {
                PostMessage(hWnd, WM_CLOSE, IntPtr.Zero, IntPtr.Zero);
            }
            else
            {
                if (!processed.Contains((uint)lParam))
                {
                    processed.Add((uint)lParam);
                }
            }
            return false; // Stop enumeration once found
        }
        return true; // Continue searching
    }

    private static bool EnumWindowsCallback(IntPtr hWnd, IntPtr lParam)
    {
        if (!processed.Contains((uint)hWnd))
        {
            StringBuilder className = new StringBuilder(MAX_CLASS_NAME);
            GetClassName(hWnd, className, MAX_CLASS_NAME);
            if (className.ToString() == "CabinetWClass")
            {
                EnumChildWindows(hWnd, EnumChildCallback, hWnd);
            }
        }
        return true; // Continue enumeration
    }

    private static IntPtr WindowProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
    {
        if (msg == WM_CLOSE)
        {
            return IntPtr.Zero;
        }
        return DefWindowProc(hWnd, msg, wParam, lParam);
    }

    // ******************************** Main ********************************
    static void Main(string[] args)
    {
        AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
        {
        };
        process = Process.GetCurrentProcess(); // static
        bool isQuitCommand = args.Length == 1 && args[0].Equals("/quit", StringComparison.OrdinalIgnoreCase);
        if (!isQuitCommand && args.Length != 0)
        {
            process.Dispose();
            Environment.Exit(0);
        }

        IntPtr hWndFind = FindWindow(WINDOW_CLASS_NAME, "MessageWindow"); // static

        // If the /quit parameter switch was specified
        if (isQuitCommand)
        {
            Abort(hWndFind);
        }

        // Register the window class
        WindowProcDelegate windowProc = WindowProc;
        IntPtr functionPointer = Marshal.GetFunctionPointerForDelegate(windowProc);
        WNDCLASSEX wndClass = new WNDCLASSEX
        {
            cbSize = (uint)Marshal.SizeOf(typeof(WNDCLASSEX)),
            style = 0,
            lpfnWndProc = functionPointer,
            cbClsExtra = 0,
            cbWndExtra = 0,
            hInstance = IntPtr.Zero,
            hIcon = IntPtr.Zero,
            hCursor = IntPtr.Zero,
            hbrBackground = IntPtr.Zero,
            lpszMenuName = null,
            lpszClassName = WINDOW_CLASS_NAME,
            hIconSm = IntPtr.Zero
        };
        if (RegisterClassEx(ref wndClass) == 0)
        {
            Abort(hWndFind);
        }
        windowProc = null;
        functionPointer = IntPtr.Zero;
        wndClass = new WNDCLASSEX { };

        // Create the Message-Only Window
        IntPtr hWndMsg = CreateWindowEx(0, WINDOW_CLASS_NAME, "MessageWindow", 0, 0, 0, 0, 0,
                                 (IntPtr)HWND_MESSAGE, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); // static
        if (hWndMsg == IntPtr.Zero)
        {
            Abort(hWndFind);
        }

        // Close the previous instance if any
        if (hWndFind != IntPtr.Zero)
        {
            PostMessage(hWndFind, WM_CLOSE, IntPtr.Zero, IntPtr.Zero);
            hWndFind = IntPtr.Zero;
        }

        // Create the Timers, and start them
        System.Windows.Forms.Timer gcTimer = new System.Windows.Forms.Timer();
        gcTimer.Interval = 30000; // 30 seconds
        gcTimer.Tick += (sender, e) =>
        {
            if (isRestartPending)
            {
                return;
            }
            process.Refresh();
            if (process.WorkingSet64 > 38 << 20)
            {
                isRestartPending = true; // static
                Process processNew = new Process();
                processNew.StartInfo.UseShellExecute = false;
                processNew.StartInfo.FileName = process.ProcessName + ".exe";
                processNew.Start();
                processNew.Dispose();
                processNew = null;
            }
            GarbageCollect();
        };
        System.Windows.Forms.Timer refreshTimer = new System.Windows.Forms.Timer();
        refreshTimer.Interval = 1000; // 1 second
        refreshTimer.Tick += (sender, e) => EnumWindows(EnumWindowsCallback, IntPtr.Zero);
        gcTimer.Start();
        refreshTimer.Start();
        GarbageCollect();

        // Start the Message Loop, using non-aggressive looping
        MSG msg;
        do
        {
            msg = new MSG();
            if (MsgWaitForMultipleObjectsEx(0, null, INFINITE, QS_ALLINPUT, MWMO_INPUTAVAILABLE) == WAIT_OBJECT_0)
            {
                while (PeekMessage(out msg, IntPtr.Zero, 0, 0, PM_REMOVE))
                {
                    TranslateMessage(ref msg);
                    DispatchMessage(ref msg);
                }
            }
        } while (msg.message != WM_CLOSE);

        // Gracefully exit
        if (hWndMsg != IntPtr.Zero && IsWindow(hWndMsg))
        {
            DestroyWindow(hWndMsg);
            hWndMsg = IntPtr.Zero;
        }
        GarbageCollect();
        process.Dispose();
        process = null;
        Environment.Exit(0);
    }
    // **********************************************************************

    private static bool IsWnd(uint i)
        {
            return !IsWindow(new IntPtr(i));
        }

    private static void GarbageCollect()
    {
        processed.RemoveWhere(IsWnd);
        if (GC.TryStartNoGCRegion(50 << 20))
        {
            GC.EndNoGCRegion();
        }
        GC.Collect(GC.MaxGeneration, GCCollectionMode.Optimized);
        GC.WaitForPendingFinalizers();
    }

    private static void Abort(IntPtr hWndFind)
    {
        if (hWndFind != IntPtr.Zero && IsWindow(hWndFind))
        {
            PostMessage(hWndFind, WM_CLOSE, IntPtr.Zero, IntPtr.Zero);
        }
        IntPtr hWnd = FindWindow(WINDOW_CLASS_NAME, "MessageWindow");
        if (hWnd != IntPtr.Zero)
        {
            PostMessage(hWnd, WM_CLOSE, IntPtr.Zero, IntPtr.Zero);
        }
        process.Dispose();
        Environment.Exit(0);
    }
}

[StructLayout(LayoutKind.Sequential)]
struct WNDCLASSEX
{
    public uint cbSize;
    public uint style;
    public IntPtr lpfnWndProc;
    public int cbClsExtra;
    public int cbWndExtra;
    public IntPtr hInstance;
    public IntPtr hIcon;
    public IntPtr hCursor;
    public IntPtr hbrBackground;
    public string lpszMenuName;
    public string lpszClassName;
    public IntPtr hIconSm;
}

[StructLayout(LayoutKind.Sequential)]
public struct MSG
{
    public IntPtr hwnd;
    public uint message;
    public IntPtr wParam;
    public IntPtr lParam;
    public uint time;
    public Point pt;
}

[StructLayout(LayoutKind.Sequential)]
public struct Point
{
    public int X;
    public int Y;
}

delegate bool EnumChildProc(IntPtr hwnd, IntPtr lParam);
delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
delegate IntPtr WindowProcDelegate(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);

Deribbonizer for Classic File Explorer

hdmi

Jack of all trades – master of none

How it works

My Computers

System One System Two

hdmi

Jack of all trades – master of none

My Computers

System One System Two

Similar threads

Latest Support Threads

Latest Tutorials

Deribbonizer for Classic File Explorer

hdmi

Jack of all trades – master of none

How it works​

My Computers

System One System Two

hdmi

Jack of all trades – master of none

My Computers

System One System Two

Similar threads

Latest Support Threads

Latest Tutorials

How it works