All posts by Ed Tittel

Full-time freelance writer, researcher and occasional expert witness, I specialize in Windows operating systems, information security, markup languages, and Web development tools and environments. I blog for numerous Websites, still write (or revise) the occasional book, and write lots of articles, white papers, tech briefs, and so forth.

Using WinLogo Glyph in FastFetch

FastFetch is a lightning-fast system information tool that runs in the terminal and displays your OS, CPU, GPU, memory, and disk details in a clean two-column layout. It ships with built-in text-art logos for major OSes. Alas, the default Windows logo in FastFetch is a modest ASCII rendering using the letter “l”. This post shows you how to replace it with the Windows 11 Nerd Font glyph. I call it the WinLogo glyph myself. And indeed, using the winlogo glyph in FastFetch is easy thanks to two short PowerShell scripts.

How Easy Is Using WinLogo Glyph in FastFetch?

Nerd Fonts are patched programming fonts that include hundreds of extra icons in their Private Use Area. The Windows 11 logo lives at Unicode code point U+E62A. When your terminal uses a Nerd Font such as CaskaydiaCove Nerd Font or JetBrainsMono Nerd Font, that code point renders as the familiar four-pane Windows 11 logo.

However, each U+E62A glyph is double-width. In other words, it occupies two terminal columns rather than one. That behavior matters when you configure FastFetch’s width parameter, as I’ll show later on. Knowing this upfront saves you trial and error later.

How FastFetch Reads a Custom Logo File

FastFetch supports a logo type called file. With this type, FastFetch reads a plain-text file and renders its contents to the left of your system information panel. Inside that file, color tokens such as $1 map to ANSI colors you define in config.jsonc. FastFetch re-applies the color at the start of each logo line, so any segment that needs consistent coloring must carry its own $1 re-arm token.

The design I used is a 2×2 arrangement of four 8×8 glyph blocks. Together, they form a large Windows logo built from smaller Windows logos. Each row contains two groups of eight glyphs separated by four spaces, with a single space between individual glyphs inside each group. A single blank line divides the top two blocks from the bottom two, giving the overall shape a clean four-pane look.

The key trick: after the left block and the four-space gap, FastFetch can silently drop the active color. Adding a second $1 token directly before the right block re-arms the color and keeps both sides uniformly blue across all 17 lines of the file. I figured this out by experiment, but I’m happy to share this “secret” openly.

Example 1: Writing the 8×8 Logo File

Run the following script in PowerShell 7. It writes the logo file with UTF-8 no-BOM encoding, which FastFetch requires to interpret this glyph correctly.

Example 1: win11logo.txt generator

$g = [char]0xE62A
$b = "$g $g $g $g $g $g $g $g"
$r = '$1 ' + $b + ' $1' + $b + ' '
$gap = '$1 ' + (' ' * 28)
$logo = ($r,$r,$r,$r,$r,$r,$r,$r,$gap,$r,$r,$r,$r,$r,$r,$r,$r) -join [char]10
[System.IO.File]::WriteAllText(
"$env:USERPROFILE\.config\fastfetch\win11logo.txt",
$logo,
[System.Text.UTF8Encoding]::new($false)
)

Note: the foregoing text is formatted for cut’n’paste use. Parsing it for human readability doesn’t work well in WordPress. Sorry! If you don’t have a fastfetch directory set up, start with this ahead of the previous commands: New-Item -ItemType Directory -Force "$env:USERPROFILE\.config\fastfetch" | Out-Null.

The [char]0xE62A expression converts the Unicode code point to an actual glyph character at runtime. The backtick before each $1 token tells PowerShell to treat the dollar sign as a literal character rather than the start of a variable name. The $gap variable fills the blank middle row with enough spaces so that FastFetch won’t collapse it.

Example 2: Write the FastFetch Config File

With the logo file in place, the next step is updating config.jsonc. The width value tells FastFetch how many columns to reserve for the logo panel. FastFetch counts each glyph as one character, not two display columns. Therefore, set width to the character count of the longest line in the logo file, not to the visual column count. For this 8×8 layout, that value is 38.

The height value is 17, matching the total line count of the logo file: eight rows, one blank gap row, and eight more rows. The color key maps $1 to Windows blue via the 24-bit ANSI code 38;2;0;120;212. A trailing space at the end of each logo row ensures the rightmost glyph renders in blue rather than in the terminal’s default foreground color.

Example 2: config.json generator
$lp = ("$env:USERPROFILE\.config\fastfetch\win11logo.txt") -replace '\\','/'
('{"logo":{"source":"' + $lp + '","type":"file","color":{"1":"38;2;0;120;212"},"width":38,"height":17,"padding":{"top":0,"left":1,"right":1}},"modules":["title","separator","os","host","kernel","uptime","packages","shell","display","cpu","gpu","memory","disk","battery"]}') | Set-Content "$env:USERPROFILE\.config\fastfetch\config.jsonc" -Encoding utf8NoBOM

Tips and Gotchas

A few points are worth keeping in mind before you run these scripts.

First, the default font must be a Nerd Font. The U+E62A glyph renders as a plain box or question mark in any non-patched font. CaskaydiaCove Nerd Font, JetBrainsMono Nerd Font, and FiraCode Nerd Font are all reliable choices that include the Windows logo glyph.

Second, width tuning requires some trial and error. If the right-side block renders in white instead of blue, increase width by two or three. If the gap between the logo and the info panel is too wide, decrease width by the same amount. The trailing space in each logo row prevents the rightmost glyph from getting clipped by the color boundary.

Third, always use Set-Content with -Encoding utf8NoBOM for the config file and [System.IO.File]::WriteAllText with an explicit UTF8Encoding $false object for the logo file. PowerShell’s default encoding on Windows adds a byte-order mark that FastFetch does not handle gracefully when reading Nerd Font glyphs. I learned this the hard way, so you don’t have to!

Enjoying the Fruits of Your Labor

After both scripts run, type fastfetch at the prompt. You should see a bold, blue 4×4 Windows logo grid on the left, assembled from 256 individual Windows 11 glyphs, flanking a full system information panel on the right. The result is a visually striking terminal greeting that is entirely Windows-native in spirit and thoroughly custom in execution.

The WinLogo glyph in FastFetch is a small but satisfying way to put your personal stamp on your PowerShell environment. If you tweak the grid size or colors, the same two-script approach scales to any N x N layout you prefer.

Here in Windows-World, I get my jollies where I can find them. Today, I found them using a Windows 11 logo glyph for my OS logo in FastFetch. Where will my jollies come tomorrow?

Facebooklinkedin
Facebooklinkedin

WinGet Misses ARM Browser Updates

If you run winget upgrade --all on an ARM-based Windows 11 PC (e.g. an Asus Zenbook A14), you may notice something odd: Chrome and Firefox don’t show in the upgrade list, even when they’re out of date. On an x64 desktop, winget catches them without fail. So what gives? Briefly put, and for various reasons, WinGet misses ARM browser updates for certain implementations.

It turns out there are four overlapping bugs and design gaps at play. All of them affect ARM64 PCs. None of them are your fault, either. But together they form a perfect storm that makes WinGet effectively blind to certain browsers. For now, anyway.

TLDR: On ARM64 Windows PCs, WinGet fails to detect and upgrade Chrome and Firefox due to four compounding issues: a name-normalization bug (winget-cli #6490), a registry hive mismatch, a broken ARM64 manifest entry for Chrome, and an architecture-selection bug (winget-pkgs #424881). Until Microsoft patches these, a handful of workarounds fill the gap. Here goes…

Diving in: Why WinGet Misses ARM Browser Updates

On x64 machines, the registry is simple: one hive, one architecture tag, and manifests that have been battle-tested for years. WinGet’s upgrade logic originates from that x64 worldview. Alas, things on ARM64 aren’t quite so simple, and all four failure modes described next come out of various diversions from the x64 situation.

Four Root Causes

  1. The ARP Name-Normalization Bug (winget-cli #6490)

Winget matches installed apps to its catalog by reading Add/Remove Programs (ARP) registry entries and normalizing display names. It strips “x86” and “x64” — but has no handling for “arm64” or “ARM64.” When Chrome or Firefox registers with an ARM64 architecture suffix on a Snapdragon device, winget cannot correlate it to the catalog entry and silently drops it. The app becomes invisible to winget upgrade.

  1. The Registry Hive Mismatch

ARM64 Windows splits app registrations across 3 registry hives:

 

Hive Contents Who Writes There
SOFTWARE\…\Uninstall Native ARM64 apps ARM64 installers
SOFTWARE\WOW6432Node\…\Uninstall x64-emulated apps x64 installers (Chrome, Firefox legacy)
HKCU\SOFTWARE\…\Uninstall Per-user installs Either architecture

 

If Chrome or Firefox were installed via an x64 installer — the only option before both browsers shipped native ARM64 builds — it lives in WOW6432Node. Winget, running as a native ARM64 process, reads the native hive first and, when name normalization is also broken, frequently misses those emulated entries entirely.

  1. The Broken Chrome ARM64 Manifest

Even when winget finds Chrome, the Google.Chrome manifest in the community repository lists an arm64 installer entry with a blank SHA256 hash. Winget requires a valid hash to verify any upgrade — blank means the ARM64 path is present on paper but non-functional. The Google.Chrome.EXE package ID does carry a properly populated hash, which explains why some users get inconsistent results depending on which package ID is in play.

  1. The Architecture Selection Bug (winget-pkgs #424881)

Even with a complete, valid manifest, winget’s upgrade logic has a documented bug where it selects the x64 installer over arm64 on Windows on ARM machines. Best case: you get the slower, emulated build pushed onto your ARM device. Worst case: the upgrade fails outright.

Viable WinGet Workarounds

Until Microsoft ships fixes, here are some WinGet options — from most precise to most blunt:

  1. Force the architecture explicitly: Use winget upgrade Google.Chrome --architecture arm64 and winget upgrade Mozilla.Firefox --architecture arm64. This bypasses both  correlation and selection bugs in one go.
  2. Use the Chrome EXE package ID: winget upgrade Google.Chrome.EXE --architecture arm64 hits the manifest entry that actually has a valid SHA256 hash for ARM64.
  3. Let the browsers self-update: Both Chrome (Google Update/Omaha) and Firefox (Mozilla Maintenance Service) are fully architecture-aware. Help → About in either browser triggers an immediate, correct ARM64 update — no winget involved, no ARM64 drama.
  4. Add --include-unknown as a catch-all: winget upgrade --all --include-unknown is a blunt instrument, but it sometimes remcatches apps that fail normal ARP correlation.

The real, true fix requires Microsoft to patch name-normalization and upgrade architecture-selection logic in winget-cli. Two of the four bug reports were filed in the last few days, so movement could come soon. Until then, –architecture arm64 is the cleanest workaround on your Zenbook A14 — or any other Snapdragon-powered Windows machine. In Windows-World, knowing where the bodies are buried is half the battle.

Facebooklinkedin
Facebooklinkedin

Version 26H2 Coming Soon Via eKB

If you’re running Windows 11 24H2 or 25H2, the next annual upgrade aka Windows 11 26H2 is almost here. For many users, the upgrade experience should be pretty low-key. Microsoft pushed Build 26300.9278 into the Release Preview Channel on August 27, 2026. That signals general availability (GA) is on track for September or October. Hence my proclamation about Version 26H2 coming soon via eKB. What’s that?

Qualifying devices won’t sit through a multi-gigabyte download or a lengthy offline install. Instead, they’ll receive a tiny enablement package (eKB) that flips the version number after a single restart.

TLDR: Windows 11 26H2 (Build 26300.9278) is in Release Preview now and coming this fall. It lands as a ~174 KB enablement package (KB5121794) for 24H2 and 25H2 users. Windows 11 23H2 and older face a full ~6.5 GB feature update. Windows 10 users, of course, need a full OS upgrade. And 26H1 (the Arm-only branch) has no standard eKB path to 26H2 at all. For them, a clean install is the only way to go forward.

What Is an Enablement Package?

An enablement package (eKB) works because 24H2, 25H2, and 26H2 share the same underlying servicing branch and codebase. Most of what defines 26H2 has already been delivered to your PC through monthly cumulative updates. Indeed, the eKB simply activates it, changes the build string to the 26300 series, and reboots. The download for KB5121794 weighs in at around 174 KB, and is smaller than most web images. One prerequisite: your system must already have KB5120998 (Builds 26200.9278 or 26100.9278) installed before the enablement package can run. A quick visit to Settings > Windows Update confirms if you’re current (or not).

As Paul Thurrott reported on Thurrott.com, for the first time, Microsoft is releasing a new Windows version to the Insider Release Preview ahead of general availability. That’s a sign that the company wants broader validation before the full rollout. The official announcement comes from Stephen Lines via the Windows Insider Blog.

Upgrade Paths: Know Where You Stand

Your path to 26H2 depends entirely on which version you’re running today. This table lays things out:

Current Version Upgrade Method Download Size Restarts
Windows 11 25H2 Enablement Package (KB5121794) ~174 KB 1
Windows 11 24H2 Enablement Package (KB5121794) ~174 KB 1
Windows 11 23H2 Full feature update (different servicing branch) ~6.5 GB Multiple
Windows 11 26H1 (Arm) Separate core branch — no standard eKB path N/A N/A
Windows 10 Full OS upgrade or clean install ~6.5 GB+ Multiple

As TechPowerUp’s AleksandarK noted, devices on 23H2 and older sit on a different servicing branch. Thus, there’s no eKB shortcut for them. And 26H1, built specifically for new Arm silicon such as Snapdragon X2 Elite devices, runs a separate Windows core and won’t roll forward via the standard enablement path. Microsoft has said those devices will eventually receive a path to a future Windows release. Those who wish to jump that gun must, as I said earlier, do a clean install.

What 26H2 Actually Delivers

Let’s be blunt: 26H2 is a stability and lifecycle-reset release, not a features spectacular. Thanks to Microsoft’s continuous innovation model, most of what carries the 26H2 label has already landed on your device via monthly updates. That said, commercial customers do get a handful of features enabled by default for the first time: Windows Settings Backup, app-specific Taskbar actions, and several File Explorer enhancements.

The bigger prize is the support lifecycle reset. That is, 24H2 Home and Pro reach end of updates on October 13, 2026. Thus, upgrading keeps you beneath the security update umbrella.

How to Get It Now

Windows Insiders in the Release Preview Channel can grab 26H2 today via Settings > Windows Update using the seeker experience (enable “Get the latest updates as soon as they’re available”). For everyone else, wait for GA. At that time, Microsoft will offer 26H2 as an optional install first, then push it automatically as 24H2 nears its support deadline. If you’re still on 23H2 or older, the smartest move right now is upgrading to 24H2 or 25H2, so that when 26H2 arrives, it costs you 174 KB and one reboot instead of a 6.5 GB weekend project.

Here in Windows-World, it’s wise to get ahead of the curve when the opportunity presents. This is one such opportunity. I plan to jump on it as soon as I can!

Facebooklinkedin
Facebooklinkedin

FAT32 UFD Nixes “Repair My PC”

Here’s an interesting one. I tried out the latest Garlin scripts this morning (dated 8/24). The boot media check turned up something new. It reported that a new Windows 11 facility wouldn’t run from my MCT-based Windows installer UFD. And indeed, upon investigation, it turns out that using a FAT32 UFD nixes “Repair my PC” capabilities in WinPE. But that’s for a good and understandable reason, as I’ll explain.

TLDR version: Boot an MCT-generated Windows 11 setup USB and click “Repair your computer.” On many FAT32-formatted drives, including these, nothing happens. That option is simply broken. Here is why, and what you can do about it.

Why FAT32 UFD Nixes “Repair My PC”

Windows 11 setup media built with the Media Creation Tool on a FAT32 drive hits a hard wall. FAT32 caps individual file sizes at 4 GB. A Windows 11 install image blows past that ceiling.

Microsoft’s solution is to split the image into two files named install.swm and install2.swm(swm is, of course, a “split WIM file” ICYDK). On the drive I examined, that pair totaled about 5.6 GB compressed. Setup.exe handles this format just fine during installation. The problem surfaces elsewhere.

WinPE Can’t Find (or Handle) the Source

Clicking “Repair your computer” in the Setup UI triggers a search. The WinPE environment in boot.wim looks for install.wim or install.esd in the sources folder. Neither file exists on a FAT32 UFD.

Only install.swm and install2.swm are present. WinPE recovery tools cannot enumerate split WIM files for repair operations. They expect a single, monolithic image file. Without it, the repair chain fails before it starts.

Please note that this is neither a certificate nor a Secure Boot issue. Garlin confirmed that all signing credentials in boot.wim were valid. Strictly speaking, the “broken” label emerges from a missing monolithic image, nothing more.

NTFS Can Fix What’s Broken, But…

The root cause is FAT32. The cure is straightforward: rebuild the drive using NTFS.

Rufus handles this cleanly. Point it at a Windows 11 25H2 ISO, choose NTFS as the file system, and let it run. NTFS has no 4 GB per-file ceiling. A Rufus NTFS build produces a single install.wim that WinPE can locate and read without complaint.

Rufus also ships a current, properly signed bootloader. That quietly resolves a secondary Garlin finding as well: a BANNED bootx64.efi signed by the deprecated Production PCA 2011 certificate. On an NTFS Rufus build, that file is replaced automatically.

Practicing Proper WinRE/WinPE Repairs

A FAT32 Windows 11 setup USB remains fully functional for clean installs. The split WIM has no effect on setup.exe. However, the “Repair your computer” path is dead on arrival.

On a machine that refuses to boot, that missing option could matter a great deal. Building setup media on NTFS costs nothing extra. Rufus is free, and a rebuild takes only a few minutes.

For a USB you may need under pressure, a working repair option is worth the small extra effort. That said, I have observed that some PCs (notably, various Lenovo and Toughbook laptops in my custody) simply won’t boot to an NTFS-formatted UFD. That takes “Repair my PC” off those particular tables, for good or ill.

Check It for Yourself

Run Garlin’s check-bootmedia script against your Windows 11 setup drives. If you see ‘Repair My PC’ is broken in WinPE, you now know why that shows up. If you rebuild on NTFS using Rufus with a current ISO, that repair option will be there when you actually need it. But only if your target PC will boot from an NTFS-formatted UFD. That’s why you have to check! Here in Windows-World, it’s best to know such things beforehand.

Note to Microsoft: Maybe you guys should buy or license Rufus so you can quickly jump MCT and “Create a recovery drive” into a completely modern, Secure Boot aware (and friendly) stance. IMO, that’s a good idea, so please give it some thought.

Oho! There’s ANOTHER Garlin Script for That…

Turns out you can download and apply yet another Garlin script to fix this very issue. It’s called Repair_My_BootWIM.ps1. Run it against your offending boot media and the problem gets fixed automagically. It just worked on my test G: drive created from MCT last week. No Rufus needed. Go figure!

Notice the text that reads “‘Repair My PC’ is broken in WinPE.”  no longer appears. Fixed!

Facebooklinkedin
Facebooklinkedin

Flo6 Recovery Partition Cleanup

One of the quieter but genuinely useful maintenance tasks for any Windows 11 machine is verifying the WinRE recovery partition. When necessary, you can refresh bits and pieces. On my desktop (production) rig Flo6, that job came due recently when I discovered a one-version gap between the OS and the recovery environment. Here’s exactly what I did to perform Flo6 recovery partition cleanup.

Why Do Flo6 Recovery Partition Cleanup?

Flo6 was running Windows 11 25H2 (build 26200.9168). It’s current and fully patched. A quick reagentc /info at an elevated command prompt, however, told a different story about the recovery environment: Windows RE Version 10.0.26100.9168. That’s 24H2 — one full major version behind the OS.

This kind of mismatch is typical after an in-place upgrade. Windows Update doesn’t always push a matching WinRE update alongside the OS upgrade. The recovery environment still works, but keeping it in sync with the running OS is simply good hygiene.

Finding the Right Source Media

Fortunately, I had a Windows 11 25H2 bootable UFD on hand. It is ESD-USB labeled, FAT32 formatted, carries seven editions in a split WIM (install.swm + install2.swm, totaling ~5.6 GB compressed). A quick DISM query confirmed the match:

dism /get-wiminfo /wimfile:G:\sources\install.swm /index:6

Output showed Version: 10.0.26200 / ServicePack Build: 9168 — an exact build-for-build match with Flo6’s OS. The source media was confirmed.

DISM Workflow: Four Clean Steps

Split WIMs add a wrinkle:the/swmfile parameter won’t work with /mount-wim. The workaround is to export first, then mount the resulting single WIM. Here’s the sequence I ran from an elevated command prompt:

Step 1 — Export the Pro edition to a single WIM:

dism /export-image /sourceimagefile:G:\sources\install.swm /swmfile:”G:\sources\install*.swm” /sourceindex:6 /destinationimagefile:C:\temp_pro.wim

Step 2 — Mount read-only to C:\BootMount (a pre-existing empty directory):

dism /mount-wim /wimfile:C:\temp_pro.wim /index:1 /mountdir:C:\BootMount /readonly

Step 3 — Extract winre.wim to a temp location:

copy C:\BootMount\Windows\System32\Recovery\Winre.wim D:\Temp\Winre25H2.wim

Step 4 — Unmount and delete the temp WIM:

dism /unmount-wim /mountdir:C:\BootMount /discard
del C:\temp_pro.wim

Swapping the WinRE Recovery Partition Image

With the new Winre.wim extracted, swapping it into the recovery partition takes just a few commands using reagentc (note: the copy command runs into a second line here, but should be a one-liner when run at the command line):

reagentc /disable
copy /y d:\temp\winre25h2.wim r:\recovery\windowsre\winre.wim
reagentc /enable
reagentc /info

The leading screenshot above shows this exact sequence — disable, copy, enable, and the final /info verification — all completing successfully. Note that R:is the recovery partition, temporarily assigned a drive letter for this operation.

A Nuance Worth Noting

The final reagentc /info reported Windows RE Version: 10.0.26100.9168 , and still shows 24H2. This isn’t a failure. The winre.wim packaged inside a 25H2 OS install image is itself built on the 24H2 WinPE base.

Microsoft maintains WinRE on its own separate servicing track. The embedded winre.wim version doesn’t automatically match the OS build number. The WinRE is fully functional and properly enabled — the version stamp reflects WinPE infrastructure, not a gap in recovery coverage.

Bottom Line

The Flo6 WinRE recovery partition is now refreshed, re-enabled, and confirmed healthy: Status Enabled, location correct, BCD identifier registered, and local reinstall available. Total active time at the command prompt: under ten minutes.

If you haven’t checked your own WinRE status lately, reagentc /info is a fast, zero-risk first step — and now you know exactly what to do if the version number looks off. Here in Windows-World, checking is good, and verifying is better. Today, I’m in a good place. How about you?

Facebooklinkedin
Facebooklinkedin

Windows Neofetch Alternatives

If you’re ever seen Neofetch, you’re likely to want something like it for Windows. It’s a command-line tool that displays a quick system snapshot. It shows OS version, CPU, GPU, RAM, uptime, shell, storage and more, alongside a rendering of the OS logo as “ASCII art.” But Neofetch is mostly a Linux/Unix thing that requires a Bash shell to run. It was also archived in April 24. It still works, but there are better choices for Windows. For those seeking Windows Neofetch alternatives, the best options are fastfetch and winfetch.

Windows Neofetch Alternatives Are Helpful, or Necessary

Again: Neofetch is a Bash script. That explains most of the friction inherent in running Neofetch on Windows. That is, it requires Git Bash or WSL — neither of which is a native Windows tool. The script itself froze at v7.1.0 when the repository was archived. Worse, going forward Neofetch is dead in the water: no updates, no bug fixes, no future-forward functionality.

Think about what Neofetch actually does: it reads your OS version, CPU, RAM, and a handful of other system facts, then prints them alongside an ASCII logo. Running an outdated Bash script through a compatibility layer to accomplish that feels like overkill. Native tools handle this job more cleanly, more quickly, and without the extra dependencies.

2 Strong Alternatives: Fastfetch and Winfetch

Both of these facilities are actively maintained, and update regularly. Either one can take over for Neofetch without skipping a beat.

Fastfetch

Fastfetch is written in C and installs as a native binary. Speed is its calling card — it fetches and renders system info noticeably faster than Neofetch ever did. Cross-platform support (Windows, Linux, macOS) makes it useful across mixed environments. Install it with any of the major Windows package managers:

winget install fastfetch

Once installed, launch it by typing fastfetch at any prompt. Configuration lives in a JSONC file, so customization is straightforward and version-control friendly. Here’s what it looks like on my AMD-based Flo6 desktop (click image to enlarge):

Winfetch

Winfetch is a pure PowerShell script — Windows-only, and deliberately so. It installs directly from the PowerShell Gallery:

Install-Script winfetch -Scope CurrentUser

For anyone already running Windows Terminal with an Oh My Posh prompt and Nerd Fonts, winfetch slots right in. The output renders cleanly alongside a styled prompt, and the whole setup feels native rather than bolted on. You can see it in the lead-in screencap.

The Winfetch Path Gotcha

What the lead-in graphic shows is me getting past the requirement that the winfetch script must be somewhere in $PATH to work. In fact, after I installed it, I got this error when I tried to run it:

Error

winfetch : The term ‘winfetch’ is not recognized as the name of a cmdlet, function, script file, or operable program.

This happens because the installer drops the script into a specific, pre-assigned folder:
C:\Users\Documents\Powershell\Scripts\
Powershell does not, however, automatically add that folder to the $PATH environment variable. So even though the script is installed, it doesn’t run from the command line. Easily fixed, however, as also shown in the lead-in graphic, through a series of simple steps.

Fixing Winfetch, Step-by-Step

Step 1: Confirm the install location

Run this to verify exactly where the script landed:

Get-InstalledScript winfetch | Select-Object Name, InstalledLocation

Step 2: Run it directly as a workaround

Before touching PATH, you can invoke winfetch immediately using its full location:

& "$((Get-InstalledScript winfetch).InstalledLocation)\winfetch.ps1"

That works, but typing it every time is obviously impractical. The permanent fix takes about ten seconds.

Step 3: Add the Scripts folder to PATH permanently

Open PowerShell and run the following command to append the Scripts folder to your PATH inside your profile:

Add-Content $PROFILE "`n`$env:PATH += `";`$([System.Environment]::GetFolderPath('MyDocuments'))\PowerShell\Scripts`""

Then reload your profile in the current session:

. $PROFILE

After that, typing winfetch works cleanly from any new PowerShell session. No more “not recognized” errors, no manual path juggling.

Tip: Execution Policy

If PowerShell refuses to run the script at all, check your execution policy first: Get-ExecutionPolicy. A setting of Restricted blocks all scripts. Set it to RemoteSigned with: Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

Which to Use: Winfetch or Fastfetch?

The choice comes down to how you work, not which tool is objectively better.

Tool Best For Install Method Config Format
Fastfetch Speed, cross-platform use, binary simplicity winget install fastfetch JSONC file
Winfetch PowerShell-native feel, Windows Terminal + Oh My Posh setups Install-Script winfetch -Scope CurrentUser PowerShell config script

Reach for fastfetch when you want something fast, dependency-free, and portable across platforms. Winfetch makes more sense if you live inside PowerShell and want the output to feel like it belongs there — especially alongside Windows Terminal and a styled prompt. Both tools beat neofetch on Windows in 2026. Pick one and move on. Either way, you get a clean, colorful system info display — and you leave a frozen Bash script behind where it belongs. That’s about as good as tradeoffs get here in Windows-World. Cheers!

Facebooklinkedin
Facebooklinkedin

Open Apps Maximized Is Nice

With the release of Beta Build 26220.9223 last Friday (Aug 21), MS now includes an “Open apps maximized.” It shows up in Settings > Accessibility > Visual effects, shown in the lead-in screencap. The feature is pretty handy, even for those who don’t work around visual impairment. Indeed, Open apps maximized is nice for all kinds of users, including your humble author. Indeed, I usually work with key tools (e.g. Office apps, text editors, WinTerm, networking tools, and so forth) maximized anyway.

If Open Apps Maximized Is Nice, Do You Use It?

It’s a matter of working style. If you regularly use apps maximized, it can be a small time-saver, that’s for sure. Interestingly, for apps with restricted max window sizes (e.g. PC Manager, CPU-Z, Core Temp, and so forth), the windows still open at their normal sizes. So it doesn’t ALWAYS fill a display with the app windows you open. That only happens for apps that allow themselves to cover that whole space already.

Even better, if you open an app in full-screen mode courtesy of this new Settings option, you can still click the “Restore down” button to return the window to whatever size you had it set at beforehand. At that point, you can still re-size the app window however you like it. Windows remembers this setting, so with “Open apps maximized” toggled on, it will return to the current sizing when you click the middle button in the top right trio (Minimize/Maximize (up) or Restore Down/Close).

Who Needs “Open Apps Maximized?”

Anybody who wants it. It’s a simple and easy UI behavior option. Personally, I like it in concept. I need to live with it for a while to see how I like it in practice. My intuition, such as it is, tells me MS might benefit from refining this further into a per-app control (e.g. Apps > Default apps or Apps> Startup do this already).

Here in Windows-World, setting default behaviors can be good or bad. You must decide what works best for you, and act accordingly. I’m still deciding if the new “Open Apps Maximixed” works for me or not. When I make that decision toggling this setting on could become part of my standard Windows set-up actions, or not. We’ll see. But it’s cool and potentially helpful nevertheless.

Facebooklinkedin
Facebooklinkedin

Managing Macrium Reflect Keys

Right now, I’m paying for 8 keys’ worth of Macrium Reflect X Home. I just conducted a survey of all the machines here at Chez Tittel and observed that only 2 currently run Reflect X, 2 run Reflect 8, and the rest run something else. Since I’m paying for 8 and currently have 8 machines at hand, I could use them all. As I’ve been managing Macrium Reflect keys, I have to compliment the company’s web interface  at manage.macrium.com/. It now works lots better than it did the last time I messed with it.

You can see part of the License info page as the lead-in graphic. Quite naturally, it doesn’t show any license keys. But it does show which ones are available, when they come up for renewal, and more. It also offers controls to add more info or revoke the license for some current installation. Nice!

Better Use from Managing Macrium Reflect Keys

Indeed, the key list now shows status, and provides controls to give each one a ‘friendly name.’ For those of mine in actual use right now, I assigned the associated machine name. That lets me know exactly which PC has which license, which is just what I want. The other licenses show “Available” which tells me I can use them if I want to.

When I tried to free up one license, however, instead of allowing the “Reset License” operation to proceed (that’s what Macrium calls it), it asked me to submit a support ticket. So that’s what I did. I’ll be interested to see what kind of response that engenders, and how soon it appears.

The Round Tuit Has Arrived!

I’ve been meaning to do this for 6 months or more. But I’m glad I’ve gotten my licenses organized. I’m even gladder to use the ‘Friendly Name’ feature to show me which PC is using which license. I plan to stay in that habit going forward. I also plan to install another copy on AsusSnap (my lone Snapdragon X based laptop right now) because Reflect X is unusally adept and speedy at backup on such CPUs.

Here in Windows-World, it’s not always about solving problems and fixing things. Sometimes, it’s about making the time to keep things neat and orderly. I’m glad I got the backup act together here. I’m sure I’ll find other, similar tasks to tackle, when I have time. Stay tuned: I’ll tell you all about it.

That Was QUICK! Note Added 1 Hr Later

The response from Macrium was as quick as such things get. It’s already fixed. They didn’t tell me why I couldn’t reset the key myself, but they did reset it for me. Now that’s what I call great service. And now, I’ve got six (count ’em: 6) Macrium Reflect X licenses to play with. A truly happy ending: thanks Francisco (name of service agent who handled my request)!

 

Facebooklinkedin
Facebooklinkedin

Oh My Posh Shows Real ARM vs x64 Differences

Following the Oh My Posh documentation, I recently ran oh-my-posh font list on my ASUS Zenbook A14 . It’s a Qualcomm Snapdragon X Elite ARM64 machine running Windows 11. The result? Nothing. No output, no error, no interactive list, just a blinking cursor that eventually handed the prompt back to me. That same command works beautifully on all my x64 PCs and laptops. Thus, Oh My Posh  shows real ARM vs x64 differences. Indeed, this sent me down a rabbit hole to figure out what OMP’s font subsystem does under the hood.

How Oh My Posh Shows Real ARM vs x64 Differences

When you run oh-my-posh font list on a working x64 machine, you get a list of available Nerd Fonts pulled live from GitHub. You can scroll that list, select a font, and it copies the name into the paste buffer for subsequent re-use. It’s helpful.

On my ARM64 Zenbook, none of that renders. The command exits silently. No crash, no error code, no partial output. That silence is itself a clue.

Inside the Oh-My-Posh Font Subsystem

OMP is written entirely in Go, and its font subsystem layers several platform-specific APIs and third-party frameworks. Understanding what those are and how they work explains why ARM64 falls short.

The first dependency is Bubble Tea a terminal oriented display and interaction UI. OMP’s font commands use Bubble Tea’s program model to launch, render, and manage the font list. Bubble Tea drives the terminal via ANSI/VT escape sequences and calls into Go’s golang.org/x/term package to manipulate terminal raw mode. On x64 Windows, Windows Terminal’s VT rendering pipeline handles these sequences without issue. On ARM64, subtle gaps in how the ARM64 console host processes certain VT sequences — particularly around alternate screen buffers and raw-mode toggling — can cause Bubble Tea’s rendering loop to fail before it draws a single line.

The second dependency is a live HTTPS call to the Nerd Fonts GitHub Releases API, which is how OMP fetches the current font list. This call goes out over Go’s standard net/http TLS stack. On ARM64, Go’s TLS implementation compiles natively, but the ARM64 binary links against a slightly different set of system crypto libraries. If that HTTP call fails silently, owing to a timeout, a TLS handshake hiccup, or a missing response, Bubble Tea never receives the data it needs to populate the list, and the program exits with nothing to show.

The third set of dependencies covers font installation: GDI32’s AddFontResourceW function (called via Go’s syscall and unsafe packages), Windows Registry writes through golang.org/x/sys/windows/registry, and a PostMessageW broadcast carrying WM_FONTCHANGE to notify the shell that new fonts are registered. These are the plumbing that oh-my-posh font install uses after the list is displayed. They are less relevant to the silent-exit problem, but they represent additional surfaces where ARM64’s native API behavior diverges from x64.

Where ARM Falls Down (or Out)

The core issue is that OMP’s font tooling was developed and battle-tested on x64 Windows. The Bubble Tea TUI path, the live GitHub fetch, and the GDI32 font registration flow all work reliably there. ARM64 Windows is a native platform now — not emulation — but the console host, terminal rendering, and system library behavior still carry edge cases that x64 does not.

Bubble Tea’s dependency on terminal raw mode and VT escape handling is especially fragile on ARM64 because Windows Terminal’s ARM64 build has historically lagged behind x64 in VT conformance. A Bubble Tea program that initializes correctly on x64 can silently short-circuit on ARM64 if golang.org/x/term‘s raw-mode call returns an unexpected result, causing the event loop to spin zero times and exit.

The irony is that OMP itself — the prompt rendering engine — works great on ARM64. The font management tooling sits on a different, more complex stack, and that stack exposes the seam between x64-matured tooling and an ARM64 Windows environment that is still catching up.

Takeaways for ARM Users

If you hit silent output from oh-my-posh font list on an ARM64 Windows machine, you now know it is not user error. It’s a real platform gap rooted in Bubble Tea TUI compatibility, live HTTP fetching, and ARM64 console API edge cases. The workaround for the moment is to install Nerd Fonts the old-fashioned way: grab the zip directly from the Nerd Fonts GitHub releases page and drop the TTF files into your user fonts folder manually. It’s not as elegant as OMP’s interactive installer, but it gets the job done.

This kind of difference is exactly why I find ARM Windows fascinating. The platform is capable, but it still surfaces small, instructive wrinkles like this one. Though I’ve seen nothing to make me question my investment in ARM hardware, oh-my-posh font list returning nothing is about as vivid a demonstration as I have seen of possible impacts of platform differences. That’s a thing worth watching out for, here in Windows-World.

Note: Only newer OMP versions (30.X.X) and higher support the font list capability. If you’re run the bog standard version on x64 (v29.0.2) you won’t see it, either. Winget should get the latest version (30.6.5) into its pipeline soon, after which you can see it, too. On the right kind of PC, anyway…

Facebooklinkedin
Facebooklinkedin

The Incredibly Bogus MSI BIOS Update

Windows Update pinged me yesterday, August 18, with a firmware notification: my MSI motherboard had a BIOS update available. My reaction was less “Great, let me install that…” and more “Wait! I just did.” The week before, I’d downloaded MSI’s latest BIOS package, copied it to a FAT32 USB drive, booted into MSI’s M-Flash utility, and flashed the thing the old-fashioned way. It worked perfectly. So why was Windows Update acting like none of that had ever happened? Thereby hangs the tale of the incredibly bogus MSI BIOS update. Here goes…

Hunting Down the Bogus MSI BIOS Update

The “bogus” here isn’t the update itself. Indeed, Windows Update found it and sought to deliver it. What was bogus was any awareness on WU’s part that I’d already installed it. When I flashed the BIOS using MSI’s UFD-based utility, that transaction happened entirely outside of Windows. No registry entry. Windows Update history records missing. No UEFI firmware capsule delivery for WU to track. As far as Windows Update was concerned, the update had never been applied, and it was doing its best to make sure I got it.

I confirmed the BIOS version in the UEFI settings. Indeed, it matched the version WU was offering. I checked Windows Update history: no entry for the flash, naturally. Optional updates, Driver updates: WU really wanted me to install this update. So I did, and of course it failed because MSI is smart enough to refuse a second install of the same UEFI version (I’ve had this happen on Lenovo PCs/laptops as well).

WU Remains Oblivious to OOB BIOS Updates

Windows Update tracks firmware updates it delivers itself. Typically, they come via UEFI firmware capsule updates. Those hand off to the firmware installer, and WU records the update in its history database. When you flash a BIOS using a manufacturer’s standalone tool (e.g. MSI’s M-Flash, a DOS-based utility, or a UFD flash from UEFI) Windows is completely out of the loop. There’s no handshake, no callback, no “hey, Ed already did this” signal.

The result: WU sees the target BIOS version, compares it against its own records (which show nothing). It concludes the update is needed. It’s not wrong, exactly. It just doesn’t know what it doesn’t know. And because the update failed anyway (I couldn’t figure out how to kill the pending item before it was applied, even with Copilot’s help) it appeared every time I checked updates in WU.

Until I hid the update it kept trying and failing to install after a mandatory restart. Vexatious!

PSWindowsUpdate Hides the Bogus Offer

For this case, the solution wasn’t to install the update again. Reflashing a BIOS that’s already current is unnecessary and might cause problems. The goal was to tell Windows Update, in terms it would respect, to quit offering that item. That’s a job for the PSWindowsUpdate module from the PowerShell Gallery.

I imported the module, enumerated all pending updates to confirm the BIOS entry was there, and then hid it. The complete sequence is in the lead-in graphic, but here it is in text form for easy access (info following # is purely descriptive and need not be entered):


Import-Module PSWindowsUpdate #Invokes PSWU cmdlet set
Get-WindowsUpdate -MicrosoftUpdate #Calls WU for upd chk
Hide-WindowsUpdate -Title "Micro-Star..." #Hides MSI upd

You can use the Title or the KB number for an update to block it. Then you can use the Get-WindowsUpdate -MicrosoftUpdate -IsHidden cmdlet to show you if your efforts succeeded.

Problem Solved, Mostly

After running Hide-WindowsUpdate, Windows Update stopped flagging the firmware update. No more notifications, no more badge on the WU icon, no more politely worded insistence that I was a BIOS version behind. A quick recheck of Get-WindowsUpdate showed a clean list.

One thing: hiding an update using PSWindowsUpdate is reversible. You can unhide it later with Show-WindowsUpdate if you ever want WU to see it again. And if you’re in the opposite situation (WU is offering a BIOS you genuinely haven’t installed), the Install-WindowsUpdate cmdlet handles that well. Either way, PSWindowsUpdate gives you control that the standard WU interface simply doesn’t.

Here in Windows-World, it’s always something. This time, it was a weird and unwanted BIOS update. Whatever it may be next time, count on me to tell you about it, and how to work with, through, or around it as circumstances might require. Cheers!

Facebooklinkedin
Facebooklinkedin