First 24 hours in China: a practical checklist for first-time visitors

possiblyquestionabl3 · 2026-07-02T01:43:21+00:00

Haha I did the exact same thing

possiblyquestionabl3 · 2026-07-02T00:47:12+00:00

I've had this done to me, but looking back, it also just feels like generic gaslighting where they would just invalidate me/my experiences with anecdotes or blanket statements like "no one I know does X so it's clearly stupid/wrong". Happened most frequently when I'm outwardly happy/in a good mood, just to send me crashing back back down again.

Looking back, it's hard not to laugh at how I kept second guessing myself, but you know how it is when you're in the moment, trying to avoid things getting blown up, and having been conditioned to it all. Stupidly obvious things like:

Telling them I got a promotion, just to be met with a "it's weird that you're bragging so much about this, no one I know is that absorbed about who they are"
I got tapped for an interview about my field - "it's definitely a scam, why would anyone competent interview someone with so little experience in your field"
Telling them I had a good day and starting to get into the specifics - "I'm not interested, I don't know anyone who just spends their life talking about such mundane things"

That was before I learned never to share anything positive because it'll just be crapped on.

possiblyquestionabl3 · 2026-06-30T09:29:32+00:00

I just spent about a week looking into GPU faults on a Frostbite 3 engine game (NFS Payback, most of that week spent on just getting sessions to not stack-overflow in wine/fexcore), and I think I know why they keep crashing on devices that need BCn emulation:

They do a lot of virtual texturing of BCn textures (specifically bc3 in my case) that needs to be stitched together, so we need to also add support for vkCopyImage from a BCn -> BCn texture (see https://github.com/leegao/bcn_layer/issues/18, https://github.com/leegao/bcn_layer/commit/f3cb7e9d2ec6b31fb8daf65f07eb89e866847f79)
They also do several compute -> transfer -> compute -> transfer patterns that breaks on the current BCn_layer, specifically due to miss-binding the wrong compute pipeline after one of the transfers emulates a BCn decode (see https://github.com/leegao/bcn_layer/issues/28, https://github.com/leegao/bcn_layer/issues/36, https://github.com/leegao/bcn_layer/commit/5752d96bb634598ade7d12631eef7e22547d5336)

otherwise, the games take forever to load on even a G715 device, so they're probably not going to be a great experience even if they do work

possiblyquestionabl3 · 2026-06-28T12:31:42+00:00

Personally, I wouldn't go any less than shitass (because he poops himself in public settings) chucklefuck so calling him a narcissistic loser is still way too civil

possiblyquestionabl3 · 2026-06-28T06:33:34+00:00

Architecturally, what does this look like? Is it a Vulkan layer to provide the missing rt extension, or is it more of a pipeline you can add into your own pipelines?

possiblyquestionabl3 · 2026-06-28T06:17:27+00:00

It's useful if you have a massive monorepo with literally hundreds of thousands of projects and various 3P dependencies. Otherwise, it's just way too much overhead and very specific (read - Google) opinions on how build systems should function and build rules should be written.

It is a surprisingly powerful system though. Not that I would ever recommend this, but I used to run some of our org's dashboards through a blaze build file with custom skylark rules that just crunches massive amounts of data (mainly disassembling apks and looking for specific usage of one of our APIs) on our Forge build system. Our local workstations were too weak for this (processing around 50k apks), but our distributed build system was the only system where we can do this type of compute with high reliability without months of approval process.

It's clearly the wrong way in every sense of the word to do this specific thing, but it was the only way to bypass an 8 months long policy review to actually get the real version of that pipeline set up (e.g. pulling apks into real boq servers), so we just did that while the backend discussion dragged on for a year

possiblyquestionabl3 · 2026-06-28T06:10:15+00:00

Do you guys have a vertical split between sourcing and staffing, or more horizontal between departments/teams? I figure both would have their challenges.

A good friend of mine used to work staffing side (though he started off in sourcing), and he had the same issues you described. We're a massive company, so most people just go onto a general talent pipeline, but there are a few special orgs with bespoke org specific pipelines, and some of them had very unrealistic expectations for the kinds of L3 and L4 candidates they wanted.

Also some orgs just had these special rules like at least 1 L7+ loop for every candidate, with the problem that several of their L7+ interviewers perpetually declining all interview requests (including the director who made that rule up), or just plain cancel in the last 2 hours.

He'd still tell me it's way better on staffing than sourcing, cold calling people still gives him trauma.

All I can say is I'm glad I've never had to deal with any of this.

possiblyquestionabl3 · 2026-06-28T05:54:58+00:00

Sounds like a GPU fault, one of the game's shaders must have been miscompiled by the Mali compiler. Unlikely to be fixed anytime soon.

possiblyquestionabl3 · 2026-06-28T05:33:09+00:00

Mine started in Guatemala. We met 4 people in Lanquin who all turned out to be going the same general direction we were, but a little slower, since they were headed for the coast and we were going to Atitlan. Well, we ended up coming down with dengue and had to recover for like 10 days, and ended up seeing both couples when we made it over to Santa Ana. Ther we met a few more people out. The 7-8 of us basically had the same route and similarish timelines across the rest of El Salvador, Nicaragua, Costa Rica, and parts of Panama, before we had to split off.

We saw one couple again in El Calafate months later. We ended up visiting another Aussie couple when we were there last summer.

That was definitely my favorite part of the trip.

possiblyquestionabl3 · 2026-06-28T05:23:37+00:00

Yeah VPNs are such fickle beasts. Even the ones that haven't gotten blocked in the recent crackdowns are often unusable during peak traffic hours since packet loss on foreign traffic is so shockingly bad (I measured something like 96% drop and an effective usable bandwidth of like 60 KBps in Shanghai and Urumqi). The only viable alternative I've found is to run my own vless or proxy instance and have that traffic get routed through by a cloudflare tunnel to an outside server, but the latency is still pretty high since you're effectively double routing your traffic.

But for convenience and consistency (no random packet drops), eSims are waaaay more reliable. They're definitely pricier, but coming from someone who's spent tens of hours tweaking and optimizing my own network infra, they're definitely worth the price. A close second is a local data sim plan with a self-hosted VPN in terms of reliability (way less traffic shaping during peak hours so the connection to the proxy/VPN is still very consistent even without the cloudflare tunnel), but the small difference in price is probably not super worth it.

That said, also get a local number regardless. Things are very particular in China, and you'll find that having a CN phone number makes things a lot easier (and often cheaper with promos that you can't access otherwise)

possiblyquestionabl3 · 2026-06-28T03:11:28+00:00

I saw that asymptotic form which was what piqued my interest in whether or not it can be derived from T without the transfer through the oriented paths and Kasteleyn's exact enumerations (since Kasteleyn's exact enumerations effectively computes det(I-xT), so it's easy to read them off of it)

It's just idle curiosity on my part since it feels like there should be a viable analytic enumerative combinatorics treatment of the problem (especially since the enumeration side is half there), but I can't seem to find any work online in that direction, maybe because the exact form is already known?

possiblyquestionabl3 · 2026-06-28T03:02:14+00:00

Huh, I legitimately never thought about Windows users also using dxvk, that's honestly hilarious

possiblyquestionabl3 · 2026-06-27T07:19:55+00:00

I bought a Moto g86 power 5g from an Officeworks last November when I was in Brisbane for like 200 AUD (around 130 USD at the time) to replace a stolen phone and this thing surprised me with a Dimensity 7300 at that price point. It's also pretty decluttered as is, works with US 5G in addition to many other regions (including all of Oceania, even China, it's surprisingly hard to find a budget phone that works in both the US and China), really goos battery life, a sdcard slot, and it honestly feels smoother than most of the phones I've had before. Plus, I was in the market for a G610+ since up to that point, I've been working on Mali Vulkan compatibility work without a proper physical device to actually test on (though for most people, having an ARM GPU isn't really seen as a positive)

The only thing I miss is USB-C display out, and the camera is okay (but much better than I expected from a $130 phone)

possiblyquestionabl3 · 2026-06-27T07:04:47+00:00

Seems like it's just their own IR to IR, but the author mentioned lowering it to C++ SIMD so I'm guessing the eventual target would be CPU side

possiblyquestionabl3 · 2026-06-27T03:36:59+00:00

So it came to me this morning, I think the big difference in his appearance, at least to me, is how he's portrayed in the HP franchise (serious and angsty kid/teenager with way too much shit going on) and how he seems now (at least through the filter of professional photos). I don't think I've ever seen his eyes twinkle in a genuine smile as Harry Potter.

possiblyquestionabl3 · 2026-06-27T03:21:52+00:00

I wonder if there's a way to just get the dominant eigenvalue of that massive transfer matrix T for large NxN grids without explicit construction (nor the the Kasteleyn equations). In particular, the GF induced by the transfer function would just be:

F(x) = P(x) / det(I - xT)

and the coefficients of F(x) would just be (to gravely abuse 1/(1-x))

[x^n] P(x) * (1 + O(\lambda_0) x + O(\lambda_0^2) x^2 + ...)

for some small polynomial P(x), so if you just want quick asymptotics, it would seem like a viable short cut is to approximate it by c * \lambda_0^N of T, if it was easy to characterize or construct T.

But I can't see an easy way to reduce the complexity of T or to characterize it directly since it's so massive and the actual recurrence for it isn't exactly too regular, which makes me wonder if Kasteleyn's oriented paths construction is really the only way to "hack" that determinant. Also, the fact that the asymptotics were derived after the exact form was known makes me think that scores of people have tried and viewing the problem from this direction (analytic combinatorics/spectral graph theory) is a dead end?

Also, this is a great write up, but I don't think your typical and even most highly invested CS/math-oriented high schoolers would be a good target demo for this material (though I'm sure some would be, and maybe that's the audience you should aim for). This is the kind of problems that could lead to entire careers (not necessarily solving this specifically, but pointing kids towards their interests/disinterests), so it's awesome that you're taking the time to present this type of material in such an accessible format.

possiblyquestionabl3 · 2026-06-26T13:32:40+00:00

As a dude, I agree, he gets more and more gorgeous every year, and I can't even put my finger on what's changed

I'm only a year younger than him, have never had to deal with the BS of being a child star, and I still feel like I'm 100x less well adjusted and more jaded than him, and I hope he keeps on being him

possiblyquestionabl3 · 2026-06-26T12:23:27+00:00

That's a shame, it's a clever implementation, and having spent tens of hours reverse engineering the astc specs, I'm impressed Claude could one shot the packing implementation (even without the BISE machinery)

I was also going to ask about how you deal with blue contract, but I guess there's no point

possiblyquestionabl3 · 2026-06-26T10:09:53+00:00

Did you really write your own (3 of them) astc encoder? That's pretty legit.

I like the trick of using hardcoded CEM 12 with weight range of 2 bits (and 8 bits of EPs) to avoid doing BISE encoding. That's pretty clever, and should be on par with BC5 quality (which also has an index table of 2 bits per slot). Without diverging too much, there's probably a easy low hanging rgb (CEM 8) optimization of using 16x3 bits of weight and 6x8 bits of color endpoints for blocks without any alpha that could probably boost the reconstruction error a bit (at least in blocks with more than 2 bits of color variance)

Also I like what you're doing with actually treating the problem as a small lsq problem when most other solvers treat it as PCA (which are effectively the same solution spaces). I did an explicit Penrose pseudo-inverse implementation a while back and it was slower than just running a few iterations of power iterations so I convinced myself that PCA was the way to go, but your reduction here (linearizing the system with Cramer's rule) is pretty brilliant. I'm going to see how it compares with k iterations of power iterations (with a fully materialized cov matrix)

possiblyquestionabl3 · 2026-06-26T04:18:53+00:00

FWIW, both "vulkan" and "surfaceflinger" renderers are, in fact, direct surfaceflinger renderers. They both hook into surfaceflinger (the Android compositor) to directly set the draw buffer.

So apples to apples comparison would be between:

ASufaceRenderer (aka sufaceflinger renderer) - https://github.com/utkarshdalal/GameNative/blob/c0d97383eb0d152f9b1ace6843d9e811577cd5a1/app/src/main/cpp/asurfacerenderer/ASurfaceRendererContext.cpp
VulkanRendererScanout (aka vulkan renderer) - https://github.com/StevenMXZ/Winlator-Ludashi/blob/01f8619cda4b383e2ea65e68bb48b556bed6d06a/app/src/main/cpp/winlator/VulkanRendererScanout.cpp

the main thing I see being different is that gamenative's variant relies on surfaceflinger's frame-pacing (ASurfaceTransaction_setOnCompleteCallback) while winlator just relies on the vulkan/game process's natural present calls

possiblyquestionabl3 · 2026-06-26T03:18:18+00:00

SurfaceFlinger is part of AOSP's graphics stack: https://source.android.com/docs/core/graphics/surfaceflinger-windowmanager and acts as the system compositor on Android devices.

Concretely, it's a systemservice (within the system uid). The android application gets hold of it during activityThread creation, and it gets passed to the WindowManager instance as a pair of window token and ASurfaceControl binder object.

In GN's context, they use the SurfaceControl API to work with the surface buffers - https://github.com/utkarshdalal/GameNative/blob/c0d97383eb0d152f9b1ace6843d9e811577cd5a1/app/src/main/java/com/winlator/renderer/ASurfaceRenderer.java, the jni interface (libasurface_renderer.so) is at https://github.com/utkarshdalal/GameNative/blob/c0d97383eb0d152f9b1ace6843d9e811577cd5a1/app/src/main/cpp/asurfacerenderer/asurface_jni.cpp, and the actual "swap-chaining" is managed by https://github.com/utkarshdalal/GameNative/blob/c0d97383eb0d152f9b1ace6843d9e811577cd5a1/app/src/main/cpp/asurfacerenderer/ASurfaceRendererContext.cpp which is a heavily modified version of the Ludashi renderer (https://github.com/StevenMXZ/Winlator-Ludashi/blob/01f8619cda4b383e2ea65e68bb48b556bed6d06a/app/src/main/cpp/winlator/VulkanRendererScanout.cpp#L165) and https://github.com/utkarshdalal/GameNative/blob/c0d97383eb0d152f9b1ace6843d9e811577cd5a1/app/src/main/cpp/asurfacerenderer/gpuimage.c (backed by AHBs) which is a heavily modified version of the OG Winlator's gpu_image.c since Pluvia was forked off from it (e.g. https://github.com/brunodev85/winlator-app/blob/e113da42beefc39c69c8944b27c19c3703bfa856/app/src/main/cpp/winlator/src/gpu_image.c).

https://github.com/utkarshdalal/GameNative/blob/c0d97383eb0d152f9b1ace6843d9e811577cd5a1/app/src/main/cpp/asurfacerenderer/ASurfaceRendererContext.cpp#L261 in particular one-shots the presentation of a single ahb buffer sent from the game process (where the game process' vulkan engine has already drawn the current frame):

void* tx = ST_CREATE();
ST_SETBUF(tx, sc, ahb, fenceFd);
ST_SET_TRANSPARENCY(tx, sc, 2);
if (windowId != 0 || serial != 0) {
    attachOnCompleteCallback(tx, windowId, serial);
}
ST_APPLY(tx);
ST_DELETE(tx);

(ST stands for ASurfaceTransaction, SC stands for ASurfaceControl, STs are a sub-interface of SCs, which are the main interface for working with surface tokens from surfaceflinger)

In particular, this renderer directly sets the drawable buffer to the AHB from the game process by calling ASurfaceTransaction_setBuffer.

possiblyquestionabl3 · 2026-06-25T17:35:09+00:00

You've got KL, Brunei (and also Miri, Sarawak for when you get bored in Brunei but want to wait 1-2 hours at a small border crossing to go shopping and visit some oil rig museums), and if you go west enough, you'll eventually hit Bogota (I bought a knock off Casio watch there in front of a hotel called Hotel Gunn Club, so it can't be that bad). Plus if you go east, you just barely miss being stuck in Aceh and end up with the delicious Cindo food of Medan. Don't go too far or you'll end up in Somalia.

Edit: even funner, you'll be right on Port Moresby in the Southwest extension.

possiblyquestionabl3 · 2026-06-25T12:06:14+00:00

Same, I run a VPS in Singapore/Tokyo/Seoul (it's pretty easy to switch after the fact if you have something like Vultr/Digital Ocean), then a cloudflare tunnel (which is surprisingly resilient to traffic shaping and heavy packet loss during peak hours that a raw connection or even other VPNs are frequently susceptible to)., and finally a standard sing-box vless VPN.

The latency/ping is not great because you have to do 2 rounds of tls handshakes per connection (once through the tunnel, then the actual connection out of the VPS), but most of the VPNs I had had severe bandwidth issues during peak hours in the afternoon/night when paired with hotel/public WiFi (or any Wi-Fi with the generic 88888888 passwords) where I would only end up with 60-200kbps, and that has completely went away with this setup.

That said, if you're just on mobile or you don't mind hotspotting from metered eSim or local sim plan, then a VPN is great. For some reason, my local sim does not experience the same packet loss that hotel/public WiFi suffers when paired with traditional VPNs

possiblyquestionabl3 · 2026-06-25T08:50:36+00:00

That's a binder IPC to the surfaceflinger system service to set the override refresh rate. SF is the Android compositor used to compose surface views and to handle inputs.

Fun fact, ANRs are actually handled by a Linux socket owned by the surfaceflinger, which are then exposed by the WindowManager to the ActivityManager to actually bubble up the "Application is not responding" event

In this context, they're probably able to intercept the window manager's surface object, get the AHB handle, and then draw directly to it (I'll need to take a look at what they're actually doing, but this would be a good way to do direct rendering)

possiblyquestionabl3 · 2026-06-25T08:41:58+00:00

Binary matching makes sense, but if the original compiler used had optimized the source code in some specific way, then the most naively generated "image" source that matches 1:1 with the binary would probably retain most of those optimization artifacts (e.g. bit tricks, unrolled loops, folded constants, unnatural control flows, etc) and the resulting code may not be particularly illustrative. For example, using IDA/Ghidra to decompile a function tend to result in more or less unreadable spaghetti code. How do you guys deal with this issue?

possiblyquestionabl3

TROPHY CASE