ComputerGuru

My friend, the same way everyone else does. It goes from 0% to 28% interest when you miss a payment. Those are rates normal lenders fall asleep dreaming of.

Not to knock on RISC-V, which I’ve been following from the embedded side of things for many years now, but I feel I must question the value of a license-free ISA in this specific market segment at this time.

Surely between the squeeze on RAM and storage pricing and the exorbitant costs of training or mass-inference scale GPUs (if you’re going into AI), the nominal cost of the CPU licensing is really not going to make or brake anything or unlock some new business viability?

Even RISC-V aside, we are essentially in a position that would have been impossible to even dream of ten or twenty years ago when Intel was the only player in the game.

Wouldn’t buying off-lease hardware (not even in bulk) give you better performance per dollar, better compatibility, and more options?

Not to say any of this will always be the case; even if RAM pricing doesn’t come down, storage will, and RISC-V processors will (maybe) eventually actually be competitive when it comes to SOTA performance, but today in 2026?

0% APR for 12 months (24 for iPhones only?) from Apple Financial Services for a device that can approach or even exceed what we were paying for new cars just a few years ago. Apple is definitely making bank off these financing offers, and with very little risk as unlike a car these Mac Studios don’t lose 20% of their value when you drive them off the lot.

Interesting times, to say the least!

Neither is the right alternative to compare to. You aren’t going to hit 100% utilization (if you are, ignore me, this doesn’t some to you, and write a blogpost for me to read and share).

The comparison should be against renting in the cloud for the duration of your task for training and research or using pay-per-api-call providers for general inference instead of buying your own hardware (and paying the electricity and cooling bills on top), because let’s face it, the models you want to use are probably the same ones available on inference providers (but, yes, some are more trustworthy than others).

Speaking as someone that does ML/AI research, you are essentially paying a huge premium for being able to just run your Python script at any time without setting up a deployment script and harness to run the job remotely, while your hardware sits essentially idle the rest of the time.

The only way to make the math work is if you rent your hardware in the background for inference while you’re not using it in anger, but despite all the startups and promises that has never become as streamlined as mining bitcoins or shitcoins used to be and they don’t pay out as much as they say they would. Renting your hardware for training is another option but doing that is a lot more involved, options are fewer and farther in between, you won’t get as much utilization out of it, and doesn’t let you feasibly abort running tasks at a moment’s notice.

I can totally see how this feature would upend most architectures. Great work, I am adding a todo list action item up see if the performance can’t work out in favor of using this in place of the browser APIs we currently run to maybe adopt it. Love what you’ve done with the package and the site (this isn’t the first time it’s come on my radar, but you’ve spurred me to actually do something about it this time).

I love your editor/comparison tool. Would you be open to adding browser WebP?

Is the JpegXL lossless options the "transparent JPEG recompression" or the actual lossless profile? I'm presuming the latter because it more than doubled the image size.

I'm a fan of JpegXL and happy to see support finally begin to coalesce around it on the browser scene, but I was wondering if anyone knew what goes into the decision of whether or not to consider adding encode support, e.g. via offscreenCanvas.convertToBlob() or whatever. How did browsers (minus Safari, of course) end up deciding to add support for WebP encode in addition to JPEG and PNG?

I think model naming has been atrocious in general, in part because newer "lite" models surpass the capabilities of previous "pro" models (case-in-point: Gemini Flash which now surpasses the capabilities of the latest Gemini Pro, with a newer Flash Lite vying somewhat unsuccessfully for the old Flash price/positioning), but gpt 5.6's Sol/Terra/Luna split is really not bad at all - probably easier to understand than Starbucks' cup sizing!

The problem becomes when you add in the adjustable reasoning efforts and you end up with {model, reasoning_effort} combinations that end up completely obviating particular model classes altogether for at least some percentage of queries; e.g. with GPT 5.6 the price/performance Pareto frontier is dominated by permutations of either Luna and Sol, with Terra nowhere to be seen (but then if you need "large model smells" that aren't captured by your benchmark you can't even rely on this, as a model like Luna simply isn't capable of encoding sufficient world knowledge in its weights to perform certain tasks at any reasoning level but you might be able to get away with Terra on low reasoning, but no one seems to be covering this for some reason).

It's a 20% discount on input and a 33% discount on output through at least November 21, 2026; the revised pricing schedule is now

    Model       Input  Cached input  Cache writes  Output
    gpt-5.6-sol $4.00  $0.40         $5.00         $20.00
    gpt-5.6-terra
                $2.00  $0.20         $2.50         $12.00
    gpt-5.6-luna
                $0.20  $0.02         $0.25         $1.20

So Sol is still 20x Luna, but much more appealing when compared to offerings from Anthropic and others.

AI-generated text warning (I submitted - but did not author - the piece), but it seems MS Paint and MS Photos add both a visible (can be turned off) and invisible (cannot be disabled and happens silently in the background with no user notice) watermarks to photos that have been AI-manipulated, even when using a local model to perform the action. It's not clear if this applies to even things like using AI-enhanced background delete/remove, but the invisible watermark is embedded in both the image pixels and the image metadata, both containing a GUID that can be linked to the exact prompt that was used and the originating device/user (on Microsoft's end).

Obvious next step is to explore if you can replace watermarker.dll with a (signed) no-op shim or MITM the API call to at least use your own (nil?) GUID that isn't linked to your device/account.

In case it's not obvious, my bigger concern isn't "this image can be identified to have been generated with/by AI" so much as it is "digital yellow printer dots have been forced upon us, except they can identify and retrieve the exact user/device/time/place/document/etc", completely destroying any and all illusions of privacy left.

Nope. Handles vision differently.

Gemini 3.7 Flash and 5.6-Sol (on all reasoning levels) also answer 8:10:25. The new "stealth" Ox Alpha also replies with the same. Opus 5 replies with 8:10 (no seconds). Not sure why this is so hard for them; Gemini is especially good at vision and I would have expected better from it.

But the discount is only available via OpenRouter.

Does OpenRouter eat this cost to get their hands on a copy of the conversations people are using with the model?

You can’t check it with only the algorithm, you need the secret seed key. Which will be different for each provider (and they’ll probably have and use multiple). And you need the llm itself, to generate the potential tokens at each step.

This was 3.5 flash lite, actually, and after prompt tuning. It was very clearly an issue that correlated with input (JSON array) size, the more elements in the batch, the higher the error rate.

3.0 flash (not lite) handled it like a champ though, fwiw.

We have 3.7 Flash now, actually, and it costs just a hair over the old 3 Flash Preview while being better!

Speaking from experience here, flash lite models have amazing price, speed, and perform far above their size, but are susceptible to very bad instruction following and recall when either complexity or context size inch up. They’ll just forget to apply your instructions to portions of the input, and repeat parts of the input that should be returned verbatim as direct quotes but with subtle changes (breaking urls, for example).

Complaining about overthinking in xhigh then pointing out output had bugs with thinking turned off seems like it’s missing the obvious compromise?

Thanks for the corrections, but I am specifically talking about semantics from the Unicode Technical Committee's perspective, of the underlying Unicode codepoint(s). There is a reason some end-user-viewable glyphs can be formed in multiple ways, sometimes with standalone codepoints (precompositions, sure) and sometimes via the use of combining marks. You have to go back to the Unicode project's actual founding vision, and its basis for accepting new codepoints or declining to do so. People are surprised to learn it has little to do with what the human-visible end result looks like.

It’s really a complete and total nothing burger. Extra code points were added, might have been an issue when we were trying to cap the total number below needing some arbitrarily fixed number of bytes for convenience, but now that’s no longer the case and they’re just a historical oddity that costs nothing to maintain and certainly don’t “haunt” in the sense of “ keep popping up and causing problems” in any way.

I appreciate the article nevertheless, of course, but I do feel that it would probably be more meaningful to someone that has at least a basic understanding of Japanese.

iOS at least renders it as an n with dieresis; is that how it was intended (I’m unfamiliar with musical notation)? If so, what is so difficult about it?

In fact, (semantics aside, from a technical perspective) the preference should always be for modifiers rather than standalone characters because the chances of being supported by the viewer’s font are much greater: it doesn’t need a separate glyph explicitly drawn and add to the font file for the code point. Difficulties in entering it or typing it out should be mitigated with client-side affordances in the UI, shortcuts, etc.

Clickbait post, already made the rounds on in other sites and was mercilessly torn to shreds. The answer is that millions do in production. PgBouncer is only needed for stateless backends, and even then, only under specific circumstances.

I never trust OpenRouter to forward parameters correctly and would only ever conduct benchmarks with the official api, personally.

At this size, it certainly doesn’t have to be.

But this isn’t a query that should need to be forwarded to the cloud for acting on!

Can you share more about the architectural/design tradeoffs you considered or decided upon? Particularly for me, why is a model that is intended mainly to just make tool calls and marshal the results back focusing on speed? Speed as an inherent result of small size, I get, but speed as a design focus confuses me because it’s simply not going to be dealing with large outputs as a rule, wouldn’t it be better to trade some of that raw speed for better smarts?

For example, I mocked a dumbed down version of what would be a reasonable intermediate tool call prompt:

> It's currently 58 degrees. User asks for house to be 8.5 degrees warmer. What temperature to set thermostat to?

The reply?

Reasoning: “User asks for temperature to set thermostat to 8.5 -> set_thermostat with temperature=8.5.”

Sounds like something Siri would do!

We are still paying the price for that today, some of us a lot more than others. It was well-intentioned but with hindsight being what it is, historians pretty much agree that it was the cause of a lot of the problems we fight with today.

Yes, I found that as a workaround but I can't help but feel it's maladaptive since your spine is no longer aligned.

What an awful website for such a wonderful feature. I don’t expect to see this in the original Find My (Apple’s) as their implementation is fully custom and works altogether differently (and already had a protocol-level rewrite not too long ago), but this is still really cool. Of course needing to be in range of the device is always a problem; some ear buds will drop out altogether if you walk to the next room.