amaranth

The multicore is only close because the RISC-V one has twice as many cores and uses twice as much power. That would suggest the RISC-V cores are getting around pi3 levels of performance which is a decade old and losing badly as perf/W.

The first one might not make sense but it gets them the pipeline for when it does make sense in the future. Plus for a lot of things using LLMs they'd be fine with older tech, especially if running it was even faster and cheaper.

Phones and watches do that with LTPO OLED which I don't believe exists at higher screen sizes although I'm not sure why. This is supposed to be special because it isn't OLED so should be able to get brighter and not have to worry about burn in.

A 2080 is about the same performance as a 5060 and every game is going to be able to run on a 5060. You might not be running it at 4K Ultra with ray tracing enabled but you should be able to run at like 1080p High or better.

Whether or not the M5 GPU is actually capable of that level of performance or whether the drivers will let it reach its potential is of course a completely different story. GPU performance is hard to estimate based on raw specs, you just have to run benchmarks and see what you end up with.

I believe it's legal because rear doors have child safety locks so often can't be opened from the inside anyway. Although that doesn't cover opening it from the outside...

One factor is that a part of their measurement is tracking how many new companies are founded and estimating how many employees a new company is likely to have. These numbers have been trending down and rapidly fell due to a lot of new companies being one person LLCs for gig economy work. It appears they haven't kept up with this trend so they overestimate how many jobs these companies will have.

That's what Intel wants everyone to believe but not quite accurate. Intel was vague at best about what the motherboard manufacturers should and were allowed to do but even following their guidance as best as possible resulted in CPU failures. Gamers Nexus did a few videos on this, here is one that covers most of it.

https://www.youtube.com/watch?v=b6vQlvefGxk

That's less of a thing here since this is "just" an ITX motherboard, a case, and a power supply. With the laptops replacing the board saves a bunch of other parts but here the board is basically the only part that matters.

The N64 is older than Pokemon.

Google Assistant is going away soon so this won't work anymore.

https://arstechnica.com/google/2025/03/end-of-life-gemini-wi...

Safari doesn't support zstd, that means if you want to use it you have to support multiple formats.

Now drag a window from one monitor to the other. The choice on X is to have both monitors run with the same specs (well, not for everything but yeah) or to have two completely separate screens at the X level which means they're isolated from each other and you can't move thing between them.

There isn't a cheaper card that's worth buying over using the iGPU you already have so yeah, that's the low end.

Yeah, I worked on that but I didn't think that would count since it was a distro, not a desktop environment. In that case Novell shipped compiz in 2006 so even earlier.

My understanding is that most of the complaints about Vista being unstable came from the nvidia driver being rather awful [1]. You were likely to either have a system that couldn't actually run Vista or have one that crashed all the time, unless you were lucky enough to have an ATI GPU.

[1] https://www.engadget.com/2008-03-27-nvidia-drivers-responsib...

GNOME 3 had a hardware accelerated compositor on release in 2011.

It's also meant to make it (somewhat) easier to apply various GPGPU filters and scalers before encode or after decode, like HDR tonemapping. The OS usually has some method to do this while keeping the data in the GPU VRAM by passing a handle from one API subsystem to another but if it never leaves Vulkan you don't have to worry about getting that right.

There are in fact two "to native" compilers for Kotlin, the one for Kotlin only is called Kotlin Native but you can also use graalvm native-image to compile any JVM language to native.

sd_notify is for additional (useful) functionality, it would work fine without it. You can tell because it works on arch.

The focus on _latency_ is a recent thing. VTE was previously focused on throughput and low CPU usage, which are conflicting goals.

In Rust the answer is "it depends". Since the runtime is not provided by the language you can have implementations that are a single thread, thread-per-task, a thread pool, or whatever other setup you can think of. Tokio at least offers a single threaded version and a thread pool version.

The font rendering thing is more complicated than that. Subpixel antialiasing doesn't work with animations and I'm pretty sure it interacts poorly with fractional scaling too. The fact that you don't need subpixel antialiasing if you have a HiDPI display just lets them make the tradeoff be "you need a good monitor" instead of having to choose between jaggy text or weird shimmering on animations.

According to [1] the estimated number of iPhone users (leaving out any Mac users) in 2024 is 1.46 billion.

[1] https://www.bankmycell.com/blog/number-of-iphone-users

If you live in the US there is a good chance that was your phone company throttling Netflix and the app automatically switching to 480p to adjust to the reduced bandwidth. They probably do that more broadly now but when they first started it was only Netflix.

They launched with one with a built-in disc drive and one without. For their mid-cycle refresh they changed it to a single model with a disc drive add-on but sell a SKU that includes the drive in the box.

Wasn't uMatrix dropped because at this point it's just a more powerful UI to do the same things uBlock Origin lets you do?

The name comes from Node so that ship has sailed, I think.

https://nodejs.org/api/n-api.html#node-api

I take it you disregard pretty much all of quantum physics then?

GNOME started down their current path through a combination of Easel (started by the people who designed the Macintosh) designing nautilus and icon sets and trying to get the desktop to be more cohesive and Sun pushing hard on accessibility which also meant making things clear and consistent. Those influences were boiled down into the GNOME Human Interface Guidelines which all apps are supposed to follow.

The easiest way to make things clear and consistent is to have less things, the idea is you have a clean base then figure out how to add the things people are still wanting the most. If you had whole development teams working on these things then that would work (see macOS) but without that people implement the simplest parts and avoid the rest due to it not being fun, not having an agreed design for them, the design being too contentious, or just a lack of time.

This is at least partially because there is a performance overhead to calling out to C from Java or Go so eventually the optimal implementation of something will be in the language itself. Rust's zero-cost calls to/from C is a positive in that it gives you a large ecosystem of existing code to use but a negative in that people are more likely to just try to build "safe" wrappers around those instead of writing something safe in Rust. This is somewhat countered by the "rewrite it in Rust" folks but you still get more C wrappers than Java or Go.