HNHacker News
TopNewBestAskShowJobs

LegNeato

751 karma · joined May 2, 2013

I worked @ Robinhood on various things. I worked @ Facebook on mobile app releases. Before I worked @ Mozilla on Firefox releases. Before that, I worked @ Apple on Mac OS X releases.
submissionscomments
LegNeato··on Measuring the impact of AI on experienced open-source developer productivity
For certain tasks it can speed me up 30x compared to an expert in the space: https://rust-gpu.github.io/blog/2025/06/24/vulkan-shader-por...
LegNeato··on A critical look at MCP
GraphQL is transport agnostic
LegNeato··on An end to all this prostate trouble?
I worked at an auto parts retailer growing up in high school. I had very basic knowledge of cars. After working there for a year, someone could come in and describe what they were seeing and hearing and 80% of the time I could tell them what is wrong and what is needed. You'd be surprised at how a large population is similar for different 'paths' through the problem and solution space
LegNeato··on CubeCL: GPU Kernels in Rust for CUDA, ROCm, and WGPU
See also this overview for how it compares to other projects in the Rust and GPU ecosystem: https://rust-gpu.github.io/ecosystem/
LegNeato··on Zig and GPUs
See also https://github.com/Rust-GPU/rust-gpu and https://github.com/rust-gpu/rust-cuda
LegNeato··on Shadertoys Ported to Rust GPU
I have a WIP naga backend that converts glsl and hlsl to rust-gpu shaders.
LegNeato··on Shadertoys Ported to Rust GPU
Yes. Under the hood it uses wgpu and naga, which translates the SPIR-V into metal so it runs iOS and macOS (on Linux and Windows it uses spirv on vulkan directly)
LegNeato··on Rust CUDA Project
wgpu is CPU side, rust-gpu is GPU side. The projects work together (our latest post uses wgpu and we fixed bugs in it: https://rust-gpu.github.io/blog/2025/04/10/shadertoys )
LegNeato··on Rust CUDA Project
Maintainer here. It works on recent rust and latest CUDA. See https://rust-gpu.github.io/blog/2025/03/18/rust-cuda-update
LegNeato··on Rust CUDA Project
You can look to https://github.com/Rust-GPU/rust-gpu/ for vulkan.
LegNeato··on The next generation of Bazel builds
As the manager of the original Buck team, rules should not be starlark. They should be `wasm`.
LegNeato··on Nvidia adds native Python support to CUDA
Maintainer here. It is not broken, it works. See https://rust-gpu.github.io/blog/2025/03/18/rust-cuda-update
LegNeato··on Nvidia adds native Python support to CUDA
https://github.com/rust-gpu/rust-cuda
LegNeato··on Apple shuffles AI executive ranks in bid to turn around Siri
Sorry, I thought I was using your terminology. I ran pretty much all the updates (switched between majors and security updates and others with my team) as well as helped with the custom OSes for hardware released between. I was talking about 10.6.1, which included any fixes in a 1.1 respin. Apple's updates could be versioned (so, for example, you can have the 10.5.8 update v1.0, v1.1, etc.)...I am specifically talking about the first software update to the new OS.

I still believe you are right and wrong (which is why I put the "ish" on wrong).

"Every new major OS update introduces new bugs, that didn't exist in the previous OS, some of them horrible, and Snow Leopard was no exception" is not what folks are noticing when talking about Snow Leopard. People don't say Snow Leopard was great because it had no bugs, they say it was great because it had fewer bugs they experienced at release and converged quickly to something that was very stable, much more quickly than previous releases (and Leopard was a particularly long stabilization cycle right before it).

I do remember that bug you link, and I remember is was via migration assistant and required some convoluted steps to get in that state (IIRC it largely cropped up with people migrating their home from extremely old versions continuously, which was one of the QA tests we actually did but this issue was missed). There was much debate as to just how widespread it was (Apple didn't have telemetry at the time and had to rely on forums and apple care reports). The majority of people had no issues with SL, which was not the case with Leopard. Leopard's development internally was also more chaotic FWIW.

During that time period my team and I triaged every single Mac OS X bug coming into the company every morning. Trust me, SL was of higher quality than Leopard.

Nowadays, shipping is less of a major event due to CI, automated tests, betas, no CDs/DVDs, recovery partitions, etc. We're in a much better world!

LegNeato··on Apple shuffles AI executive ranks in bid to turn around Siri
As the person who personally ran 10.6 v1.1 at Apple (and 10.5.8), you are wrong(ish).

The new version of the OS was always being developed in a branch/train, and fixes were backported to the current version as they were found. They weren't developed linearly / one after another. So yeah, if you are comparing the most stable polished/fixed/stagnant last major version with the brand new 1.0 major version branch, the newer major is going to be buggier. That would be the case with every y.0 vs x.8. But if you are comparing major OS versions, Snow Leopard was different.

Snow Leopard's stated goal internally was reducing bugs and increasing quality. If you wanted to ship a feature you had to get explicit approval. In feature releases it was bottom up "here is what we are planning to ship" and in Snow Leopard it was top down "can we ship this?".

AFAIK Snow Leopard was the first release of this kind (the first release I worked on was Jaguar or Puma), and was a direct response to taking 8 software updates to stabilize 10.5 and the severity of the bugs found during that cycle and the resulting bad press. Leopard was a HUGE feature release and with it came tons of (bad) bugs.

The Apple v1.1 software updates always fixed critical bugs, because:

1. You had to GM / freeze the software to physically create the CDs/DVDs around a month before the release. Bugs found after this process required a repress (can't remember the phrase we used), which cost money and time and scrambled effort at the last minute and added risk. This means the bar was super high, and most "bad, but not can't use your computer bad" bugs were put in v1.1...which was developed concurrently with the end of v1.0 (hence why v1.1s came out right away)

2. Testing was basically engineers, internal QA, some strategic partners like Adobe and MS, and the Apple Seed program (which was tiny). There was very little automated testing. Apple employees are not representative of the population and QA coverage is never very complete. And we sometimes held back features from seed releases when we were worried about leaks, so it wasn't even the complete OS that was being tested.

A v1.1 was always needed, though the issues they fixed became less severe over time due to larger seeds (aka betas), recovery partitions, and better / more modern development practices.

LegNeato··on H3: For indexing geographies into a hexagonal grid, by Uber
There is a super high quality Rust lib that implements this: https://github.com/HydroniumLabs/h3o
LegNeato··on Introduction to CUDA programming for Python developers
I am in the process of rebooting it: https://rust-gpu.github.io/blog/2025/01/27/rust-cuda-reboot/
LegNeato··on Introduction to CUDA programming for Python developers
Also check out https://github.com/rust-gpu/rust-gpu and https://github.com/rust-gpu/rust-cuda
LegNeato··on Show HN: New approach for CI/CD/compute system
You are mistaken on many accounts:

1. Bazel/Buck is not just for building, it is a task runner with built in distributed execution and caching. Which is, uh, what CI is.

2. You not finding it useful might be because you want to continue to use the same methods and tools yet get different results. Bazel/Buck supports Go and Rust and those just fine (JS is steadily improving as well, I know multiple public companies using it). Now, the DX may be different or non-standard but that's the point...different methods for different results. Of course there are tradeoffs to it not being the standard way to do things for a particular language!

3. You can run postgresql/redis/what have you into the environment with Bazel/Buck, all the companies using these tools do it. Almost everyone wires it up to https://testcontainers.com/, see https://www.docker.com/blog/revolutionize-your-ci-cd-pipelin....

4. For integrating the entire lifecycle, this is how it is set up at most companies...use Bazel/Buck for building the environment, use Bazel/Buck for building, use Bazel/Buck to trigger a deploy, etc. For example, see https://github.com/adobe/rules_gitops

Again, not trying to be rude, just drop info. Your list of pain points in the post is real, but only with certain / older systems or ways of using them. If you look into the newer systems, you'll see that they were largely created to solve those issues!

LegNeato··on Show HN: New approach for CI/CD/compute system
As someone who lead this space at multiple FAANGs, just use Bazel or Buck2 and have whatever CI call it. CI should be one line(-ish) calling a local tool. "Fat" CI is an anti-pattern. The problem is not the CI tools you mention are bad and the only thing available, the problem is that newer tools and methods solving these issues are not known or adopted.

And if those don't work for you, build custom on something like Temporal.

LegNeato··on Translating 10M lines of Java to Kotlin
You are getting the details wrong (I was there). This was the single DEX limit, and Google would just bump it in AOSP every time their own apps hit it (as their apps didn't support older OS versions). FB at the time was supporting back to froyo, which had a much lower limit than "modern" apps needed. See this note for more info: https://www.facebook.com/notes/10158791578712200/
LegNeato··on Using Libc for GPUs
If you are interested in this, you might be interested in Rust GPU: https://rust-gpu.github.io/
LegNeato··on How AMD Is Taking Standard C/C++ Code to Run Directly on GPUs
Also check out Rust GPU, which aims to do the same for Rust: https://github.com/Rust-GPU/rust-gpu
LegNeato··on Optimizing a Rust GPU matmul kernel
CUDA has support for complex numbers and some NVIDIA frameworks use and expose it (https://nvidia.github.io/cccl/thrust/api/structthrust_1_1com...).

For Rust GPU, nothing built in but there are libraries like https://github.com/rust-num/num-complex that support `no_std` and should work on the GPU. I've never used them so I don't know what (if any) the perf hit would be.

LegNeato··on Optimizing a Rust GPU matmul kernel
The goal is to handle things similar to how rust on the CPU does (shared traits with different implementations, intrinsics, platform-specific modules, user replaceable traits like alloc or panic handler and "asm" as a last ditch case).

We already have a lot (we have many intrinsics and an `arch` module like `std::arch`, asm! to include raw spirv, etc). For example, here are the intrinsics: https://rust-gpu.github.io/rust-gpu/api/spirv_std/arch/index... and here is support for ray tracing (which obviously is not on every card: https://rust-gpu.github.io/rust-gpu/api/spirv_std/ray_tracin...).

Vulkan has a way to query and specify different GPU capabilities and Rust-GPU uses that.

Rust and Vulkan have many of the tools we need for progressive enhancement, we are not focused on lowest common denominator.

LegNeato··on The Slang Shading Language
It's not just syntax, it is semantics as well.
LegNeato··on The Slang Shading Language
Also check out Rust GPU, which has similar features and uses Rust rather than a new language:

https://github.com/Rust-GPU/rust-gpu

LegNeato··on What's Next for WebGPU
Check out https://renderling.xyz/
LegNeato··on C Compiler to SPIR-V
Similar project but for Rust: https://github.com/Rust-GPU/rust-gpu
LegNeato··on Trap – Transformers in APL
Check out https://github.com/Rust-GPU/rust-gpu if you have not seen it
← PreviousPage 3 of 5Next →