bno1

Just today I've used this in a Windows 11 QEMU VM to fix rekordbox (it failed to start about 4 out of 5 tries). rekordbox uses Unity with OpenGL for the UI and I guess the devs never tested it on a computer without GPU acceleration. Amazing stuff.

What stops a scraper from detecting Anubis and just removing "Mozilla" from the user-agent string?

I wonder how they deal with multi-threading. Forking a multi-threaded process is very error-prone (e.g. allocator locks can remain orphaned).

Proton uses esync or fsync which (from what I've read) are on-par with ntsync. However, esync and fsync can't be merged into upstream wine because they can't properly emulate some quirks of NT sync objects, hence the ntsync driver.

A big issue with IPC is thread scheduling. Thread B needs to get scheduled to see the request from thread A and thread A needs to get scheduled to see the response from thread B. I think there are WIP solutions to deal with this [1] this but I'm not up to date.

[1] https://www.phoronix.com/news/Google-User-Thread-Futex-Swap

I found squashfs to be a great archive format. It preserves Linux file ownership and permissions, you can extract individual files without parsing the entire archive like tar and it's mountable. It's also openable in 7zip.

I wonder how pack compares to it, but its home page and github don't tell much.

Why doesn't USA pass a law that enforces data on US citizens to be stored in the US, like GDPR does in EU?

Errant Signal's analysis is also really good: https://youtu.be/wlBrenhzMZI

No, the entire point of those vulkan extensions is to use the hardware-accelerated video processing units. You can use computer shaders for software decoding on the GPU, there is no need for special extensions to do that. AMD and Intel have specialized encoding/decoding hw too.

Isn't inverse transform sampling even faster than ziggurat? Most languages have an approximate erf^-1 implementation, everything is straight forward from there. I needed to generate random numbers from a truncated normal distribution and found inverse transform sampling easier to implement than trying to understand and adapt the ziggurat algorithm.

A nice blog on this: https://stackedboxes.org/2017/05/01/acklams-normal-quantile-...

I think the people who say the Pixel 8 slow are gamers. Even a cheap phone is fast enough for the vast majority of people unless they play 3D games on it.

Someone is trying to game on them, or at least run DirectX apps in Linux, based on this PR: https://github.com/doitsujin/dxvk/pull/3795

"The internet has been broken in a fundamental way. It is no longer a repository of people communicating with people"

But the examples given are... google search results and articles from big publishers, things made to cast a wide net. Those were never good ways to communicate with other people online imo. If you want to interact with real people look for smaller communities and individual creators.

I wonder what forests looked back then. Trees going through and on piles of dead trees?

Thank you, makes sense now

> Note that an acquire load of p would have prohibited this reordering, since acquire loads block all future memory access, even if unrelated to the value being acquired.

I don't really get this part. The docs for acquire say:

> memory_order_acquire A load operation with this memory order performs the acquire operation on the affected memory location: no reads or writes in the current thread can be reordered before this load. All writes in other threads that release the same atomic variable are visible in the current thread

The prefetch is already ordered before the load in the same thread.

Saving a few ms during decompression actually matters when the game streams data from the disk in real time. People also hate loading screens and objects popping-in because the streaming pipeline is slow.

Well yes, because on Linux you use mmap to reserve virtual memory.

I wouldn't say that tooling is not aware of all that. For example, top and htop display virtual memory and resident memory and shared memory. You need to look at resident memory if you want to know physical memory usage.

That's most likely reserved virtual memory. It's not committed, meaning it's not backed by physical memory.

I don't really get the point of the article. You can opt out of the privacy sandbox and block interests you don't want apps to see. The biggest change seems to be that chrome cand feed data into this system through an Android API, but doesn't this already happen through telemetry, analytics scripts and fingerprinting? You can also just not use chrome.

Sounds like you want font hinting but for vector graphics.

*piracy sorry

Copying is privacy and piracy is still an issue for the host.

Just yesterday zmike held a presentation about Zink at XDC, it's very interesting to hear about all the issues they had to deal with (he's also a great person to listen to): https://youtu.be/0XSJG5xGZfU?t=6h49m36s

Their "negative latency" thing really didn't sound practical at all for games where latency matters.

Generating an UV map from an untextured mesh. The UV map is stored in vertices as texture coordinates, and together with the topology of the mesh it defines how the texture (images) gets mapped to the mesh. A good UV maps preserve surface area (e.g. every region of the mesh map to regions of the texture proportionally, otherwise you get stretching), have few seams and have little empty space around the texture to reduce size.

There are ways to do this automatically but they're far from perfect. Artists usually take the mesh and literally unwrap it until it's planar, and convert this transformed mesh to the UV mapping. The advantage of this method is that it gives you very good control of seams and texture islands, but it's tricky to preserve surface area.

Those neural rendering methods are very cool because they use light/color fields, but they still have a lot of catching up to do compared to modern 3D graphics.

An AI that does good UV unwrapping would be much more interesting and useful.

I wish pip had some package deduplication implemented. Even some basic local environments have >100MB of dependencies. ML environments go into the gigabytes range from what I remember.

They do transport you to the other side tho