Category Archives: Cool Tools

More Discord Follies: Unactivated Download

Sometimes an update problem gets more interesting after the obvious fix succeeds. That just happened to me with Discord on Windows. WinGet insisted version 1.0.9267 was available, while my PC remained on 1.0.9266. Even stranger, forcing the upgrade did not change the reported installed version.

I tried WinGet, UniGetUI and Discord’s in-app updater. Nothing moved the needle. Eventually I performed a clean uninstall and reinstall. That exercise exposed what was really happening: version 1.0.9267 had downloaded, but Discord was still running 1.0.9266. That’s how I found myself engaged in more Discord Follies: unactivated download is present, but inert. WTF?

Unpacking More Discord Follies: Unactivated Download

The basic inventory command showed the mismatch clearly:
winget list --id Discord.Discord --exact --scope user

It reported 1.0.9266 installed and 1.0.9267 available. Discord was installed at user scope, which also produced an instructive side trip. An elevated WinGet session refused to uninstall the per-user package. Switching to a normal Windows Terminal session fixed that.

winget uninstall --id Discord.Discord --exact --scope user

After the uninstall succeeded, I checked for leftovers:

Test-Path "$env:APPDATA\Discord"
Test-Path "$env:LOCALAPPDATA\Discord"

Both returned True. With no Discord processes still running, I removed those directories and verified that both paths returned False. That gave me the clean slate I wanted.

The Clean Install Surprise!

Next came an explicit installation of the supposedly newer release:

winget install --id Discord.Discord --exact --version 1.0.9267 --scope user

WinGet found 1.0.9267, verified its installer hash and reported a successful installation. Yet another winget list still showed 1.0.9266 installed, with 1.0.9267 available. At first glance, that looked impossible.

The file system told a better story. I enumerated Discord’s version directories:

Get-ChildItem "$env:LOCALAPPDATA\Discord" -Directory -Filter "app-*" | Select-Object Name, FullName

There were two of them: app-1.0.9266 and app-1.0.9267. Checking the Discord.exe files confirmed that each directory contained the version its name advertised. Again: WTF?

Installed Is Not Activated, Apparently

The decisive check was to examine the running processes instead of trusting package inventory alone:

Get-Process Discord | Select-Object Id, Path,
@{N='FileVersion';E={$_.MainModule.FileVersionInfo.FileVersion}}

Every running Discord process came from app-1.0.9266. I then checked the per-user uninstall registration:

Get-ItemProperty HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\* |
Where-Object DisplayName -eq 'Discord' |
Select-Object DisplayName, DisplayVersion, InstallLocation, UninstallString

Windows likewise registered Discord as version 1.0.9266. In other words, WinGet was not hallucinating. Version 1.0.9267 really existed on disk, but 1.0.9266 remained the registered and active release.

The Nub of This Discord Folly Is…

Discord’s current generic stable update manifest identifies 1.0.9267 as the host version. I also found installation-specific manifest results that still identify 1.0.9266. That makes staged update selection a plausible explanation for this split state, though the local evidence alone doesn’t completely illuminate  Discord’s rollout policy.

Here, the important lesson is more general. When an updater says success but inventory disagrees, inspect three layers: package registration, files on disk and the executable that’s actually running. Those views might disagree: here they did so spectacularly.

For now, I’m leaving both Discord directories alone. Manually deleting the active release or rewriting its registration would create more, not less

Discord’s current generic stable update manifest identifies 1.0.9267 as the host version. We also found installation-specific manifest results that still identify 1.0.9266. That makes staged update selection a plausible explanation for the split state, although the local evidence alone cannot prove Discord’s rollout policy.

The important lesson is more general. When an updater says success but inventory disagrees, inspect three layers: package registration, files on disk and the executable actually running. Those views can disagree, and here they did spectacularly.

For now, I am leaving both Discord directories alone. Manually deleting the active release or rewriting its registration would create more, not less uncertainty. Here in Windows-World, sometimes the best troubleshooting means knowing exactly why you should stop troubleshooting. I’m done for now, and will wait to see what Discord does next. Sigh.

Further Reading

Discord stable Windows x64 update manifest

Discord Support, Windows Corrupt Installation

Facebooklinkedin
Facebooklinkedin

Revoking P16 CA-2011 Breaks Secure Boot Stalemate

For several days, my Lenovo ThinkPad P16 seemed stuck halfway through Microsoft’s Secure Boot certificate transition. The new 2023 certificates were present, but the Secure-Boot-Update task would not finish the job. Then I revoked the old Microsoft Windows Production PCA 2011 certificate. Finally, it looks like revoking P16 CA-2011 breaks Secure Boot stalemate!

The resulting Garlin check_UEFI-CA2023 audit is the kind of output Windows admins like to see, including yours truly. Every check passes. The Windows UEFI CA 2023 trust chain is active, the newer Boot Manager is in use, and the old PCA 2011 path is revoked.

What changed, and why did revocation apparently matter? That question is worth examining because this 2011-to-2023 transition is becoming increasingly important for Windows PCs.

P16 Breaks Secure Boot Stalemate

Before the final change, this P16 was not exactly broken. Secure Boot was on. Windows booted normally. The 2023 certificates had made their way into the firmware databases. Yet the overall migration remained incomplete.

Repeated efforts to trigger the Microsoft Secure-Boot-Update scheduled task did not transition to the expected state. The task sat at Ready, and Garlin’s checks continued to show that more work remained.

That distinction is useful. A system can remain operational while sitting between the old and new Secure Boot states. Seeing a scheduled task at Ready also does not prove that the complete certificate transition has occurred.

Microsoft Makes It a Staged Transition

Microsoft’s documentation helps explain why. Moving from the 2011 Secure Boot certificates to their 2023 replacements involves more than dropping a certificate into firmware. Microsoft says the change includes new Secure Boot certificates and a Windows Boot Manager signed by the updated trust. All those pieces work together as an explicit design.

Microsoft also treats revocation carefully. Its CVE-2023-24932 guidance warns that Secure Boot revocations can have persistent consequences. Once applied, they cannot simply be undone while Secure Boot remains in use. That’s a real reason why Microsoft has rolled related mitigations out in stages rather than treating them like an ordinary monthly update.

Enterprise guidance makes another dependency explicit. Adding Windows UEFI CA 2023 and untrusting Microsoft Windows Production PCA 2011 requires cooperation from device firmware. Differences among hardware and firmware therefore matter.

Revocation Supplies the Missing Shove

On my P16, requesting the PCA 2011 revocation was the move that finally altered the outcome. I would not claim that revoking PCA 2011 repaired a defective scheduled task. I cannot see enough of the task’s internal decision-making to verify that.

Nevertheless, the observable evidence supports a narrower and more useful conclusion. The machine had reached an intermediate Secure Boot state. Applying the revocation caused Windows and the firmware to complete the remaining transition work. Only then did the audit report the Secure Boot state as functionally complete and up-to-date.

That’s an important troubleshooting insight. When Secure-Boot-Update appears intransigent, the visible task state may be a symptom rather than the underlying cause. Certificate state, firmware state, Boot Manager signing and revocation state all need inspection.

Confirmation: (Mostly) Clean Garlin Check UEFI Results

That said, Garlin still reports two missing certificates.

These missing certificates serve different purposes from Windows UEFI CA 2023:

  • Microsoft UEFI CA 2023 signs third-party UEFI boot loaders and EFI applications.
  • Microsoft Option ROM UEFI CA 2023 signs third-party option ROMs.

They replace broader third-party trust previously supplied by the 2011 Microsoft UEFI certificate. Microsoft split the replacement into two certificates for finer control over third-party boot loaders and option ROMs.

Questioning the Final Garlin Repairs

However, the P16’s DB listing does not contain the old Microsoft Corporation UEFI CA 2011 certificate. Microsoft says the update task adds those two replacement certificates if the old Microsoft Corporation UEFI CA 2011 certificate exists in DB. It doesn’t so neither do they. Garlin’s script accurately observes that these two third-party certs are missing, but they don’t seem to interfere with proper boot behavior.

The decisive lines appear in the lead-in graphic as:

Windows Boot Manager [Windows UEFI CA 2023] is ALLOWED.
Registry: "WindowsUEFICA2023Capable" = 2
Registry: "UEFICA2023Status" = Updated
Windows BootMgr SVN 12.0
SkuSiPolicy.p7b is CURRENT.

The next screencap shows the tail-end of the Garlin check script results. I’ve run this repair three or more times and it never makes an impact on P16. That’s why I think it’s done, even though the check script still calls for those certs. Copilot says the 0x5800 modifier has a special meaning — namely:

  • 0x0800 requests installation of Microsoft Option ROM UEFI CA 2023 into DB.
  • 0x1000 requests installation of Microsoft UEFI CA 2023 into DB.
  • 0x4000 is a conditional modifier. It tells Windows to install those two certificates only if DB already contains the old Microsoft Corporation UEFI CA 2011 certificate.

Add ’em all together and  you get — wait for it — 0x5800. ‘Nuff said.

As far as I’m concerned, the P16 is fully updated and compliant. I had to do some learning to understand why. I did, and now I’m satisfied.

Further Reading

Microsoft Support, “How to manage the Windows Boot Manager revocations for Secure Boot changes associated with CVE-2023-24932” (KB5025885).
Microsoft Support, “Enterprise Deployment Guidance for CVE-2023-24932” (KB5053946).
Microsoft Support, “Updating Windows bootable media to use the PCA2023 signed boot manager” (KB5053484).
Microsoft Support, “When Secure Boot certificates expire on Windows devices” (KB5079373).

Facebooklinkedin
Facebooklinkedin

Steps to an Ecology of Boot

With apologies to Gregory Bateson, I’m reminded of his work from the tangle of elements around booting to Windows 11 rescue media in the era of Secure Boot. Indeed, backups don’t count for much if their rescue media won’t boot. I rediscovered that old truth while testing Macrium Reflect X rescue media on my Lenovo ThinkPad P16. What looked like a simple USB boot test turned into a useful tour of modern Windows boot ecology. It also defined (for me, at least) the essential steps to an ecology of boot in today’s world.

Think about it: the word “ecology” fits. Modern booting isn’t one thing. It’s an interaction among firmware, Secure Boot certificates, revocation policy, boot files, BitLocker, virtualization-based security, the recovery environment, and even the particular USB flash drive you choose.

Steps to an Ecology of Boot: First, Update Rescue Media

My first concern was the Macrium rescue image itself. I had already been working on a PowerShell repair script, fixmrrdv6.ps1, to bring its boot components into line with current Secure Boot requirements. The script updates the external EFI boot manager and relevant files inside boot.wim.

Garlin’s Check_BootMedia.ps1 supplied the essential reality check. An earlier test showed the external Windows Boot Manager as BANNED even though components inside boot.wim were ALLOWED. After correcting the source and running version 6 of the repair script, the external boot manager, the WinPE boot manager, and winload.efi all reported ALLOWED. The boot manager showed SVN 12.0.

That was lesson one: a rescue UFD can look perfectly ordinary in File Explorer yet contain boot components that current Secure Boot policy won’t accept.

Step 2: Get the $#@^! UFD Recognized in UEFI

Next came hardware discovery. A SanDisk 32 GB UFD (USB Flash Drive) didn’t appear in the P16 F12 boot menu. I moved it from one USB-A port to another. No joy. I also encountered the curious “USB FDD” boot choice while working through Windows recovery options. Selecting it did not produce a successful rescue boot.

At that point the problem had stopped looking purely like Secure Boot. If firmware won’t enumerate a device as a boot candidate, fixing the files on that device won’t go anywhere.

So I changed media. I built fresh Macrium rescue media on other UFDs, including a Mushkin Ventura Pro. Ultimately, an ADATA S102 became the device that successfully booted the P16. Go figure!

Step 3: Slogging Through Security Layers

The P16 sports a full complement of modern Windows protections. Secure Boot was on. BitLocker protected C:. Virtualization-based security and Device Guard were in the mix. That’s good for normal operation, but it introduces multiple variables when testing alternate boot media.

I suspended BitLocker protection for the experiment. I also temporarily turned Device Guard/VBS off. That did not make Windows “recognize USB.” Instead, it removed another security and code-integrity variable while testing whether or not the repaired rescue environment could actually start.

Importantly, Secure Boot stayed on. That made the successful test meaningful. I wasn’t simply bypassing the very mechanism I wanted the rescue disk to comply with.

Step 4: The Boot Circle Shows Up from the Rescue Disk

With the ADATA rescue UFD in place and the test conditions sorted out, I initiated the alternate boot. The P16 went black for quite a while. Then the familiar spinning circle appeared. Finally, Macrium Reflect’s WinPE rescue environment appeared.

That was the result I wanted. I opened a command prompt inside WinPE and later used wpeutil reboot to return the P16 to Windows.

Back in the running OS, I restored the normal protection state. BitLocker once again reported ProtectionStatus On. Subsequent checks showed Secure Boot on and virtualization-based security running.

What Did I Learn From This Tapdance?

The biggest lesson is that “bootable USB” is no longer a yes/no thing. A UFD may contain the right partition, filesystem, EFI directory, boot.wim, and loader files, yet still fail somewhere along the path from firmware enumeration to Windows PE.

Current Secure Boot policy makes its contents matter. BitLocker makes boot-state changes matter. Device Guard and VBS add another enforcement layer. Firmware decides whether the UFD works at all. And apparently the physical flash device matters, too.

That last point remains a mystery. The ADATA S102 worked where the Mushkin Ventura Pro did not. I don’t yet have a satisfying technical explanation for that. What I do have is a repeatable successful test using the ADATA. So that’s what I’ll use.

That’s troubleshooting in a nutshell. Change one variable where possible. Verify the state at every layer. Keep good tools handy. And never assume your rescue disk can rescue anything until you’ve actually booted it and seen it work. Here in Windows-World, rescue isn’t guaranteed unless you check it before the brown stuff hits the whirling blades!

Facebooklinkedin
Facebooklinkedin

Scripting Macrium Rescue Disk Repair

Here’s something I’ve been chewing on for the past few weeks. I’ve had help from a persistent and curiously passive interlocutor at ElevenForum.com. I still use Macrium Reflect to back up at least half of my PC fleet.

For whatever reason, the Macrium Software team has yet to update its Rescue Disk creation to accommodate Secure Boot requirements. That’s what led me to scripting Macrium Rescue Disk repair using Copilot and PowerShell. Therein hangs today’s post…

What’s Involved in Scripting Macrium Rescue Disk Repair?

Basically, I asked Copilot to build a PowerShell script to fix the Macrium Rescue Disk for Secure Boot. Why? I use Secure Boot on all my PCs.

I can’t restore a Reflect boot image unless the Rescue Disk will actually BOOT the target PC. Only then can I perform the restore operation.

For the record, I’m using Macrium Reflect X, not the older versions numbered 8.x or lower. Working with Copilot, I had to chunk through three, then four versions before the script worked on my PC.

That PC is Flo6, my B550-based desktop. It has an MSI MAG Tomahawk MAX motherboard, Ryzen 7 5800X, NVIDIA RTX 3070 Ti, and 64GB RAM.

Using Copilot Requires LOTS of Trial and Error

The output from the script itself documents what it does pretty well, so I reproduce it here:

==============================================================
  fixmrrdv6.ps1  --  Secure Boot SVN Repair Tool              
==============================================================
   [>>] Validating target drive: G:                                                                                                                       
       [OK] Drive label  : ESD-USB                                                                                                                       
       [OK] File system  : FAT32
       [OK] Size         : 14.4 GB
       [!!] Label 'ESD-USB' does not contain MACRIUM -- verify correct drive.
   [>>] Locating boot.wim on rescue media                                                                                                                 
       [OK] Found WIM    : G:\sources\boot.wim                                                                                                           
       [OK] WIM size     : 557.2 MB
   [>>] Locating Secure Boot source files from live Windows
       [OK] External source: C:\Windows\Boot\EFI_EX\bootmgfw_EX.efi
       [OK] WIM source     : C:\Windows\Boot\EFI_EX\bootmgfw_EX.efi
       [OK] Winload source : C:\Windows\System32\winload.efi
       [OK] Backup root    : C:\Users\ed\AppData\Local\Temp\FixMRRD_Backups_20261026_155946
   [>>] Replacing external bootmgfw.efi on USB
       [OK] Backed up: bootmgfw.efi -> C:\Users\ed\AppData\Local\Temp\FixMRRD_Backups_20261026_155946\ExternalUSB\bootmgfw.efi
       [OK] Replaced: bootmgfw.efi from EFI_EX\bootmgfw_EX.efi
   [>>] Patching boot.wim (index 1) with Secure Boot files
       [OK] Mount directory  : C:\Users\ed\AppData\Local\Temp\FixMRRD_WimMount_20261026155946
       [!!] Mounting WIM (this may take a minute)...
       [OK] WIM mounted successfully.
       [OK] Backed up: bootmgfw.efi -> C:\Users\ed\AppData\Local\Temp\FixMRRD_Backups_20261026_155946\WIM\bootmgfw.efi
       [OK] Patched: bootmgfw.efi
       [OK] Backed up: bootmgfw_EX.efi -> C:\Users\ed\AppData\Local\Temp\FixMRRD_Backups_20261026_155946\WIM\bootmgfw_EX.efi
       [OK] Patched: bootmgfw_EX.efi
       [OK] Backed up: winload.efi -> C:\Users\ed\AppData\Local\Temp\FixMRRD_Backups_20261026_155946\WIM\winload.efi
       [OK] Patched: winload.efi
       [!!] Committing and unmounting WIM (this may take a minute)...
       [OK] boot.wim patched and committed successfully.

==============================================================
  All done! Secure Boot SVN repair completed successfully.
  Run check_bootmedia.ps1 against the USB to verify ALLOWED.
==============================================================

To debug this script, I kept catching error messages as it ran, reporting them to Copilot, and re-running rewritten versions until it produced a clean Rescue Disk on Flo6. How did I define that? By running Garlin’s check_bootmedia.ps1 script against it until it returned a clean result (all boot managers use CA 2023, show up as ALLOWED, use SVN 12.0). And indeed it works on Flo6 right now just fine.

What Works for Me, May Not Work for YOU

What I’ve learned from my interlocutor on ElevenForum.com is the following. Though the script runs on Flo6, it doesn’t run on his PC. Based on the errors he’s reporting, I think I know what’s going on. Writing files into a mounted WIM is tricky, as I’ve learned, and requires extensive mucking about with permissions. System ownership must be taken over, writing work done, then restored to pristine condition. This takes work and some understanding of how ACLs and the Trusted Installer work in modern Windows OSes (10 and 11, basically, though the same behaviors also hold in current Windows Server versions).

When things go wrong for me with a script like this one, I attack them with Copilot until they work. My interlocutor, apparently, isn’t inclined to do this himself. But that’s what it takes to make things work on YOUR PC here in Windows-World: a dogged determination to keep iterating until the error messages no longer appear, and the resulting functionality does what you want it to do.

Post some comments here to let me know if you’re OK with this “exercise is left to the reader to fully complete” approach. Those who really want the script to fix their Macrium Reflect X Rescue Disks can ask for it, and I’ll send it to them. But they’ll have to be ready to make it work on their PCs to achieve its intended use!

Facebooklinkedin
Facebooklinkedin

MS Store Sees Update Coming, But…

It’s definitely a Monday. I’ve got interesting oddities popping up right and left. Take a look at the intro screenshot. When I run “Check for updates” from the Updates and Downloads tab in MS Store, it sometimes tells me that it itself needs an update, but couldn’t run because the “App was in use” (as shown). Funnily enough, if I close the app then re-open it, that pending update no longer shows but is also missing in the “Recent updates list” below. Thus, MS Store sees update coming, but no longer see it when it’s done. Weird…

Yes: MS Store Sees Update Coming, But No History

I had to ask Copilot what it thought was going on. To my relief, it confirms that indeed this particular self-update goes untracked:

Once the update completes, the Store process reloads into its newly installed package. The Updates & downloads page then refreshes from inside that replacement package. Apparently, the Store does not reliably copy its own completed update into the user-facing Recent updates list.

So it seems to be a case of “Lost in transition” rather than “Lost in translation.” Just another interesting oddity to notice. It doesn’t seem to exact any consequences, as far as I can tell.

Self-Updates Are Almost Always Interesting

In working with WinGet over the past 6-plus years, I’ve noticed that things get interesting when running packages have to handle their own updates. That’s what I call a self-update. For example, WinGet itself (Microsoft.AppInstaller), PowerShell, and Windows Terminal, all get a little flustered when they themselves handle updates in an active Windows Terminal session.

Usually, the right way to straighten things out is to close them, then re-open them. Sometimes, a reboot may be needed to untangle the thorniest of self-updates. But gosh, this is the first time I can recall that the update history itself drops a stitch and misses its own incremental advancement. That’s odd, even here in Windows-World. But it’s all part of its strange charm…

Facebooklinkedin
Facebooklinkedin

MediaMonkey Version Info Fools WinGet

MediaMonkey recently taught me another lesson about package managers: version information has to agree at both ends. Otherwise, automation can outstrip itself. Indeed, I’ve just witnessed how truncated MediaMonkey version info fools winget into a looping update.

I had already run a broad WinGet update using winget upgrade –all –include-unknown. MediaMonkey was included and its update completed successfully. Later, though, WinGet proffered MediaMonkey again. That follow-on install also completed successfully, leaving me wondering why an already updated application looked stale.

How Truncated MediaMonkey Version Info Fools WinGet

The lead-in screenshot makes a mismatch plain. WinGet identifies the package as VentisMedia.MediaMonkey.2024. Its list output reports the installed Version as “2024,” but Available is “2024.2.2.3222.” From WinGet’s perspective, those strings do not match.

A PowerShell registry query settles the question from the installed-software side. MediaMonkey 2024 records DisplayVersion simply as “2024.” The same entry identifies Ventis Media Inc. as Publisher and points to the 32-bit Program Files installation location.

Get-ItemProperty `
HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*,
HKLM:\Software\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*, `
HKCU:\Software\Microsoft\Windows\CurrentVersion\Uninstall\* `
-ErrorAction SilentlyContinue | `
Where-Object DisplayName -Like '*MediaMonkey*' | `
Select-Object DisplayName, DisplayVersion, Publisher, InstallLocation, PSPath

That is the crux of the problem. The installed application advertises “2024.” The WinGet package advertises “2024.2.2.3222.” Thus, WinGet continues to find the need to upgrade even after installing the latest package.

A Blocking Pin Breaks the Loop

Rather than let routine upgrade runs keep revisiting MediaMonkey, I added a blocking pin against the package ID:

winget pin add --id VentisMedia.MediaMonkey.2024 --blocking

The next winget pin list confirms the result. MediaMonkey 2024 appears with version 2024, source winget, and pin type Blocking.

That choice is deliberately stronger than an ordinary pin. Microsoft documents a blocking pin as preventing upgrades through both “winget upgrade –all” and a direct package upgrade. The package must be unpinned before a normal WinGet upgrade can proceed, although the force option can override this specific pin behavior.

Watch, Wait, Then Unpin When It’s Time

For now, blocking is exactly what I want. The installed MediaMonkey is current based on the package I just installed, while its reported version remains too broad and unspecific for WinGet to compare cleanly.

The next move is patience. I will periodically check MediaMonkey and the WinGet package metadata. When a genuine new release appears, I can remove the block, run the upgrade, and see whether the installed DisplayVersion finally reports a fully qualified build number.

If that happens, WinGet should again have comparable version strings to work with. If not, the blocking pin can go right back on.

Version Metadata Makes the Difference

Yesterday’s episode is a useful reminder that WinGet can only act on available version information. A successful install does not guarantee the application and package catalog describe the result identically.

Here, two command-line checks tell the whole story. First, winget list exposes the disagreement. Second, PowerShell confirms what Windows knows about MediaMonkey. Until those values line up, a blocking pin turns an annoying repeat upgrade into a controlled watch-and-wait problem. Case closed, at least for now. Here in Windows-World it’s been added to the list of things I must watch and remember. It’s a big and pretty active one, as Windows pros already know…

Facebooklinkedin
Facebooklinkedin

F10 Toggles A14 Camera

At some point in the recent past, I must’ve struck the F10 key on my Asus Zenbook A14. How do I know that? Because the Fn keys on the top row of that laptop serve dual purposes. As I’ve now learned, F10 toggles the A14 camera on and off. That explains why Windows Hello facial recognition quit working on that PC: I had turned off the camera!

If you look at the camera symbol in Windows Hello setup (lead-in graphic), the left-to-right slash means “no camera!” Indeed, seeing that symbol sent me down the “turn it back on” path.

Tiny Orange LED sez: F10 Toggles A14 Camera

Now that I know what to look for, I also see a teeny-tiny orange LED at the left of the half-height F10 key. In fact, the glowing LED tells me that the camera is inactive. Good to know.

Better still, once I turn the camera back on, the machine amazes me with how quickly Windows Hello recognizes me and logs me in when I sit down in front of it.

To steer clear of other potholes, I had Copilot build me a table of Fn/hotkeys for my further education and enlightenment. So, here goes:

ASUS Zenbook A14 UX3407QA function keys

Key Secondary function
F1 Speaker mute/unmute
F2 Volume down
F3 Volume up
F4 Display brightness down
F5 Display brightness up
F6 Touchpad on/off
F7 Keyboard backlight brightness
F8 Display/output mode
F9 Microphone mute/unmute
F10 Camera on/off
F11 Screen capture / Snipping Tool
F12 MyASUS

Here in Windows-World, it pays to know and use the controls for one’s hardware. Admittedly, I’ve been remiss in not learning these controls sooner. However, now I know, and I consider myself better qualified to drive this thing.

Of course, let’s see what kind of upcoming accident propels my understanding further. After all, that’s often how I learn things best: try it and see what happens! Or, sometimes, try it by accident and learn what I just did.

Facebooklinkedin
Facebooklinkedin

Production Switchover Produces Unexpected Speed-up

Over the past week, I’ve switched two older PCs from Insider Preview to Production builds. For the record, the X380 is a 2018 vintage Lenovo ThinkPad X380 Yoga, while the X12 is a 2021 vintage Lenovo ThinkPad X12 Convertible Tablet Gen 1. Happily, this production switchover produces unexpected speed-up for both machines across the board. Let me tell  you more…

Why Production Switchover Produces Unexpected Speed-up

MS has been on a bit of a tear lately, trying to repair its user credibility and brand image for Windows 11. Industry observers have noticed and published stories like these:

My usual response to such coverage is “Yeah, right, sure…” (delivered with an eye roll and a skeptical tone of voice). But this time, it’s possible that the coverage is both apt and accurate.

What Improvements Might One Find in 26H2?

After the switchover from Beta (X380) and Insider Preview (X12) builds on those PCs to mainline 26H2 (Build 26300.9711 as I write this). I’ve noticed snappier response and quicker completions across the board on both machines. Some of this, says Copilot (and I agree) is simply a natural outcome of switching from a more heavily instrumented and closely monitored Insider release to a more streamlined and less tarted-up production release.

But there’s more. I am seeing noticeably faster performance on both PCs including:

  • Improved system responsiveness
  • Faster app launch times
  • Faster File Explorer
  • Lower RAM usage
  • Reduced latency in UI interactions

Case in point: I just ran winget upgrade -all --include-unknown on both PCs and they ran updates on CrystalDiskInfo, WinScript, CoreTemp and (as shown) MS.Gameinput. All did their work — checking the manifest, showing the update list, then performing the individual updates — enough faster than their previous usual that I noticed an improvement.

Same thing goes for app launches, installs and uninstalls outside of WinTerm. As old as these two machines are, I feel like they’ve gained a new lease on life. Here in Windows-World, that’s a win! Maybe I didn’t shoot myself quite as badly in the foot with the “Let’s try Installation Assistant and see what happens” experiment on these PCs as I had originally feared. Woo-hoo!

Facebooklinkedin
Facebooklinkedin

PowerToys Gets Double Upgrade

Here’s something I’ve not seen  before. As is my usual practice, I ran winget upgrade --all --include-unknown this morning. Upon returning to WinTerm after it was done I noticed something odd. The version number in the release notes for PowerToy (open automatically after any release) was higher than the target version in the Winget uprade info. Upon closer examination, I determined this is a case where PowerToys gets “double upgrade”. Let me explain…

How PowerToys Gets Double Upgrade

Indeed, winget took PowerToys to the targeted version (0.102.2862.0). But in the meantime, the PowerToys (PT) team released a higher-numbered version (0.102.2883.0). And because I have PT configured to auto-update upon launch, once the winget driven update finished, the program itself took care of the second one on its own.

For a split second, I wondered about possible pixies — or gremlins, maybe. Then  I realized it’s all baked into the way the app itself behaves. Here in Windows-World what looks like a mystery can just be the way things look odd sometimes, even as they do what they’re supposed to.

That’s what passes for entertainment these days here at Chez Tittel. And I admit, I’m both entertained and bemused.

Edge Rears Its Install Technology Head

Speed reader that I am I also initially conflated the message from Edge — entirely in character and seen many times before, BTW — with what PowerToys was doing. Not so. I just had to run the updater inside Edge itself and this momentary hiccup also cleared.

Keeping things updated is as much about remembering edge cases and exceptions as it is about following the channel in the river of new packages continuously showing up via winget. I do have to remind myself about that occasionally. But again: it’s all in good fun here in Windows-World.

Facebooklinkedin
Facebooklinkedin

UniGetUI Handles Discord Updates

In my September 16 post, “WinGet Mistakenly Reports Discord as Pinned,” I covered a quirk in how winget labels certain packages. I was reminded of same, as I observed that UniGetUI hanldes Discord updates easily and directly. If winget marks Discord as pinned and skips it, how can UniGetUI update it anyway? Let me ‘splain it to you.

How UniGetUI Handles Discord Update, While WinGet Fails

It is a handling difference that distinguishes the two package managers. Actually, WinGet itself stumbles only when using update --all. WinGet actually CAN handle a Discord update but it has to be commanded correctly and directly. UniGetUI uses WinGet to get (at least some of) its work done (also works with Chocolatey, Scoop, etc.). The trick turns out to hinge on how WinGet is told to upgrade Discord. The blanket approach just described fails because of a manifest flag (see 9/16 post for deets). Winget simply skips over that upgrade.

UniGetUI does things differently. Under the hood, it calls winget using an explicit package ID for each app that needs an update. For Discord it works just as if it had entered

winget upgrade --id Discord.Discord --include-pinned

at a command line (cmd.exe or PowerShell). In fact, WinGet will update Discord if you use similar syntax, to wit:

winget upgrade --id Discord.Discord --force

Manual Override Is a One-Off Avventura

Please note: the preceding command string is a one-time override. The RequireExplicitUpgrade: true flag that causes WinGet to skip over Discord for WinGet upgrade --all stays in place. Future winget upgrade –all runs will still skip Discord, so you would need to repeat the command each time you wanted to force that update manually.

UniGetUI’s approach turns this winget blind spot into a non-issue for anyone who prefers a GUI workflow. I’m actually coming to like this program more and more because of its consistent, user-friendly package handling. But WinGet remains number one in my heart because it’s command-line native, and readily susceptible to scripting and automation.

Facebooklinkedin
Facebooklinkedin