I've taken the deep dive into local AI so you don't have to.

My feed is filled with local AI stuff. There's a lot of "boy who cried wolf" feeling around it because I hear claims and then only later you find out they were running on $100k of hardware. For that I could subscribe to Claude Max, Codex Pro and Grok Super Heavy Build for decades.

What I really wanted to know is what hardware can do what. What were the real limitations and what they could really do. And so I dug in. And now, you can benefit from that journey. And yes, I use em-dashes — a lot. They're mine. AI can't claim them.

Part 1: The AI Models

AI Parameters: 2B, 3B, 9B, 27B for fun and profit

When you see a model called "Llama 8B" or "Gemma 27B," the number is its parameter count, the number of learned weights inside the neural network, in billions. Parameters are, roughly, the model's capacity to know things and reason about them.

Rough breakdown by size:

• ~1B and under: Autocomplete with hallucinations of grandeur. Fine for classification, summarizing a paragraph, simple formatting tasks.
• 2B–4B: Genuinely conversational. Can follow instructions, answer general questions, and with careful prompting, do simple tool use. This is the sweet spot for phones and NPUs.
• 7B–9B: The workhorse class. Decent general knowledge, can follow multi-step instructions, handles light agentic work (call a tool, read the result, respond).
• 13B–30B: Where local models start feeling like "real" AI. Better judgment, fewer hallucinations, can recover from their own mistakes mid-task.
• 70B+: Approaching frontier-model territory, but you need serious hardware. Think a Mac Studio with 128GB of unified memory or a multi-GPU rig, not a laptop.

Parameter count also affects speed, not just smarts. Every single token the model generates requires reading essentially all of the parameters from memory. A 27B model isn't just smarter than a 3B model, it's also about 9x more work per word. Keep that in mind; it becomes a big deal when we start thinking about what you can do in real-time vs. what you should schedule out.

Quantization

Models are trained in 16-bit precision. An 8B model at 16 bits per parameter is 16GB just for the weights.

Think of it like graphics formats. 16-bit precision is like a bitmap. No one, anymore, sends a .BMP in email.

Quantization is lossy compression for neural networks: store each weight in 8, 5, or 4 bits instead of 16. So it's like taking that BMP and turning it into a JPEG. At 8-bit quantization it's essentially the same as the original uncompressed version. At 4-bit it's lost some but probably not enough to matter other than in benchmarks. Below that and it starts to get pretty bad. 4-bit is generally the sweet spot.

The alphabet soup: Q4_0, Q4_K_M, Q8_0, IQ4_NL

Quantization also has many ways of doing it. Just like there's a ton of graphic formats there's a ton of ways of quantizing these models, each with their own trade-offs.

In my experience, I tend to focus on MLX (for Mac hardware), the ones that NVIDIA likes, and the ones that NPUs from Qualcomm and others will like.

A sampling:

• Q8_0: 8-bit. Nearly lossless, twice the size of 4-bit. Worth it only for small models where the size doesn't hurt (a 0.6B model at Q8 is under 1GB, so why not).
• Q4_K_M: the modern 4-bit "K-quant." Smarter allocation of bits (important layers get more precision). Usually the best quality per gigabyte, and the default recommendation on CPUs and GPUs.
• Q4_0: the original, simplest 4-bit format. Slightly worse quality than Q4_K_M, but its plain block layout is what specialized hardware paths are built for. On ARM CPUs and NPUs, Q4_0 is often dramatically faster than Q4_K_M because the fast kernels only speak Q4_0.
• IQ4_NL: a newer 4-bit format using a non-linear codebook. Great quality, but hardware support is spottier.

The format has to match the hardware. In our own testing, the same 4B model ran at 37 tokens/second as Q4_K_M on CPU but collapsed to 14 when routed to the NPU, because the NPU path couldn't handle K-quants and fell back to a slow path. Same model, same computer, same "4-bit," 2.5x difference. This is the single most common way people accidentally sandbag their local AI setup. This is why it's still a headache and programs like Clairvoyance are exploding in popularity — they just take care of this nonsense.

Part 2: Hardware constraints

TOPS, NPUs, GPUs: the speed of thinking

Chip vendors advertise TOPS, trillions of operations per second. A Copilot+ certified laptop's NPU claims 40–80 TOPS; an RTX 4090 delivers over 600. You'd think a 45-TOPS NPU runs AI at some meaningful fraction of a 4090's speed.

It does not.

There are two very different phases when a model responds to you:

1. Prefill: reading your prompt. This can be done in parallel so GPUs and NPUs do great here.
2. Decode: writing the answer. Tokens come out one at a time, and each one requires streaming the entire model through memory again. TOPS are nearly irrelevant; memory bandwidth is everything.

So a laptop NPU can read and understand a full article of text in half-a-second. But actually commenting on it is limited by the memory bandwidth which might take a minute.

RAM: system RAM, GPU VRAM, and unified memory

The model has to live somewhere, whole, in fast memory:

• Discrete GPU (VRAM): Fastest option by far, but VRAM is scarce. A 12GB card fits a 9B comfortably or a 27B not at all. Spilling layers to system RAM works but every spilled layer runs at system-RAM speed.
• System RAM (CPU): Plentiful and cheap (32GB fits anything you'd sanely run) but slow, see below.
• Unified memory (Apple Silicon, Snapdragon X, AMD Strix Halo): CPU, GPU, and NPU share one pool. The great trick of a 128GB Mac is that all 128GB of it is available to the model at decent bandwidth, even though that bandwidth isn't remarkable on its own.

Sizing rule of thumb: model file size + 20–30% for the working context. A 5GB Q4 model wants roughly 7GB free.

Memory bandwidth: the often-ignored bottleneck

Memory bandwidth predicts local AI decode speed better than any other spec:

One of the first things I realized is that my laptop of choice can run a 27B model just fine. It's just slow at doing it. But most of the work I need to do with AI is not real-time. The very first feature that I used in Clairvoyance was the scheduling. I have so many dashboards, crash reports, sentiment reports, sales data coming in that I just have it run overnight for me to look at in the morning. I used to have that on Claude and that stuff was costing me $100 a month in tokens. But a 27B model can do it exactly as well and at no cost as long as I schedule it.

Diversion: Geek out on Hardware

• The RTX 5090 is the current consumer king. Nearly 1.8 TB/s means a 5GB model decodes at hundreds of tokens/second, and its 32GB of VRAM fits a 4-bit 27B with room to spare. If your goal is "fast local AI, money is no object," this is the answer. As of this writing, an RTX 5090 currently retails for a little over $4.6 trillion dollars.
• The RTX PRO 6000 Blackwell is the 5090's workstation sibling: same ~1.8 TB/s bus, but 96GB of VRAM, enough to hold a 4-bit 70B (or an 8-bit 70B, barely) on a single card at full speed. It solves the problem two 4090s can't (see below), big model and big bandwidth in one memory pool, for roughly the price of a decent used car. The use case for us would be you'd park one of these on the rack and have several users on it running a 27B model in real time.
• The Nvidia DGX Spark is slower than you'd expect. It's marketed as an AI supercomputer for your desk, and for capacity it delivers. 128GB of unified memory fits models no consumer GPU can touch. But its 273 GB/s bandwidth is less than half an M5 Max, a quarter of a 4090. It runs big models acceptably; it does not run any model fast. You're buying capacity, not speed. There's a reason these are in stock at Microcenter. I'd just buy a Snapdragon X2 Elite Extreme or Mac M5 Max instead.
• AMD's Radeon RX 9070 XT at ~645 GB/s out-decodes every laptop and more than doubles the Spark at a fraction of the price. It's one of the best value plays in local AI, provided the model fits in its 16GB. A 4-bit 9B flies, a 4-bit 27B just squeaks in. The main issue here is the amount of RAM they put on it. Envision me shaking my fist at my friends at AMD. 16GB max? Why? Why did you do this?
• Two 4090s do not make a 2,000 GB/s machine. The usual way to split a model across two cards is by layers, half the network on each, and a token still passes through the layers in sequence, so each card sits idle half the time. What you actually buy with the second card is capacity: 48GB of VRAM, enough for a 4-bit 70B, at roughly single-4090 speed. (Tensor-parallel setups can claw back some speed, but that's server-software territory, not a checkbox.) Two mid-tier cards to "add up" bandwidth is a common and expensive misunderstanding. But 1000 GB/sec is no joke. 48GB of RAM handles that 27B model just fine.

Extra Detail Stuff

The back-of-envelope math: decode speed ≈ bandwidth ÷ model size. A 5GB model on a 152 GB/s bus tops out around 30 tokens/second no matter how many TOPS you have, because generating each token means reading all 5GB. Our measurements land right on this line: 9B models at 4-bit decode at 21–23 tokens/second on a Copilot+ certified laptop whether we use the CPU, the NPU, or both.

This is also why we learned, the hard way, with a stopwatch, that routing big models to an NPU is pointless or worse. The NPU shares the same memory bus as the CPU, so it can't decode any faster, and its dedicated fast memory is tiny, so anything beyond roughly 3B parameters doesn't fit where the NPU is actually fast. Our working rule is now simply: models over ~3B run on the CPU; the NPU is for small models and for prefill. Small model on NPU: brilliant (a 3B doing a full task in 5.8 seconds). 9B on NPU: same speed as CPU at best, sometimes slower.

Smaller models are proportionally faster, not just a little faster. Half the parameters, twice the tokens per second, on the same machine. Which brings us to what you should actually run.

Part 3: Real world usage

The right model for the right task

"Which model should I use?" is the wrong question until you've answered "for what?" Capabilities don't scale evenly with size. They arrive in tiers:

• Chat and Q&A: Works surprisingly far down. Look for a 3B model. That's your sweet spot for this. As soon as you go to 4B you max out the Copilot+ spec for memory bandwidth. TURN OFF thinking if the model supports it. You lose all the benefit of speed and a 3B model will never think itself into being smart.
• Tool use (the model calls functions: search, open a file, run a query): 9B. This is the "Edit this email" level.
• Agentic work (multi-step: search, read the result, decide, act again): Right now I would say 27B is the sweet spot. But a 13B model can do a lot of this and run real-time on an M5 Max level machine.
• Judgment (which of these is better? is this claim supported? did I make a mistake?): The last thing to emerge. In our sweeps, the 27B was the only model that went 3-for-3 on every configuration with clean or self-correcting tool use. It noticed its own errors and fixed them. That is a capability, and it doesn't compress. But this is only on newer 27B models.

Side Note: Thinking is not always a good idea

Reasoning models, the ones that deliberate in a visible scratchpad before answering, look like the obvious way to buy quality without buying parameters. At the small end it backfires, and our own benchmark testing showed it was pretty terrible.

We ran our favorite 3B model (VibeThinker-3B) through the same find-and-display task as everything else here. With thinking nominally disabled, its reasoning training still leaked into the output: 2,000–3,000 generated tokens per run, against roughly 70 for a conventional model on the identical task. At 43 tokens/second, that's about a minute of deliberation before the useful answer starts. End to end it took 85–104 seconds, and it was unreliable. One run never called the tool at all. A conventional 9B, three times the parameters, finished the same task in a sixth of the time.

Then we gave it a prompt template that actually suppresses the deliberation. Same model, same hardware, same task: ~56 generated tokens, 5.8 seconds end-to-end including a cold model load, and three successes out of three across CPU, hybrid, and NPU. It went from the worst configuration we had measured to the best one in the sweep. Thinking != Smarter.

Below roughly 4B, turn thinking off. If a task genuinely needs deliberation, those tokens are better spent on a bigger model answering plainly. The 27B above did its self-correcting with thinking switched off. One distinction worth keeping straight: a model distilled from a reasoning model is not the same animal. The 4B distill in the same sweep emitted 155 tokens per task rather than 3,000, and was one of the fastest reliable configurations we measured.

Time to first token

The first speed you feel is the pause before anything appears. It's the sum of model load (if not already resident, loading 5GB off an SSD takes seconds) plus prefill of your prompt. This is where NPUs and GPUs matter. Now you know why that first "Hello" takes so long. It's basically booting the model.

Prefill speed

Measured in tokens/second of input processing, and the spread is huge: we've measured the same 3B model prefilling at 576 tok/s on CPU and 1,908 tok/s on the NPU. For chat, with short prompts, you barely notice. For anything agentic, where every turn re-feeds the growing conversation plus tool results, prefill speed compounds and quickly dominates. This is the legitimate use of that big TOPS number.

Tokens per second (decode)

The number everyone quotes, and the one that governs how it feels once text is flowing. Real measurements from a Copilot+ certified laptop, all 4-bit unless noted:

Note how cleanly it tracks model size. That's just the memory bandwidth ceiling from Part 2 showing up in practice.

Real-world examples: 3B for chat, 9B for light tool use, 27B for real work

Putting it all together, from our own benchmark sweeps (same task, find a document and display it, run across 35 hardware/model combinations):

• 3B on NPU: completed the entire task in 5.8 seconds end-to-end, including starting the server and loading the model cold. Warm, the same turn takes 2.4 seconds. Reliable across every run. This is the "it just feels instant" tier, and it's what a modern AI laptop should be doing for quick tasks.
• 9B on CPU: ~18–24 seconds for the same task. Noticeably more thoughtful answers, comfortable with tools, still fast enough that you don't context-switch away.
• 27B on CPU: ~41 seconds. Slow enough that you go do something else, but it was the only model that never failed, and the only one that caught and corrected its own mistakes. For work where being wrong costs more than waiting, this is the one.

So use the fast tier for things you're sitting there waiting on, and the slow one for things you hand off. Chat with the 3B, give the 27B a job and come back later.

And "real work" is not a euphemism anymore. The 27B in that benchmark is Qwen3.8-27B, released in mid-August 2026 under Apache 2.0, and its published numbers are the kind that would have been science fiction for a local model a year ago: 61.7% on SWE-Bench Pro and 70.7% on CoWorkBench, the latter edging out the 68.2% Alibaba reports for Claude Opus 4.6 Max, a frontier model. The pattern across independent write-ups is consistent: the 27B leads on agentic software-engineering benchmarks, while the frontier model keeps its lead on pure-knowledge tests (GPQA Diamond, Humanity's Last Exam) and raw terminal coding. Two caveats before you cancel anything: those are vendor-reported scores at full precision, and the 4-bit quant you'll actually run gives some of it back. But directionally, the gap between "toy" and "frontier" has collapsed to a benchmark-by-benchmark argument, for a model that fits on a gaming GPU.

But how many tokens per second do we actually need?

Useful anchors:

• People read at roughly 5 tokens/second (~250 words/minute). Anything above ~10 tok/s outruns your reading for chat.
• For agentic work the bar is higher, because most generated tokens are tool calls and reasoning you never read. You're waiting on the outcome. There, 20+ tok/s is where waiting stops being painful, and below ~10 it's genuinely tedious.

What does Claude Code do, as a reference?

For calibration against the frontier: Claude Code, Anthropic's agentic coding tool, running on datacenter hardware, typically streams output in the ballpark of 50–100 tokens/second, varying with model and load. Now look back at the table: a 3B model on a laptop NPU decodes at 43–57 tok/s. A local model on a battery-powered machine matches the typing speed of a frontier system.

It does not fully match the judgment, though as the Qwen3.8-27B numbers above show, even that gap is now contested territory rather than a chasm. The frontier model still wins on breadth of knowledge and the hardest reasoning; the local model's advantage is that the tokens are free, private, and available on an airplane. The trick to being happy with local AI is the same as staffing anything: match the size of the mind to the size of the task. And what you can run on your own hardware keeps getting bigger faster than I expected it to.

Conclusion

Hopefully this has helped you get a handle on what local AI can and can't do. If you can run it locally, I recommend doing so. Easiest way, by far, is to download Clairvoyance. Once you get comfortable with that, you can branch out. I recommend Ollama and LM Studio.

Now, let's take a step back from the benchmarks for a moment and look at the trajectory. A year ago, running a useful model locally meant enthusiast hardware and a tolerance for pain. Today, a certified laptop you can buy at Best Buy answers in under six seconds, a gaming GPU runs a model that would have been considered frontier a few months ago.
It doesn't take a genius to figure out where things are going. Because make no mistake: There are diminishing returns on the benefit of AI for most people. Just as you don't need an airplane to drive to the store, you don't need a ChatGPT Fable 7 to put together the nightly inventory reports or software crash telemetry. Most use cases of Power BI can be handled now by these Local AI models if you pair them with something like Clairvoyance.

The challenge is going to be integrating these capabilities into an individual or enterprise's workflow stack.

• A staff of persistent AI agents that retain memories of the workspaces they work in. I.e. They already build "second brains" and have since day one.
• Multi-model agent orchestration. An AI agent producer can, on its own, "hire" a Claude Code Opus 5 UI designer and a GPT 5.6 Terra engineer. You can tell it to do this too but it will do it on its own at its own discretion.
• Universal resuming of AI agent sessions across Claude, Codex, Cursor, Copilot, Grok and more. Run out of tokens on one? Resume with another. Oh and the session descriptions are summarized.
• Built-in local AI model handling through a friendly GUI. This includes a powerful local AI optimized harness and full tool-chain to let local AI actually do work and not be a chat bot demo.
• Rich visual Direct Terminal. You can run in a classic terminal if you want. You an have a dozen terminals running together. And if you paste an image in it will automatically store it somewhere for you. And the terminal does allow you to orchestrate agents. But the gorgeous Direct Terminal can create interactive HTML blocks in chat. Imagine the best, more feature rich web based chat bot you've ever used and then you can imagine something that isn't even nearly as good as Direct Terminal. There is nothing remotely close. It can even tell you your Claude Code cache hit %.
• Context compression and optimization to reduce token use and increase agent intelligence. In order to do Direct Terminal we have to have total control of the context. This allows us jettison tool call noise output before it gets to the cloud.
• File Protection. We can block agents from wiping out directories. Not through "hooks" but at the app level.
• Multi-agent communication (@ other agents). You can have a Fable 5 or other expensive agent just hanging around and do most of your work with say a GPT Luna agent and when something tough comes up, just say "Ask

  @Fable

  to look at this." and they will put together a hand off.
• AI Task Scheduler. This was one of our first features. Set schedules for agents to be spawned to do something. We use this to create Steam and Discord sentiment reports for us (i.e. who's mad today?) as well as for gathering crash reports and sending them to humans (or other agents) to look at.
• HomeDesk with dozens of AI-enabled micro-apps (artifacts). Probably one of the most obvious features and yet still exclusive to Clairvoyance. A vast library of AI enabled widgets that live in their own space. You an also ask agents to create ones for you (so not just weather and stock tickers but things specific to your needs).
• Local-first storage of files, exhibits, reports and other output, with the option to sync to the cloud. We don't want our stuff hosted by AI companies. When you link your stuff to an AI provider, you are just handing the the keys to your workflow and data to, at best, train on. If you think companies sharing your email address was bad, get ready for companies sharing your proprietary workflows. So nip that in the bud and keep your stuff local or on your own rack.
• Full-featured Todo and Sprint system that lets AI (and humans) plan out large projects and build them. Not just some Kanban board, a fully featured Todo/Task/Sprint system that the AI agents know how to use, comment on, and organize. No more having a big plan wasted because something went wrong half-way through. The sprint progress provides all the documentation and progress information.
• Highly polished, feature-rich Markdown editor with Obsidian compatibility, including .md, .base and .canvas file support. We love Obsidian. And its local-first philosophy will pay dividends to its users. We natively support all the file formats and users can point their workspaces as their Obsidian vaults.
• Complete Canvas system with over a dozen templates, including mind maps, flow charts, system architecture, org charts and more. Imagine your favorite flow charting or mind mapping app. Now imagine if your AI agents could just seamlessly work with it. As in, do everything in it that you can do.
• Built-in presentation generation and storage. If you've ever lost half-a-day making a Powerpoint presentation, you will love Exhibits. Tell your staff what you want, what data to know about and it'll make an Exhibit that will be polished and amazing and ready to be shared.
• Seamless sharing of any file, anywhere. No special directory. No hoops. Right click on a file, choose share, how you want to share it and you get a link. That C++ file in some project file you need someone to look at? No problem, right-click share it.
• Remote control of desktop agents from anywhere via a powerful but easy to use web interface. The morning doom scroll can be replaced with checking on what your agents have prepared for you and giving them instructions from your phone or iPad.
• Powerful code editor with an integrated language server, AI completions and a code observatory, built to support AI agent collaboration from the ground up. Not a fork of VS Code. Why have a code editor at all? The AI agents use them and anything they can do, we want you to be able to see what they're up to. Even our "subagents" live in their own windows so you can see what they're doing. The code editor is powerful, fully featured, lightning fast and there to make sure you can keep an eye on what the AI is doing.
• Company-wide domains with built-in mailboxes so agents can communicate with other agents at the company. Your agents can message other people in your company with news and information and they can be responded to by that person's agents with only the non-trivial things surfacing.
• Integrated credentials vault that lets users direct agents to use MCPs and REST APIs with minimal effort. No one enjoys having to type in some command line to get some MCP to work. But people do know how to add their credentials. No .env variables with your data in plain text.
• Direct Control feature that lets AI agents build, run and playtest local applications and iterate on them. You haven't lived until you look over and discover your AI agents playing Star Control. "They're testing".
• Rich database system with dozens of data viewers including Kanban, tables, budget manager, contact management and much more. AI is great at creating data. But without ways to filter and view it in useful ways, it's just noise. We fix that.
• Deep token budget analysis that shows users where every token was spent in a given session. Are you wasting tokens? Where is it going? How much are these MCPs using?
• Seamless onboarding for the installation of Claude Code, Copilot, Codex and more from a friendly GUI. Sure, you might know Winget or NPM but most people getting set up just want to press a button and have it. We do that.
• Integrated Clairvoyance AI harness that lets users work with multiple AI providers (Opus, GPT, etc.) with no setup. Don't have Claude Code or Codex or don't use them enough to justify a subscription? No problem, Clairvoyance provides GPT 5.6, Opus, etc. with its own harness so you can get started doing real stuff right away.

Greetings!

Version 0.83 of our new desktop manage for orchestrating AI agents to do work on your machine for you is now available.  Here are some screenshots highlight the work.

First fun little thing:  The common AI jobs artifact now includes a Game Maker.  Just describe what you want, and it will go make it.

Next up is the main (and admittedly less sexy) attraction: Data management.  

Some of you may be old enough to remember when IBM, Microsoft, and Apple were chasing the holy grail of "Information at your fingertips".  IBM and Apple had Taligent, Microsoft had Cairo (WinFS).  

The idea was to componentize things so that you could work on your data in a much more intelligent way rather than loading gigantic, bloated apps.  As you probably can guess, by the huge apps you are stuck using today, this failed.

The reason componentized apps (OpenDoc, COM, OLE, etc.) failed was because the first step was that data had to have a rich "metadata" wrapper around it.  Data had to know what could be done with it.  And shockingly, it was expected that humans would do most of this classifying by hand.   Unshockingly, they did not.

Now, fast-forward to 2026 where Windows search is still terrible. You have to remember whether the piece of data you need is in a Teams message, Sharepoint, OneDrive, Documents, some "appdata" thing, Dropbox, Google Drive, Slack, Discord, etc.    

The problem isn't that that the data is spread out.  The problem is that there is no nothing keeping track of this.  That is where Clairvoyance comes in.

Now, on the surface, Clairvoyance might just look like a worldclass AI agent orchestrator that bundles a great mark-down editor, mindmap app and code editor.  And it does do that.  But those features are prerequisites for the main event:  Total Information Awareness.

Clairvoyance doesn't run in the cloud. It's on your machine at your command.  And it can use AI to catalog all your files and it doesn't care where they are located.  That is the goal anyway.

The first step is getting that Metadata set up.   Users create workspaces and order an agent to catalog it.

So AI will go through your files and add the metadata.  Here's an example.  Now, the metadata isn't really for our benefit.  It's for search and AI to be able to know the relationships for.

Version 0.83 of Clairvoyance also adds "Deep Search" which lets people find this stuff.

At Stardock, most of our data is spread between Google Docs, Dropbox, OneDrive and Sharepoint.

So the goal here is to have agents classify all this stuff and then instantly find it.  And I mean instant (because metadata is basically nothing compared to searching a file). 

The tricky part has been and continues to be getting all the different types of files classified.  For instance, Adobe Premiere has one way of doing it and Excel has a different way.  

The benefits are speed, less memory usage, and great at finding your stuff. 

It's a lot of unglamorous work, especially making sure that the local AIs are able to do this seamlessly for users (because most of you are probably a: Sick of hearing AI hype and b: uninterested in having to know what "parameters" and "quantize" and other terms mean).

Greetings!

Over the coming months you are going to see a gradual evolution to WinCustomize as we begin to feature more and more creations that were AI assisted.

We now have an application called Clairvoyance that makes it easy for users to create all kinds of amazing things.   We have made a gallery that is gradually being rolled out to the public: Exhibit Gallery  Everything you could do with DesktopX by hand can now be made by its successor, Clairvoyance.  

Games. Widgets. Wallpapers. Cool visualizations. You name it.  Here are a few of mine:

Meadow of the Wind

Just a little open world meadow you can walk around in.

A frog simulator:

Frog Simulator

Little Sculptor

So come check it out.  We'll be merging Clairvoyance stuff into WinCustomize asap.

For the first time in many years, Stardock has invested in a massive upgrade to its server hardware.   It's, by far, the most expensive and expansive hardware upgrade we've done.

Part of it was necessitated by last year's near destruction of not just this site but all of Stardock's tech infrastructure.

About a year ago, we had an issue in our datacenter that caused many of our critical VMs to become corrupted and required us to reconstruct nearly everything from scratch. 

Now, we had backups but it was one of those things that hadn't been fully tested because you are talking something like 36 terrabytes of data.  

It took us awhile to recover and we didn't fully recover.  There was loss and the recovery wiped out our IT budget for the year.

Now, we are in 2026 and we are looking at where things are going with WinCustomize.  The first thing we're doing is migrating it all to the new hardware. This will happen in bits and pieces but you should notice a general speedup.

But the real change is going to be the complete rewrite of this site.  It's going to look different and we are going to be changing the site's mission a bit.  It's still about customization but the world is getting very interesting with people able to create a lot of interesting stuff.

I've already built a kind of test site for this.  You can see it here. https://www.clairvoyanceai.com/gallery/browse?type=exhibit 

That's just for showing off cool stuff people have made. It's not terribly applicable here since WInCustomize has always been about sharing things that others can use to customize their Windows experience in some neat way.

But I do think we can look forward to people being able to make DesktopX type things a lot easier and share them.  We just need to make a new product for it (a new DesktopX basically but one that is built with today's security -- we were so native 20 years ago).  

I'd like to get your opinions on what kinds of new things you'd like to see added here.  We are pretty far away from the days of people making Winamp skins and icon packages. People don't do that anymore.    I had thought, at one time, that maybe iPhone/Android stuff might be interesting but I never even change the wallpaper on my iPhone.

But I can imagine all kinds of interesting things that I might want to improve my desktop in 2026 provided it can be done without fear of malware or something getting injected.   

This UI was made by AI.  

So was this:

We are not quite at the point where AI can make the actual WindowBlinds skins themselves. Certainly not in real time. But I think we are getting close to where skinners will be able to make skins much more easily.

We don't generally allow politics on the forums.  With the obvious exception of The Political Machine. The Political Machine - The Power of the Presidency Can Be Yours! Forums

But the world trade situation is probably something worth discussing provided people can avoid assuming "the other" are stupid or evil or greedy or whatever.  

Now, I'm a child of Michigan USA.  Detroit area.  That means cars.  And I can say, regardless of political association, the topic of unfair trade has been discussed endlessly here.

I won't get into the issues with the UAW and Unions and whatnot.  But I will say that the global trade situation is more nuanced than most know.

To side-step the USA vs. China stuff, I want to instead talk about UK.

Last UK blast furnaces days from closure as Chinese owners cut off crucial supplies | Money News | Sky News

The United Kingdom is about to close its last steel plant.  I.e. for the first time since the Bronze Age, the land of England will stop being able to make metal.  That's a bit hyperbolic but the point is the same.  Losing the ability to make certain basic civilizational goods is a problem.

If we lived in a world that would never have any supply disruptions and could avoid having any wars, then it would be perfectly fine for the US, UK, the EU, etc. to just switch to a pure information economy of services and leave the production of physical goods to other countries.  But we don't live in that world.

When COVID hit, Americans discovered that most antibiotics and N95 masks were made elsewhere and no longer readily available.  This is a problem when there is a disruption.  

I don't know what nations should do.  I do know that it is probably a very bad thing if the UK, for instance, can't produce steel anymore.  Similarly, I think it's bad for the world in general if a single country produces virtually all the manufactured goods (whether that be the USA, China, or whatever).

Just my 2 cents.

Today we were finally able to get most of the forums back from the dead.  2 weeks ago we didn't think we would be able to bring them up.  And to be honest, we probably will never get everything back.  

Fun fact: These are (one of) the oldest continuously running forums on the Internet.  When we wrote the forums, back in the late 1990s, we had to do everything from scratch.  We built these to replace Usenet.

So a few things:

If you're forum account is "new" (as in the past few years) there's a good chance you'll need to create a new account.  We didn't lose the posts and we didn't lose the user accounts but we did lose some of the blue that pointed a post to the user account.   So if you are having trouble and you're not an old timer, you'll probably need to create a new account. 

We apologize for the inconvenience.

I recently got back into Virtual Machines and found the performance terrible on Windows 11.   

I couldn't figure out why.  There was noticeable input lag and even moving windows around was sluggish.  

I looked on Reddit and elsewhere and got advice about installing tools or configuring the VM differently but eventually just had a feeling that it had something to do with security on Windows.  So after a lot of trial and error I found this option:

Now, I am not recommending you disable this.  But on my home box, that is behind firewalls and I am using myself in relative isolation, I felt comfortable turning this off when doing VM work.  Doing so brought VM speed back to where you would expect it.

Hoe this helps.

Nearly a month ago now I got a call early in the morning. It was from our IT lead. The Datacenter...was gone.

At first I thought we were under some sort of DOS attack. Then I feared the worst, some sort of Ransomware? Were we going to find out that everything was encrypted and gone? We soon learned, no—but in some ways, it was worse. Everything we had at the Datacenter was wiped out. Everything. 34 Terabytes spread across a dozen+ servers of various ages with unique configurations dating back decades. Some of this stuff had been brought over from OS/2 back in the day. Some of the configurations were originally set up on NT 4 for PowerPC! Gone.

We have near real-time backups to dedicated servers at the datacenter but they were wiped out too. For legal reasons, I can't go into anything more specific than to say everything was gone.

We also do nightly backups off-site as well. But these are the kinds of backups you don't really expect to ever have to use. They're the equivalent of the old tape drives we used to use back in the day. You back up to them but you don't really anticipate ever needing them. But here we were.

The backup was a single, 34TB file. We debated how to get the data back fastest. I mean, couldn't we just put them on a removable HD and ship it? Well, not so much. The NAS or whatever it used at the off-site service has a USB 3.0 connection. Getting the data off would take many days and then have to be reuploaded via the USB HD.

Ok, so transferring it is. We have a 10Gb/sec net connection, how long could it take? The math made it out that we should be able to get it in just a few days. Nope. Weeks. It took weeks.

And once we got it back, things didn't look good. While the raw data was there, it was not obvious how all this would hook up again. Remember, we are talking a hodgepodge of servers that have been around decades. You can't just spin this stuff up.

I talked to Jafo and LightStar and others and I told them I didn't think we'd be getting WinCustomize back. Even if we got the skins and themes back, the spaghetti of the skin library databases would not so easily be brought back to life. Even now, it's not clear how well connected the various files will be.

Near the end of March I wrote:

Dear Artists, Skinners and Designers,

For 24 years we have created amazing things together. I am sad report that we suffered a catastrophic data loss. This data loss also consumed all of our on-site backups as well. While we did have many offsite backups, the sheer size, complexity and fragility of the data has made it impractical to restore them. As a result, we have made the painful decision to close WinCustomize.com.

We have enjoyed the near quarter-century of collaboration, conversation and creation with you. I am sorry to see it end. It is, indeed, an end to an era.

Farewell,

-Frogboy

But the team didn't want to give up. Pat, myself, Jillian, and others from the 2001 era are all still at Stardock and the team was desperate to save WinCustomize.

And so tonight, as I write this, we're...almost back. The site definitely is worse for wear. We are going to need your help to rehabilitate the site and we will be grateful for as much grace and patience that can be sent our way as we still struggle to bring it back. But I am happy to report that WinCustomize has survived—and we couldn't have done it without the incredible determination of our team and the loyalty of our community. It's going to be a journey, but it's one we're committed to taking together.